[mirror_qemu.git] / audio / dbusaudio.c

/*
 * QEMU DBus audio
 *
 * Copyright (c) 2021 Red Hat, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include "qemu/osdep.h"
#include "qemu/error-report.h"
#include "qemu/host-utils.h"
#include "qemu/module.h"
#include "qemu/timer.h"
#include "qemu/dbus.h"

#include <gio/gunixfdlist.h>
#include "ui/dbus-display1.h"

#define AUDIO_CAP "dbus"
#include "audio.h"
#include "audio_int.h"
#include "trace.h"

#define DBUS_DISPLAY1_AUDIO_PATH DBUS_DISPLAY1_ROOT "/Audio"

#define DBUS_AUDIO_NSAMPLES 1024 /* could be configured? */

typedef struct DBusAudio {
    GDBusObjectManagerServer *server;
    GDBusObjectSkeleton *audio;
    QemuDBusDisplay1Audio *iface;
    GHashTable *out_listeners;
    GHashTable *in_listeners;
} DBusAudio;

typedef struct DBusVoiceOut {
    HWVoiceOut hw;
    bool enabled;
    RateCtl rate;

    void *buf;
    size_t buf_pos;
    size_t buf_size;

    bool has_volume;
    Volume volume;
} DBusVoiceOut;

typedef struct DBusVoiceIn {
    HWVoiceIn hw;
    bool enabled;
    RateCtl rate;

    bool has_volume;
    Volume volume;
} DBusVoiceIn;

static void *dbus_get_buffer_out(HWVoiceOut *hw, size_t *size)
{
    DBusVoiceOut *vo = container_of(hw, DBusVoiceOut, hw);

    if (!vo->buf) {
        vo->buf_size = hw->samples * hw->info.bytes_per_frame;
        vo->buf = g_malloc(vo->buf_size);
        vo->buf_pos = 0;
    }

    *size = MIN(vo->buf_size - vo->buf_pos, *size);
    *size = audio_rate_get_bytes(&hw->info, &vo->rate, *size);

    return vo->buf + vo->buf_pos;

}

static size_t dbus_put_buffer_out(HWVoiceOut *hw, void *buf, size_t size)
{
    DBusAudio *da = (DBusAudio *)hw->s->drv_opaque;
    DBusVoiceOut *vo = container_of(hw, DBusVoiceOut, hw);
    GHashTableIter iter;
    QemuDBusDisplay1AudioOutListener *listener = NULL;
    g_autoptr(GBytes) bytes = NULL;
    g_autoptr(GVariant) v_data = NULL;

    assert(buf == vo->buf + vo->buf_pos && vo->buf_pos + size <= vo->buf_size);
    vo->buf_pos += size;

    trace_dbus_audio_put_buffer_out(size);

    if (vo->buf_pos < vo->buf_size) {
        return size;
    }

    bytes = g_bytes_new_take(g_steal_pointer(&vo->buf), vo->buf_size);
    v_data = g_variant_new_from_bytes(G_VARIANT_TYPE("ay"), bytes, TRUE);
    g_variant_ref_sink(v_data);

    g_hash_table_iter_init(&iter, da->out_listeners);
    while (g_hash_table_iter_next(&iter, NULL, (void **)&listener)) {
        qemu_dbus_display1_audio_out_listener_call_write(
            listener,
            (uintptr_t)hw,
            v_data,
            G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
    }

    return size;
}

#ifdef HOST_WORDS_BIGENDIAN
#define AUDIO_HOST_BE TRUE
#else
#define AUDIO_HOST_BE FALSE
#endif

static void
dbus_init_out_listener(QemuDBusDisplay1AudioOutListener *listener,
                       HWVoiceOut *hw)
{
    qemu_dbus_display1_audio_out_listener_call_init(
        listener,
        (uintptr_t)hw,
        hw->info.bits,
        hw->info.is_signed,
        hw->info.is_float,
        hw->info.freq,
        hw->info.nchannels,
        hw->info.bytes_per_frame,
        hw->info.bytes_per_second,
        hw->info.swap_endianness ? !AUDIO_HOST_BE : AUDIO_HOST_BE,
        G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
}

static int
dbus_init_out(HWVoiceOut *hw, struct audsettings *as, void *drv_opaque)
{
    DBusAudio *da = (DBusAudio *)hw->s->drv_opaque;
    DBusVoiceOut *vo = container_of(hw, DBusVoiceOut, hw);
    GHashTableIter iter;
    QemuDBusDisplay1AudioOutListener *listener = NULL;

    audio_pcm_init_info(&hw->info, as);
    hw->samples = DBUS_AUDIO_NSAMPLES;
    audio_rate_start(&vo->rate);

    g_hash_table_iter_init(&iter, da->out_listeners);
    while (g_hash_table_iter_next(&iter, NULL, (void **)&listener)) {
        dbus_init_out_listener(listener, hw);
    }
    return 0;
}

static void
dbus_fini_out(HWVoiceOut *hw)
{
    DBusAudio *da = (DBusAudio *)hw->s->drv_opaque;
    DBusVoiceOut *vo = container_of(hw, DBusVoiceOut, hw);
    GHashTableIter iter;
    QemuDBusDisplay1AudioOutListener *listener = NULL;

    g_hash_table_iter_init(&iter, da->out_listeners);
    while (g_hash_table_iter_next(&iter, NULL, (void **)&listener)) {
        qemu_dbus_display1_audio_out_listener_call_fini(
            listener,
            (uintptr_t)hw,
            G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
    }

    g_clear_pointer(&vo->buf, g_free);
}

static void
dbus_enable_out(HWVoiceOut *hw, bool enable)
{
    DBusAudio *da = (DBusAudio *)hw->s->drv_opaque;
    DBusVoiceOut *vo = container_of(hw, DBusVoiceOut, hw);
    GHashTableIter iter;
    QemuDBusDisplay1AudioOutListener *listener = NULL;

    vo->enabled = enable;
    if (enable) {
        audio_rate_start(&vo->rate);
    }

    g_hash_table_iter_init(&iter, da->out_listeners);
    while (g_hash_table_iter_next(&iter, NULL, (void **)&listener)) {
        qemu_dbus_display1_audio_out_listener_call_set_enabled(
            listener, (uintptr_t)hw, enable,
            G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
    }
}

static void
dbus_volume_out_listener(HWVoiceOut *hw,
                         QemuDBusDisplay1AudioOutListener *listener)
{
    DBusVoiceOut *vo = container_of(hw, DBusVoiceOut, hw);
    Volume *vol = &vo->volume;
    g_autoptr(GBytes) bytes = NULL;
    GVariant *v_vol = NULL;

    if (!vo->has_volume) {
        return;
    }

    assert(vol->channels < sizeof(vol->vol));
    bytes = g_bytes_new(vol->vol, vol->channels);
    v_vol = g_variant_new_from_bytes(G_VARIANT_TYPE("ay"), bytes, TRUE);
    qemu_dbus_display1_audio_out_listener_call_set_volume(
        listener, (uintptr_t)hw, vol->mute, v_vol,
        G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
}

static void
dbus_volume_out(HWVoiceOut *hw, Volume *vol)
{
    DBusAudio *da = (DBusAudio *)hw->s->drv_opaque;
    DBusVoiceOut *vo = container_of(hw, DBusVoiceOut, hw);
    GHashTableIter iter;
    QemuDBusDisplay1AudioOutListener *listener = NULL;

    vo->has_volume = true;
    vo->volume = *vol;

    g_hash_table_iter_init(&iter, da->out_listeners);
    while (g_hash_table_iter_next(&iter, NULL, (void **)&listener)) {
        dbus_volume_out_listener(hw, listener);
    }
}

static void
dbus_init_in_listener(QemuDBusDisplay1AudioInListener *listener, HWVoiceIn *hw)
{
    qemu_dbus_display1_audio_in_listener_call_init(
        listener,
        (uintptr_t)hw,
        hw->info.bits,
        hw->info.is_signed,
        hw->info.is_float,
        hw->info.freq,
        hw->info.nchannels,
        hw->info.bytes_per_frame,
        hw->info.bytes_per_second,
        hw->info.swap_endianness ? !AUDIO_HOST_BE : AUDIO_HOST_BE,
        G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
}

static int
dbus_init_in(HWVoiceIn *hw, struct audsettings *as, void *drv_opaque)
{
    DBusAudio *da = (DBusAudio *)hw->s->drv_opaque;
    DBusVoiceIn *vo = container_of(hw, DBusVoiceIn, hw);
    GHashTableIter iter;
    QemuDBusDisplay1AudioInListener *listener = NULL;

    audio_pcm_init_info(&hw->info, as);
    hw->samples = DBUS_AUDIO_NSAMPLES;
    audio_rate_start(&vo->rate);

    g_hash_table_iter_init(&iter, da->in_listeners);
    while (g_hash_table_iter_next(&iter, NULL, (void **)&listener)) {
        dbus_init_in_listener(listener, hw);
    }
    return 0;
}

static void
dbus_fini_in(HWVoiceIn *hw)
{
    DBusAudio *da = (DBusAudio *)hw->s->drv_opaque;
    GHashTableIter iter;
    QemuDBusDisplay1AudioInListener *listener = NULL;

    g_hash_table_iter_init(&iter, da->in_listeners);
    while (g_hash_table_iter_next(&iter, NULL, (void **)&listener)) {
        qemu_dbus_display1_audio_in_listener_call_fini(
            listener,
            (uintptr_t)hw,
            G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
    }
}

static void
dbus_volume_in_listener(HWVoiceIn *hw,
                         QemuDBusDisplay1AudioInListener *listener)
{
    DBusVoiceIn *vo = container_of(hw, DBusVoiceIn, hw);
    Volume *vol = &vo->volume;
    g_autoptr(GBytes) bytes = NULL;
    GVariant *v_vol = NULL;

    if (!vo->has_volume) {
        return;
    }

    assert(vol->channels < sizeof(vol->vol));
    bytes = g_bytes_new(vol->vol, vol->channels);
    v_vol = g_variant_new_from_bytes(G_VARIANT_TYPE("ay"), bytes, TRUE);
    qemu_dbus_display1_audio_in_listener_call_set_volume(
        listener, (uintptr_t)hw, vol->mute, v_vol,
        G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
}

static void
dbus_volume_in(HWVoiceIn *hw, Volume *vol)
{
    DBusAudio *da = (DBusAudio *)hw->s->drv_opaque;
    DBusVoiceIn *vo = container_of(hw, DBusVoiceIn, hw);
    GHashTableIter iter;
    QemuDBusDisplay1AudioInListener *listener = NULL;

    vo->has_volume = true;
    vo->volume = *vol;

    g_hash_table_iter_init(&iter, da->in_listeners);
    while (g_hash_table_iter_next(&iter, NULL, (void **)&listener)) {
        dbus_volume_in_listener(hw, listener);
    }
}

static size_t
dbus_read(HWVoiceIn *hw, void *buf, size_t size)
{
    DBusAudio *da = (DBusAudio *)hw->s->drv_opaque;
    /* DBusVoiceIn *vo = container_of(hw, DBusVoiceIn, hw); */
    GHashTableIter iter;
    QemuDBusDisplay1AudioInListener *listener = NULL;

    trace_dbus_audio_read(size);

    /* size = audio_rate_get_bytes(&hw->info, &vo->rate, size); */

    g_hash_table_iter_init(&iter, da->in_listeners);
    while (g_hash_table_iter_next(&iter, NULL, (void **)&listener)) {
        g_autoptr(GVariant) v_data = NULL;
        const char *data;
        gsize n = 0;

        if (qemu_dbus_display1_audio_in_listener_call_read_sync(
                listener,
                (uintptr_t)hw,
                size,
                G_DBUS_CALL_FLAGS_NONE, -1,
                &v_data, NULL, NULL)) {
            data = g_variant_get_fixed_array(v_data, &n, 1);
            g_warn_if_fail(n <= size);
            size = MIN(n, size);
            memcpy(buf, data, size);
            break;
        }
    }

    return size;
}

static void
dbus_enable_in(HWVoiceIn *hw, bool enable)
{
    DBusAudio *da = (DBusAudio *)hw->s->drv_opaque;
    DBusVoiceIn *vo = container_of(hw, DBusVoiceIn, hw);
    GHashTableIter iter;
    QemuDBusDisplay1AudioInListener *listener = NULL;

    vo->enabled = enable;
    if (enable) {
        audio_rate_start(&vo->rate);
    }

    g_hash_table_iter_init(&iter, da->in_listeners);
    while (g_hash_table_iter_next(&iter, NULL, (void **)&listener)) {
        qemu_dbus_display1_audio_in_listener_call_set_enabled(
            listener, (uintptr_t)hw, enable,
            G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
    }
}

static void *
dbus_audio_init(Audiodev *dev)
{
    DBusAudio *da = g_new0(DBusAudio, 1);

    da->out_listeners = g_hash_table_new_full(g_str_hash, g_str_equal,
                                                g_free, g_object_unref);
    da->in_listeners = g_hash_table_new_full(g_str_hash, g_str_equal,
                                               g_free, g_object_unref);
    return da;
}

static void
dbus_audio_fini(void *opaque)
{
    DBusAudio *da = opaque;

    if (da->server) {
        g_dbus_object_manager_server_unexport(da->server,
                                              DBUS_DISPLAY1_AUDIO_PATH);
    }
    g_clear_object(&da->audio);
    g_clear_object(&da->iface);
    g_clear_pointer(&da->in_listeners, g_hash_table_unref);
    g_clear_pointer(&da->out_listeners, g_hash_table_unref);
    g_clear_object(&da->server);
    g_free(da);
}

static void
listener_out_vanished_cb(GDBusConnection *connection,
                         gboolean remote_peer_vanished,
                         GError *error,
                         DBusAudio *da)
{
    char *name = g_object_get_data(G_OBJECT(connection), "name");

    g_hash_table_remove(da->out_listeners, name);
}

static void
listener_in_vanished_cb(GDBusConnection *connection,
                        gboolean remote_peer_vanished,
                        GError *error,
                        DBusAudio *da)
{
    char *name = g_object_get_data(G_OBJECT(connection), "name");

    g_hash_table_remove(da->in_listeners, name);
}

static gboolean
dbus_audio_register_listener(AudioState *s,
                             GDBusMethodInvocation *invocation,
                             GUnixFDList *fd_list,
                             GVariant *arg_listener,
                             bool out)
{
    DBusAudio *da = s->drv_opaque;
    const char *sender = g_dbus_method_invocation_get_sender(invocation);
    g_autoptr(GDBusConnection) listener_conn = NULL;
    g_autoptr(GError) err = NULL;
    g_autoptr(GSocket) socket = NULL;
    g_autoptr(GSocketConnection) socket_conn = NULL;
    g_autofree char *guid = g_dbus_generate_guid();
    GHashTable *listeners = out ? da->out_listeners : da->in_listeners;
    GObject *listener;
    int fd;

    trace_dbus_audio_register(sender, out ? "out" : "in");

    if (g_hash_table_contains(listeners, sender)) {
        g_dbus_method_invocation_return_error(invocation,
                                              DBUS_DISPLAY_ERROR,
                                              DBUS_DISPLAY_ERROR_INVALID,
                                              "`%s` is already registered!",
                                              sender);
        return DBUS_METHOD_INVOCATION_HANDLED;
    }

    fd = g_unix_fd_list_get(fd_list, g_variant_get_handle(arg_listener), &err);
    if (err) {
        g_dbus_method_invocation_return_error(invocation,
                                              DBUS_DISPLAY_ERROR,
                                              DBUS_DISPLAY_ERROR_FAILED,
                                              "Couldn't get peer fd: %s",
                                              err->message);
        return DBUS_METHOD_INVOCATION_HANDLED;
    }

    socket = g_socket_new_from_fd(fd, &err);
    if (err) {
        g_dbus_method_invocation_return_error(invocation,
                                              DBUS_DISPLAY_ERROR,
                                              DBUS_DISPLAY_ERROR_FAILED,
                                              "Couldn't make a socket: %s",
                                              err->message);
        return DBUS_METHOD_INVOCATION_HANDLED;
    }
    socket_conn = g_socket_connection_factory_create_connection(socket);
    if (out) {
        qemu_dbus_display1_audio_complete_register_out_listener(
            da->iface, invocation, NULL);
    } else {
        qemu_dbus_display1_audio_complete_register_in_listener(
            da->iface, invocation, NULL);
    }

    listener_conn =
        g_dbus_connection_new_sync(
            G_IO_STREAM(socket_conn),
            guid,
            G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER,
            NULL, NULL, &err);
    if (err) {
        error_report("Failed to setup peer connection: %s", err->message);
        return DBUS_METHOD_INVOCATION_HANDLED;
    }

    listener = out ?
        G_OBJECT(qemu_dbus_display1_audio_out_listener_proxy_new_sync(
            listener_conn,
            G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
            NULL,
            "/org/qemu/Display1/AudioOutListener",
            NULL,
            &err)) :
        G_OBJECT(qemu_dbus_display1_audio_in_listener_proxy_new_sync(
            listener_conn,
            G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
            NULL,
            "/org/qemu/Display1/AudioInListener",
            NULL,
            &err));
    if (!listener) {
        error_report("Failed to setup proxy: %s", err->message);
        return DBUS_METHOD_INVOCATION_HANDLED;
    }

    if (out) {
        HWVoiceOut *hw;

        QLIST_FOREACH(hw, &s->hw_head_out, entries) {
            DBusVoiceOut *vo = container_of(hw, DBusVoiceOut, hw);
            QemuDBusDisplay1AudioOutListener *l =
                QEMU_DBUS_DISPLAY1_AUDIO_OUT_LISTENER(listener);

            dbus_init_out_listener(l, hw);
            qemu_dbus_display1_audio_out_listener_call_set_enabled(
                l, (uintptr_t)hw, vo->enabled,
                G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
        }
    } else {
        HWVoiceIn *hw;

        QLIST_FOREACH(hw, &s->hw_head_in, entries) {
            DBusVoiceIn *vo = container_of(hw, DBusVoiceIn, hw);
            QemuDBusDisplay1AudioInListener *l =
                QEMU_DBUS_DISPLAY1_AUDIO_IN_LISTENER(listener);

            dbus_init_in_listener(
                QEMU_DBUS_DISPLAY1_AUDIO_IN_LISTENER(listener), hw);
            qemu_dbus_display1_audio_in_listener_call_set_enabled(
                l, (uintptr_t)hw, vo->enabled,
                G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
        }
    }

    g_object_set_data_full(G_OBJECT(listener_conn), "name",
                           g_strdup(sender), g_free);
    g_hash_table_insert(listeners, g_strdup(sender), listener);
    g_object_connect(listener_conn,
                     "signal::closed",
                     out ? listener_out_vanished_cb : listener_in_vanished_cb,
                     da,
                     NULL);

    return DBUS_METHOD_INVOCATION_HANDLED;
}

static gboolean
dbus_audio_register_out_listener(AudioState *s,
                                 GDBusMethodInvocation *invocation,
                                 GUnixFDList *fd_list,
                                 GVariant *arg_listener)
{
    return dbus_audio_register_listener(s, invocation,
                                        fd_list, arg_listener, true);

}

static gboolean
dbus_audio_register_in_listener(AudioState *s,
                                GDBusMethodInvocation *invocation,
                                GUnixFDList *fd_list,
                                GVariant *arg_listener)
{
    return dbus_audio_register_listener(s, invocation,
                                        fd_list, arg_listener, false);
}

static void
dbus_audio_set_server(AudioState *s, GDBusObjectManagerServer *server)
{
    DBusAudio *da = s->drv_opaque;

    g_assert(da);
    g_assert(!da->server);

    da->server = g_object_ref(server);

    da->audio = g_dbus_object_skeleton_new(DBUS_DISPLAY1_AUDIO_PATH);
    da->iface = qemu_dbus_display1_audio_skeleton_new();
    g_object_connect(da->iface,
                     "swapped-signal::handle-register-in-listener",
                     dbus_audio_register_in_listener, s,
                     "swapped-signal::handle-register-out-listener",
                     dbus_audio_register_out_listener, s,
                     NULL);

    g_dbus_object_skeleton_add_interface(G_DBUS_OBJECT_SKELETON(da->audio),
                                         G_DBUS_INTERFACE_SKELETON(da->iface));
    g_dbus_object_manager_server_export(da->server, da->audio);
}

static struct audio_pcm_ops dbus_pcm_ops = {
    .init_out = dbus_init_out,
    .fini_out = dbus_fini_out,
    .write    = audio_generic_write,
    .get_buffer_out = dbus_get_buffer_out,
    .put_buffer_out = dbus_put_buffer_out,
    .enable_out = dbus_enable_out,
    .volume_out = dbus_volume_out,

    .init_in  = dbus_init_in,
    .fini_in  = dbus_fini_in,
    .read     = dbus_read,
    .run_buffer_in = audio_generic_run_buffer_in,
    .enable_in = dbus_enable_in,
    .volume_in = dbus_volume_in,
};

static struct audio_driver dbus_audio_driver = {
    .name            = "dbus",
    .descr           = "Timer based audio exposed with DBus interface",
    .init            = dbus_audio_init,
    .fini            = dbus_audio_fini,
    .set_dbus_server = dbus_audio_set_server,
    .pcm_ops         = &dbus_pcm_ops,
    .can_be_default  = 1,
    .max_voices_out  = INT_MAX,
    .max_voices_in   = INT_MAX,
    .voice_size_out  = sizeof(DBusVoiceOut),
    .voice_size_in   = sizeof(DBusVoiceIn)
};

static void register_audio_dbus(void)
{
    audio_driver_register(&dbus_audio_driver);
}
type_init(register_audio_dbus);

module_dep("ui-dbus")
Commit	Line	Data
739362d4 MAL	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(&hw->info, &vo->rate, 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	#ifdef HOST_WORDS_BIGENDIAN
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(&hw->info, &vo->rate, 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")