From nobody Sat May 18 17:34:37 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=redhat.com ARC-Seal: i=1; a=rsa-sha256; t=1676366748; cv=none; d=zohomail.com; s=zohoarc; b=SXnmUvg5ocT8QaH5zCaux4JW0H/JV/zoMT9Hy0bfObxn7TVOl/arb+7Ol5iSnEuJ0gDJ/3Vp+DOWoCNi74vpd+06brh3u7E2u7Ac6Q7N7ZYHM4d1DQG7DOdAZBZ07XT24KE/XVgcTL1BlVOyLLfpSIL0Ew3d+wSWVasZCBYERKI= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1676366748; h=Content-Transfer-Encoding:Cc:Date:From:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Sender:Subject:To; bh=p9i+p8l1DNdOh5jDjRcnOASjpjOfz1crdaH9PNGOpOU=; b=THoEZXUuV/L0VPKYdeEaNo9u1LamqZd1ExeKuEx2okk7CvIl0t2OQ7uVCHNCr1LkSzc/KyIkb29IVcZcLbceRrVdGhQm+A8fEw9DXwsct4LXJihQnNy87Y64Q8sqKeUhk9WZilb1kOu3KoDO/hpfpdj23GmC9BCmA6hMZTcfEno= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1676366748750814.8783342184556; Tue, 14 Feb 2023 01:25:48 -0800 (PST) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1pRrZH-0008Vh-9B; Tue, 14 Feb 2023 04:25:43 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pRrZE-0008Lt-Jb for qemu-devel@nongnu.org; Tue, 14 Feb 2023 04:25:41 -0500 Received: from us-smtp-delivery-124.mimecast.com ([170.10.129.124]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pRrZA-0007kA-6n for qemu-devel@nongnu.org; Tue, 14 Feb 2023 04:25:39 -0500 Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-8-6xs7slLgP5exCeKKxltTdQ-1; Tue, 14 Feb 2023 04:23:56 -0500 Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.rdu2.redhat.com [10.11.54.5]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 7D5AC87B2A2 for ; Tue, 14 Feb 2023 09:23:56 +0000 (UTC) Received: from ovpn-192-50.brq.redhat.com (ovpn-192-50.brq.redhat.com [10.40.192.50]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 3F4D018EC2; Tue, 14 Feb 2023 09:23:55 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1676366734; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding; bh=p9i+p8l1DNdOh5jDjRcnOASjpjOfz1crdaH9PNGOpOU=; b=ShwEvy0o6MyMecbeF/OxJZBOG43CSQWW3esz213btrdoq9vF3qumfCHu0RaAm1o8c9dc5E EXwZdqUIaB6JJ03Q+pDMrk8tf1+Q1ADu+V3XVpkuZ7PHlBwaMbemgDOJklKLXO0aecHCNY BHugC8s/wofYPi9Ku35Ox9+6mZ4ceXY= X-MC-Unique: 6xs7slLgP5exCeKKxltTdQ-1 From: Dorinda Bassey To: qemu-devel@nongnu.org Cc: Dorinda Bassey Subject: [PATCH] audio/pwaudio.c: Add Pipewire audio backend for QEMU Date: Tue, 14 Feb 2023 10:23:43 +0100 Message-Id: <20230214092343.399435-1-dbassey@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Scanned-By: MIMEDefang 3.1 on 10.11.54.5 Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=170.10.129.124; envelope-from=dbassey@redhat.com; helo=us-smtp-delivery-124.mimecast.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, RCVD_IN_MSPIKE_H2=-0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @redhat.com) X-ZM-MESSAGEID: 1676366750203100003 Content-Type: text/plain; charset="utf-8" This commit adds a new audiodev backend to allow QEMU to use Pipewire as bo= th an audio sink and source. This backend is available on most systems. Added Pipewire entry points for QEMU Pipewire audio backend Added wrappers for QEMU Pipewire audio backend in qpw_pcm_ops() qpw_write function returns the current state of the stream to pwaudio and W= rites some data to the server for playback streams using pipewire spa_ringb= uffer implementation. qpw_read function returns the current state of the stream to pwaudio and Re= ads some data from the server for capture streams using pipewire spa_ringbu= ffer implementation. These functions qpw_write and qpw_read are called during playback and captu= re. Added some functions that convert pw audio formats to QEMU audio format and= vice versa which would be needed in the pipewire audio sink and source fun= ctions qpw_init_in() & qpw_init_out(). These methods that implement playbac= k and recording will create streams for playback and capture that will star= t processing and will result in the on_process callbacks to be called. Built a connection to the Pipewire sound system server in the qpw_audio_ini= t() method. Signed-off-by: Dorinda Bassey --- audio/audio.c | 3 + audio/audio_template.h | 4 + audio/meson.build | 1 + audio/pwaudio.c | 816 ++++++++++++++++++++++++++++++++++ meson.build | 7 + meson_options.txt | 4 +- qapi/audio.json | 45 ++ qemu-options.hx | 17 + scripts/meson-buildoptions.sh | 8 +- 9 files changed, 902 insertions(+), 3 deletions(-) create mode 100644 audio/pwaudio.c diff --git a/audio/audio.c b/audio/audio.c index 4290309d18..ed8616d56d 100644 --- a/audio/audio.c +++ b/audio/audio.c @@ -2069,6 +2069,9 @@ void audio_create_pdos(Audiodev *dev) #ifdef CONFIG_AUDIO_PA CASE(PA, pa, Pa); #endif +#ifdef CONFIG_AUDIO_PA + CASE(PW, pw, Pw); +#endif #ifdef CONFIG_AUDIO_SDL CASE(SDL, sdl, Sdl); #endif diff --git a/audio/audio_template.h b/audio/audio_template.h index 42b4712acb..18d1ab0a77 100644 --- a/audio/audio_template.h +++ b/audio/audio_template.h @@ -355,6 +355,10 @@ AudiodevPerDirectionOptions *glue(audio_get_pdo_, TYPE= )(Audiodev *dev) case AUDIODEV_DRIVER_PA: return qapi_AudiodevPaPerDirectionOptions_base(dev->u.pa.TYPE); #endif +#ifdef CONFIG_AUDIO_PW + case AUDIODEV_DRIVER_PW: + return qapi_AudiodevPwPerDirectionOptions_base(dev->u.pw.TYPE); +#endif #ifdef CONFIG_AUDIO_SDL case AUDIODEV_DRIVER_SDL: return qapi_AudiodevSdlPerDirectionOptions_base(dev->u.sdl.TYPE); diff --git a/audio/meson.build b/audio/meson.build index 0722224ba9..309bdfd228 100644 --- a/audio/meson.build +++ b/audio/meson.build @@ -19,6 +19,7 @@ foreach m : [ ['sdl', sdl, files('sdlaudio.c')], ['jack', jack, files('jackaudio.c')], ['sndio', sndio, files('sndioaudio.c')], + ['pw', pipewire, files('pwaudio.c')], ['spice', spice, files('spiceaudio.c')] ] if m[1].found() diff --git a/audio/pwaudio.c b/audio/pwaudio.c new file mode 100644 index 0000000000..89040ac99e --- /dev/null +++ b/audio/pwaudio.c @@ -0,0 +1,816 @@ +/* + * QEMU Pipewire audio driver + * + * Copyright (c) 2023, Red Hat Inc, Dorinda Bassey + * + * Permission is hereby granted, free of charge, to any person obtaining a= copy + * of this software and associated documentation files (the "Software"), t= o deal + * in the Software without restriction, including without limitation the r= ights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or se= ll + * 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 OT= HER + * 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/module.h" +#include "audio.h" +#include +#include +#include +#include + +#include + +#define AUDIO_CAP "pipewire" +#define RINGBUFFER_SIZE (1u << 22) +#define RINGBUFFER_MASK (RINGBUFFER_SIZE - 1) +#define BUFFER_SAMPLES 128 + +#include "audio_int.h" + +enum { + MODE_SINK, + MODE_SOURCE +}; + +typedef struct pwaudio { + Audiodev *dev; + struct pw_thread_loop *thread_loop; + struct pw_context *context; + + struct pw_core *core; + struct spa_hook core_listener; + int seq; +} pwaudio; + +typedef struct PWVoice { + pwaudio *g; + bool enabled; + struct pw_stream *stream; + struct spa_hook stream_listener; + struct spa_audio_info_raw info; + uint32_t frame_size; + struct spa_ringbuffer ring; + uint8_t buffer[RINGBUFFER_SIZE]; + + uint32_t mode; + struct pw_properties *props; +} PWVoice; + +typedef struct PWVoiceOut { + HWVoiceOut hw; + PWVoice v; +} PWVoiceOut; + +typedef struct PWVoiceIn { + HWVoiceIn hw; + PWVoice v; +} PWVoiceIn; + +static void +stream_destroy(void *data) +{ + PWVoice *v =3D (PWVoice *) data; + spa_hook_remove(&v->stream_listener); + v->stream =3D NULL; +} + +/* output data processing function to read stuffs from the buffer */ +static void +playback_on_process(void *data) +{ + PWVoice *v =3D (PWVoice *) data; + void *p; + struct pw_buffer *b; + struct spa_buffer *buf; + uint32_t n_frames, req, index, n_bytes; + int32_t avail; + + /* obtain a buffer to read from */ + b =3D pw_stream_dequeue_buffer(v->stream); + if (b =3D=3D NULL) { + pw_log_warn("out of buffers: %m"); + return; + } + + buf =3D b->buffer; + p =3D buf->datas[0].data; + if (p =3D=3D NULL) { + return; + } + req =3D b->requested * v->frame_size; + if (req =3D=3D 0) { + req =3D 4096 * v->frame_size; + } + n_frames =3D SPA_MIN(req, buf->datas[0].maxsize); + n_bytes =3D n_frames * v->frame_size; + + /* get no of available bytes to read data from buffer */ + + avail =3D spa_ringbuffer_get_read_index(&v->ring, &index); + + if (!v->enabled) { + avail =3D 0; + } + + if (avail =3D=3D 0) { + memset(p, 0, n_bytes); + } else { + if (avail < (int32_t) n_bytes) { + n_bytes =3D avail; + } + + spa_ringbuffer_read_data(&v->ring, + v->buffer, RINGBUFFER_SIZE, + index & RINGBUFFER_MASK, p, n_bytes); + + index +=3D n_bytes; + spa_ringbuffer_read_update(&v->ring, index); + } + + buf->datas[0].chunk->offset =3D 0; + buf->datas[0].chunk->stride =3D v->frame_size; + buf->datas[0].chunk->size =3D n_bytes; + + /* queue the buffer for playback */ + pw_stream_queue_buffer(v->stream, b); +} + +/* output data processing function to generate stuffs in the buffer */ +static void +capture_on_process(void *data) +{ + PWVoice *v =3D (PWVoice *) data; + void *p; + struct pw_buffer *b; + struct spa_buffer *buf; + int32_t filled; + uint32_t index, offs, n_bytes; + + /* obtain a buffer */ + b =3D pw_stream_dequeue_buffer(v->stream); + if (b =3D=3D NULL) { + pw_log_warn("out of buffers: %m"); + return; + } + + /* Write data into buffer */ + buf =3D b->buffer; + p =3D buf->datas[0].data; + if (p =3D=3D NULL) { + return; + } + offs =3D SPA_MIN(buf->datas[0].chunk->offset, buf->datas[0].maxsize); + n_bytes =3D SPA_MIN(buf->datas[0].chunk->size, buf->datas[0].maxsize - o= ffs); + + filled =3D spa_ringbuffer_get_write_index(&v->ring, &index); + + if (!v->enabled) { + n_bytes =3D 0; + } + + if (filled < 0) { + pw_log_warn("%p: underrun write:%u filled:%d", p, index, filled); + } else { + if ((uint32_t) filled + n_bytes > RINGBUFFER_SIZE) { + pw_log_warn("%p: overrun write:%u filled:%d + size:%u > max:%u", + p, index, filled, n_bytes, RINGBUFFER_SIZE); + } + } + spa_ringbuffer_write_data(&v->ring, + v->buffer, RINGBUFFER_SIZE, + index & RINGBUFFER_MASK, + SPA_PTROFF(p, offs, void), n_bytes); + index +=3D n_bytes; + spa_ringbuffer_write_update(&v->ring, index); + + /* queue the buffer for playback */ + pw_stream_queue_buffer(v->stream, b); +} + +static void +on_stream_state_changed(void *_data, enum pw_stream_state old, + enum pw_stream_state state, const char *error) +{ + PWVoice *v =3D (PWVoice *) _data; + + printf("stream state: \"%s\"\n", pw_stream_state_as_string(state)); + + switch (state) { + case PW_STREAM_STATE_ERROR: + case PW_STREAM_STATE_UNCONNECTED: + { + break; + } + case PW_STREAM_STATE_PAUSED: + printf("node id: %d\n", pw_stream_get_node_id(v->stream)); + break; + case PW_STREAM_STATE_CONNECTING: + case PW_STREAM_STATE_STREAMING: + break; + } +} + +static const struct pw_stream_events capture_stream_events =3D { + PW_VERSION_STREAM_EVENTS, + .destroy =3D stream_destroy, + .state_changed =3D on_stream_state_changed, + .process =3D capture_on_process +}; + +static const struct pw_stream_events playback_stream_events =3D { + PW_VERSION_STREAM_EVENTS, + .destroy =3D stream_destroy, + .state_changed =3D on_stream_state_changed, + .process =3D playback_on_process +}; + +static size_t +qpw_read(HWVoiceIn *hw, void *data, size_t len) +{ + PWVoiceIn *pw =3D (PWVoiceIn *) hw; + PWVoice *v =3D &pw->v; + pwaudio *c =3D v->g; + const char *error =3D NULL; + size_t l; + int32_t avail; + uint32_t index; + + pw_thread_loop_lock(c->thread_loop); + if (pw_stream_get_state(v->stream, &error) !=3D PW_STREAM_STATE_STREAMIN= G) { + /* wait for stream to become ready */ + l =3D 0; + goto done_unlock; + } + /* get no of available bytes to read data from buffer */ + avail =3D spa_ringbuffer_get_read_index(&v->ring, &index); + + if (avail < (int32_t) len) { + len =3D avail; + } + + spa_ringbuffer_read_data(&v->ring, + v->buffer, RINGBUFFER_SIZE, + index & RINGBUFFER_MASK, data, len); + index +=3D len; + spa_ringbuffer_read_update(&v->ring, index); + l =3D len; + +done_unlock: + pw_thread_loop_unlock(c->thread_loop); + return l; +} + +static size_t +qpw_write(HWVoiceOut *hw, void *data, size_t len) +{ + PWVoiceOut *pw =3D (PWVoiceOut *) hw; + PWVoice *v =3D &pw->v; + pwaudio *c =3D v->g; + const char *error =3D NULL; + size_t l; + int32_t filled, avail; + uint32_t index; + + pw_thread_loop_lock(c->thread_loop); + if (pw_stream_get_state(v->stream, &error) !=3D PW_STREAM_STATE_STREAMIN= G) { + /* wait for stream to become ready */ + l =3D 0; + goto done_unlock; + } + filled =3D spa_ringbuffer_get_write_index(&v->ring, &index); + + avail =3D 512 * v->frame_size * 3 - filled; + + pw_log_debug("%u %u %u %zu", filled, avail, index, len); + + if (len > avail) { + len =3D avail; + } + + if (filled < 0) { + pw_log_warn("%p: underrun write:%u filled:%d", pw, index, filled); + } else { + if ((uint32_t) filled + len > RINGBUFFER_SIZE) { + pw_log_warn("%p: overrun write:%u filled:%d + size:%zu > max:%u", + pw, index, filled, len, RINGBUFFER_SIZE); + } + } + + spa_ringbuffer_write_data(&v->ring, + v->buffer, RINGBUFFER_SIZE, + index & RINGBUFFER_MASK, data, len); + index +=3D len; + spa_ringbuffer_write_update(&v->ring, index); + l =3D len; + +done_unlock: + pw_thread_loop_unlock(c->thread_loop); + return l; +} + +static int +audfmt_to_pw(AudioFormat fmt, int endianness) +{ + int format; + + switch (fmt) { + case AUDIO_FORMAT_S8: + format =3D SPA_AUDIO_FORMAT_S8; + break; + case AUDIO_FORMAT_U8: + format =3D SPA_AUDIO_FORMAT_U8; + break; + case AUDIO_FORMAT_S16: + format =3D endianness ? SPA_AUDIO_FORMAT_S16_BE : SPA_AUDIO_FORMAT_S16= _LE; + break; + case AUDIO_FORMAT_U16: + format =3D endianness ? SPA_AUDIO_FORMAT_U16_BE : SPA_AUDIO_FORMAT_U16= _LE; + break; + case AUDIO_FORMAT_S32: + format =3D endianness ? SPA_AUDIO_FORMAT_S32_BE : SPA_AUDIO_FORMAT_S32= _LE; + break; + case AUDIO_FORMAT_U32: + format =3D endianness ? SPA_AUDIO_FORMAT_U32_BE : SPA_AUDIO_FORMAT_U32= _LE; + break; + case AUDIO_FORMAT_F32: + format =3D endianness ? SPA_AUDIO_FORMAT_F32_BE : SPA_AUDIO_FORMAT_F32= _LE; + break; + default: + dolog("Internal logic error: Bad audio format %d\n", fmt); + format =3D SPA_AUDIO_FORMAT_U8; + break; + } + return format; +} + +static AudioFormat +pw_to_audfmt(enum spa_audio_format fmt, int *endianness, + uint32_t *frame_size) +{ + switch (fmt) { + case SPA_AUDIO_FORMAT_S8: + *frame_size =3D 1; + return AUDIO_FORMAT_S8; + case SPA_AUDIO_FORMAT_U8: + *frame_size =3D 1; + return AUDIO_FORMAT_U8; + case SPA_AUDIO_FORMAT_S16_BE: + *frame_size =3D 2; + *endianness =3D 1; + return AUDIO_FORMAT_S16; + case SPA_AUDIO_FORMAT_S16_LE: + *frame_size =3D 2; + *endianness =3D 0; + return AUDIO_FORMAT_S16; + case SPA_AUDIO_FORMAT_U16_BE: + *frame_size =3D 2; + *endianness =3D 1; + return AUDIO_FORMAT_U16; + case SPA_AUDIO_FORMAT_U16_LE: + *frame_size =3D 2; + *endianness =3D 0; + return AUDIO_FORMAT_U16; + case SPA_AUDIO_FORMAT_S32_BE: + *frame_size =3D 4; + *endianness =3D 1; + return AUDIO_FORMAT_S32; + case SPA_AUDIO_FORMAT_S32_LE: + *frame_size =3D 4; + *endianness =3D 0; + return AUDIO_FORMAT_S32; + case SPA_AUDIO_FORMAT_U32_BE: + *frame_size =3D 4; + *endianness =3D 1; + return AUDIO_FORMAT_U32; + case SPA_AUDIO_FORMAT_U32_LE: + *frame_size =3D 4; + *endianness =3D 0; + return AUDIO_FORMAT_U32; + case SPA_AUDIO_FORMAT_F32_BE: + *frame_size =3D 4; + *endianness =3D 1; + return AUDIO_FORMAT_F32; + case SPA_AUDIO_FORMAT_F32_LE: + *frame_size =3D 4; + *endianness =3D 0; + return AUDIO_FORMAT_F32; + default: + *frame_size =3D 1; + dolog("Internal logic error: Bad spa_audio_format %d\n", fmt); + return AUDIO_FORMAT_U8; + } +} + +static int +create_stream(pwaudio *c, PWVoice *v, const char *name) +{ + int res; + uint32_t n_params; + const struct spa_pod *params[2]; + uint8_t buffer[1024]; + struct spa_pod_builder b; + + v->stream =3D pw_stream_new(c->core, name, NULL); + + if (v->stream =3D=3D NULL) { + res =3D -errno; + goto error; + } + + if (v->mode =3D=3D MODE_SOURCE) { + pw_stream_add_listener(v->stream, + &v->stream_listener, &capture_stream_events, v); + } else { + pw_stream_add_listener(v->stream, + &v->stream_listener, &playback_stream_events, v= ); + } + + n_params =3D 0; + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + params[n_params++] =3D spa_format_audio_raw_build(&b, + SPA_PARAM_EnumFormat, + &v->info); + + /* connect the stream to a sink or source */ + res =3D pw_stream_connect(v->stream, + v->mode =3D=3D + MODE_SOURCE ? PW_DIRECTION_INPUT : + PW_DIRECTION_OUTPUT, PW_ID_ANY, + PW_STREAM_FLAG_AUTOCONNECT | + PW_STREAM_FLAG_MAP_BUFFERS | + PW_STREAM_FLAG_RT_PROCESS, params, n_params); + if (res < 0) { + goto error; + } + + return 0; +error: + return res; +} + +static void +pw_destroy(pwaudio *c) +{ + if (c->thread_loop) { + pw_thread_loop_stop(c->thread_loop); + } + if (c->core) { + pw_core_disconnect(c->core); + } + + free(c); +} + +static int +qpw_stream_new(pwaudio *c, PWVoice *v, const char *name) +{ + int r; + + pw_thread_loop_lock(c->thread_loop); + + switch (v->info.channels) { + case 8: + v->info.position[0] =3D SPA_AUDIO_CHANNEL_FL; + v->info.position[1] =3D SPA_AUDIO_CHANNEL_FR; + v->info.position[2] =3D SPA_AUDIO_CHANNEL_FC; + v->info.position[3] =3D SPA_AUDIO_CHANNEL_LFE; + v->info.position[4] =3D SPA_AUDIO_CHANNEL_RL; + v->info.position[5] =3D SPA_AUDIO_CHANNEL_RR; + v->info.position[6] =3D SPA_AUDIO_CHANNEL_SL; + v->info.position[7] =3D SPA_AUDIO_CHANNEL_SR; + break; + case 6: + v->info.position[0] =3D SPA_AUDIO_CHANNEL_FL; + v->info.position[1] =3D SPA_AUDIO_CHANNEL_FR; + v->info.position[2] =3D SPA_AUDIO_CHANNEL_FC; + v->info.position[3] =3D SPA_AUDIO_CHANNEL_LFE; + v->info.position[4] =3D SPA_AUDIO_CHANNEL_RL; + v->info.position[5] =3D SPA_AUDIO_CHANNEL_RR; + break; + case 5: + v->info.position[0] =3D SPA_AUDIO_CHANNEL_FL; + v->info.position[1] =3D SPA_AUDIO_CHANNEL_FR; + v->info.position[2] =3D SPA_AUDIO_CHANNEL_FC; + v->info.position[3] =3D SPA_AUDIO_CHANNEL_LFE; + v->info.position[4] =3D SPA_AUDIO_CHANNEL_RC; + break; + case 4: + v->info.position[0] =3D SPA_AUDIO_CHANNEL_FL; + v->info.position[1] =3D SPA_AUDIO_CHANNEL_FR; + v->info.position[2] =3D SPA_AUDIO_CHANNEL_FC; + v->info.position[3] =3D SPA_AUDIO_CHANNEL_RC; + break; + case 3: + v->info.position[0] =3D SPA_AUDIO_CHANNEL_FL; + v->info.position[1] =3D SPA_AUDIO_CHANNEL_FR; + v->info.position[2] =3D SPA_AUDIO_CHANNEL_LFE; + break; + case 2: + v->info.position[0] =3D SPA_AUDIO_CHANNEL_FL; + v->info.position[1] =3D SPA_AUDIO_CHANNEL_FR; + break; + case 1: + v->info.position[0] =3D SPA_AUDIO_CHANNEL_MONO; + break; + default: + for (size_t i =3D 0; i < v->info.channels; i++) { + v->info.position[i] =3D SPA_AUDIO_CHANNEL_UNKNOWN; + } + break; + } + + /* create a new unconnected pwstream */ + r =3D create_stream(c, v, name); + if (r < 0) { + goto error; + } + + pw_thread_loop_unlock(c->thread_loop); + return r; + +error: + AUD_log(AUDIO_CAP, "Failed to create stream."); + pw_thread_loop_unlock(c->thread_loop); + pw_destroy(c); + return -1; +} + +static int +qpw_init_out(HWVoiceOut *hw, struct audsettings *as, void *drv_opaque) +{ + PWVoiceOut *pw =3D (PWVoiceOut *) hw; + PWVoice *v =3D &pw->v; + struct audsettings obt_as =3D *as; + pwaudio *c =3D v->g =3D drv_opaque; + AudiodevPwOptions *popts =3D &c->dev->u.pw; + AudiodevPwPerDirectionOptions *ppdo =3D popts->out; + int r; + v->enabled =3D false; + + v->mode =3D MODE_SINK; + + pw_thread_loop_lock(c->thread_loop); + + v->info.format =3D audfmt_to_pw(as->fmt, as->endianness); + v->info.channels =3D as->nchannels; + v->info.rate =3D as->freq; + + obt_as.fmt =3D + pw_to_audfmt(v->info.format, &obt_as.endianness, &v->frame_size); + v->frame_size *=3D as->nchannels; + + /* call the function that creates a new stream for playback */ + r =3D qpw_stream_new(c, v, ppdo->stream_name ? : c->dev->id); + if (r < 0) { + pw_log_error("qpw_stream_new for playback failed\n "); + goto fail; + } + + /* report the audio format we support */ + audio_pcm_init_info(&hw->info, &obt_as); + + /* report the buffer size to qemu */ + hw->samples =3D 512; + + pw_thread_loop_unlock(c->thread_loop); + return 0; +fail: + pw_thread_loop_unlock(c->thread_loop); + return -1; +} + +static int +qpw_init_in(HWVoiceIn *hw, struct audsettings *as, void *drv_opaque) +{ + PWVoiceIn *pw =3D (PWVoiceIn *) hw; + PWVoice *v =3D &pw->v; + struct audsettings obt_as =3D *as; + pwaudio *c =3D v->g =3D drv_opaque; + AudiodevPwOptions *popts =3D &c->dev->u.pw; + AudiodevPwPerDirectionOptions *ppdo =3D popts->in; + int r; + v->enabled =3D false; + + v->mode =3D MODE_SOURCE; + pw_thread_loop_lock(c->thread_loop); + + v->info.format =3D audfmt_to_pw(as->fmt, as->endianness); + v->info.channels =3D as->nchannels; + v->info.rate =3D as->freq; + + obt_as.fmt =3D + pw_to_audfmt(v->info.format, &obt_as.endianness, &v->frame_size); + v->frame_size *=3D as->nchannels; + + /* call the function that creates a new stream for recording */ + r =3D qpw_stream_new(c, v, ppdo->stream_name ? : c->dev->id); + if (r < 0) { + pw_log_error("qpw_stream_new for recording failed\n "); + goto fail; + } + + /* report the audio format we support */ + audio_pcm_init_info(&hw->info, &obt_as); + + /* report the buffer size to qemu */ + hw->samples =3D 512; + + pw_thread_loop_unlock(c->thread_loop); + return 0; +fail: + pw_thread_loop_unlock(c->thread_loop); + return -1; +} + +static void +qpw_fini_out(HWVoiceOut *hw) +{ + PWVoiceOut *pw =3D (PWVoiceOut *) hw; + PWVoice *v =3D &pw->v; + + if (v->stream) { + pwaudio *c =3D v->g; + pw_thread_loop_lock(c->thread_loop); + pw_stream_destroy(v->stream); + v->stream =3D NULL; + pw_thread_loop_unlock(c->thread_loop); + } +} + +static void +qpw_fini_in(HWVoiceIn *hw) +{ + PWVoiceIn *pw =3D (PWVoiceIn *) hw; + PWVoice *v =3D &pw->v; + + if (v->stream) { + pwaudio *c =3D v->g; + pw_thread_loop_lock(c->thread_loop); + pw_stream_destroy(v->stream); + v->stream =3D NULL; + pw_thread_loop_unlock(c->thread_loop); + } +} + +static void +qpw_enable_out(HWVoiceOut *hw, bool enable) +{ + PWVoiceOut *po =3D (PWVoiceOut *) hw; + PWVoice *v =3D &po->v; + v->enabled =3D enable; +} + +static void +qpw_enable_in(HWVoiceIn *hw, bool enable) +{ + PWVoiceIn *pi =3D (PWVoiceIn *) hw; + PWVoice *v =3D &pi->v; + v->enabled =3D enable; +} + +static void +on_core_error(void *data, uint32_t id, int seq, int res, const char *messa= ge) +{ + pwaudio *pw =3D data; + + pw_log_warn("error id:%u seq:%d res:%d (%s): %s", + id, seq, res, spa_strerror(res), message); + + pw_thread_loop_signal(pw->thread_loop, FALSE); +} + +static void +on_core_done(void *data, uint32_t id, int seq) +{ + pwaudio *pw =3D data; + if (id =3D=3D PW_ID_CORE) { + pw->seq =3D seq; + pw_thread_loop_signal(pw->thread_loop, FALSE); + } +} + +static const struct pw_core_events core_events =3D { + PW_VERSION_CORE_EVENTS, + .done =3D on_core_done, + .error =3D on_core_error, +}; + +static void * +qpw_audio_init(Audiodev *dev) +{ + pwaudio *pw; + pw =3D g_new0(pwaudio, 1); + pw_init(NULL, NULL); + + AudiodevPwOptions *popts; + AUD_log(AUDIO_CAP, "Initialize PW context\n"); + assert(dev->driver =3D=3D AUDIODEV_DRIVER_PW); + popts =3D &dev->u.pw; + + if (!popts->has_latency) { + popts->has_latency =3D true; + popts->latency =3D 44100; + } + + pw->dev =3D dev; + pw->thread_loop =3D pw_thread_loop_new("Pipewire thread loop", NULL); + if (pw->thread_loop =3D=3D NULL) { + goto fail; + } + pw->context =3D + pw_context_new(pw_thread_loop_get_loop(pw->thread_loop), NULL, 0); + + if (pw_thread_loop_start(pw->thread_loop) < 0) { + goto fail; + } + + pw_thread_loop_lock(pw->thread_loop); + + pw->core =3D pw_context_connect(pw->context, NULL, 0); + if (pw->core =3D=3D NULL) { + goto fail; + } + + pw_core_add_listener(pw->core, &pw->core_listener, &core_events, pw); + + pw_thread_loop_unlock(pw->thread_loop); + + return pw; + +fail: + AUD_log(AUDIO_CAP, "Failed to initialize PW context"); + pw_thread_loop_unlock(pw->thread_loop); + pw_context_destroy(pw->context); + pw_thread_loop_destroy(pw->thread_loop); + g_free(pw); + return NULL; +} + +static void +qpw_audio_fini(void *opaque) +{ + pwaudio *pw =3D opaque; + + pw_thread_loop_stop(pw->thread_loop); + + if (pw->core) { + spa_hook_remove(&pw->core_listener); + spa_zero(pw->core_listener); + pw_core_disconnect(pw->core); + } + + if (pw->context) { + pw_context_destroy(pw->context); + } + pw_thread_loop_destroy(pw->thread_loop); + + g_free(pw); +} + +static struct audio_pcm_ops qpw_pcm_ops =3D { + .init_out =3D qpw_init_out, + .fini_out =3D qpw_fini_out, + .write =3D qpw_write, + .buffer_get_free =3D audio_generic_buffer_get_free, + .run_buffer_out =3D audio_generic_run_buffer_out, + .enable_out =3D qpw_enable_out, + + .init_in =3D qpw_init_in, + .fini_in =3D qpw_fini_in, + .read =3D qpw_read, + .run_buffer_in =3D audio_generic_run_buffer_in, + .enable_in =3D qpw_enable_in +}; + +static struct audio_driver pw_audio_driver =3D { + .name =3D "pw", + .descr =3D "http://www.pipewire.org/", + .init =3D qpw_audio_init, + .fini =3D qpw_audio_fini, + .pcm_ops =3D &qpw_pcm_ops, + .can_be_default =3D 1, + .max_voices_out =3D INT_MAX, + .max_voices_in =3D INT_MAX, + .voice_size_out =3D sizeof(PWVoiceOut), + .voice_size_in =3D sizeof(PWVoiceIn), +}; + +static void +register_audio_pw(void) +{ + audio_driver_register(&pw_audio_driver); +} + +type_init(register_audio_pw); diff --git a/meson.build b/meson.build index c626ccfa82..785b30e305 100644 --- a/meson.build +++ b/meson.build @@ -734,6 +734,11 @@ if not get_option('jack').auto() or have_system jack =3D dependency('jack', required: get_option('jack'), method: 'pkg-config', kwargs: static_kwargs) endif +pipewire =3D not_found +if not get_option('pw').auto() or (targetos =3D=3D 'linux' and have_system) + pipewire =3D dependency('libpipewire-0.3', required: get_option('pw'), + method: 'pkg-config', kwargs: static_kwargs) +endif sndio =3D not_found if not get_option('sndio').auto() or have_system sndio =3D dependency('sndio', required: get_option('sndio'), @@ -1667,6 +1672,7 @@ if have_system 'jack': jack.found(), 'oss': oss.found(), 'pa': pulse.found(), + 'pw': pipewire.found(), 'sdl': sdl.found(), 'sndio': sndio.found(), } @@ -3940,6 +3946,7 @@ endif if targetos =3D=3D 'linux' summary_info +=3D {'ALSA support': alsa} summary_info +=3D {'PulseAudio support': pulse} + summary_info +=3D {'Pipewire support': pipewire} endif summary_info +=3D {'JACK support': jack} summary_info +=3D {'brlapi support': brlapi} diff --git a/meson_options.txt b/meson_options.txt index e5f199119e..f42605a8ac 100644 --- a/meson_options.txt +++ b/meson_options.txt @@ -21,7 +21,7 @@ option('tls_priority', type : 'string', value : 'NORMAL', option('default_devices', type : 'boolean', value : true, description: 'Include a default selection of devices in emulators') option('audio_drv_list', type: 'array', value: ['default'], - choices: ['alsa', 'coreaudio', 'default', 'dsound', 'jack', 'oss', = 'pa', 'sdl', 'sndio'], + choices: ['alsa', 'coreaudio', 'default', 'dsound', 'jack', 'oss', = 'pa', 'pw', 'sdl', 'sndio'], description: 'Set audio driver list') option('block_drv_rw_whitelist', type : 'string', value : '', description: 'set block driver read-write whitelist (by default aff= ects only QEMU, not tools like qemu-img)') @@ -253,6 +253,8 @@ option('oss', type: 'feature', value: 'auto', description: 'OSS sound support') option('pa', type: 'feature', value: 'auto', description: 'PulseAudio sound support') +option('pw', type: 'feature', value: 'auto', + description: 'Pipewire sound support') option('sndio', type: 'feature', value: 'auto', description: 'sndio sound support') =20 diff --git a/qapi/audio.json b/qapi/audio.json index 4e54c00f51..6c17d08ab8 100644 --- a/qapi/audio.json +++ b/qapi/audio.json @@ -324,6 +324,48 @@ '*out': 'AudiodevPaPerDirectionOptions', '*server': 'str' } } =20 +## +# @AudiodevPwPerDirectionOptions: +# +# Options of the Pipewire backend that are used for both playback and +# recording. +# +# @name: name of the sink/source to use +# +# @stream-name: name of the Pipewire stream created by qemu. Can be +# used to identify the stream in Pipewire when you +# create multiple Pipewire devices or run multiple qemu +# instances (default: audiodev's id, since 7.1) +# +# +# Since: 7.2 +## +{ 'struct': 'AudiodevPwPerDirectionOptions', + 'base': 'AudiodevPerDirectionOptions', + 'data': { + '*name': 'str', + '*stream-name': 'str' } } + +## +# @AudiodevPwOptions: +# +# Options of the Pipewire audio backend. +# +# @in: options of the capture stream +# +# @out: options of the playback stream +# +# @latency: add latency to playback in microseconds +# (default 44100) +# +# Since: 7.2 +## +{ 'struct': 'AudiodevPwOptions', + 'data': { + '*in': 'AudiodevPwPerDirectionOptions', + '*out': 'AudiodevPwPerDirectionOptions', + '*latency': 'uint32' } } + ## # @AudiodevSdlPerDirectionOptions: # @@ -416,6 +458,7 @@ { 'name': 'jack', 'if': 'CONFIG_AUDIO_JACK' }, { 'name': 'oss', 'if': 'CONFIG_AUDIO_OSS' }, { 'name': 'pa', 'if': 'CONFIG_AUDIO_PA' }, + { 'name': 'pw', 'if': 'CONFIG_AUDIO_PW' }, { 'name': 'sdl', 'if': 'CONFIG_AUDIO_SDL' }, { 'name': 'sndio', 'if': 'CONFIG_AUDIO_SNDIO' }, { 'name': 'spice', 'if': 'CONFIG_SPICE' }, @@ -456,6 +499,8 @@ 'if': 'CONFIG_AUDIO_OSS' }, 'pa': { 'type': 'AudiodevPaOptions', 'if': 'CONFIG_AUDIO_PA' }, + 'pw': { 'type': 'AudiodevPwOptions', + 'if': 'CONFIG_AUDIO_PW' }, 'sdl': { 'type': 'AudiodevSdlOptions', 'if': 'CONFIG_AUDIO_SDL' }, 'sndio': { 'type': 'AudiodevSndioOptions', diff --git a/qemu-options.hx b/qemu-options.hx index 88e93c6103..4fc73af804 100644 --- a/qemu-options.hx +++ b/qemu-options.hx @@ -779,6 +779,11 @@ DEF("audiodev", HAS_ARG, QEMU_OPTION_audiodev, " in|out.name=3D source/sink device name\n" " in|out.latency=3D desired latency in microseconds\n" #endif +#ifdef CONFIG_AUDIO_PW + "-audiodev pw,id=3Did[,prop[=3Dvalue][,...]]\n" + " in|out.name=3D source/sink device name\n" + " latency=3D desired latency in microseconds\n" +#endif #ifdef CONFIG_AUDIO_SDL "-audiodev sdl,id=3Did[,prop[=3Dvalue][,...]]\n" " in|out.buffer-count=3D number of buffers\n" @@ -942,6 +947,18 @@ SRST Desired latency in microseconds. The PulseAudio server will try to honor this value but actual latencies may be lower or higher. =20 +``-audiodev pw,id=3Did[,prop[=3Dvalue][,...]]`` + Creates a backend using Pipewire. This backend is available on + most systems. + + Pipewire specific options are: + + ``latency=3Dlatency`` + Add extra latency to playback in microseconds + + ``in|out.name=3Dsink`` + Use the specified source/sink for recording/playback. + ``-audiodev sdl,id=3Did[,prop[=3Dvalue][,...]]`` Creates a backend using SDL. This backend is available on most systems, but you should use your platform's native backend if diff --git a/scripts/meson-buildoptions.sh b/scripts/meson-buildoptions.sh index c2982ea087..d6f741f574 100644 --- a/scripts/meson-buildoptions.sh +++ b/scripts/meson-buildoptions.sh @@ -1,7 +1,8 @@ # This file is generated by meson-buildoptions.py, do not edit! meson_options_help() { - printf "%s\n" ' --audio-drv-list=3DCHOICES Set audio driver list [defau= lt] (choices: alsa/co' - printf "%s\n" ' reaudio/default/dsound/jack/os= s/pa/sdl/sndio)' + printf "%s\n" ' --audio-drv-list=3DCHOICES Set audio driver list [defau= lt] (choices: al' + printf "%s\n" ' sa/coreaudio/default/dsound/ja= ck/' + printf "%s\n" ' oss/pa/pw/sdl/sndio)' printf "%s\n" ' --block-drv-ro-whitelist=3DVALUE' printf "%s\n" ' set block driver read-only whi= telist (by default' printf "%s\n" ' affects only QEMU, not tools l= ike qemu-img)' @@ -136,6 +137,7 @@ meson_options_help() { printf "%s\n" ' parallels parallels image format support' printf "%s\n" ' png PNG support with libpng' printf "%s\n" ' pvrdma Enable PVRDMA support' + printf "%s\n" ' pw Pipewire sound support' printf "%s\n" ' qcow1 qcow1 image format support' printf "%s\n" ' qed qed image format support' printf "%s\n" ' qga-vss build QGA VSS support (broken with MinG= W)' @@ -374,6 +376,8 @@ _meson_option_parse() { --disable-profiler) printf "%s" -Dprofiler=3Dfalse ;; --enable-pvrdma) printf "%s" -Dpvrdma=3Denabled ;; --disable-pvrdma) printf "%s" -Dpvrdma=3Ddisabled ;; + --enable-pw) printf "%s" -Dpw=3Denabled ;; + --disable-pw) printf "%s" -Dpw=3Ddisabled ;; --enable-qcow1) printf "%s" -Dqcow1=3Denabled ;; --disable-qcow1) printf "%s" -Dqcow1=3Ddisabled ;; --enable-qed) printf "%s" -Dqed=3Denabled ;; --=20 2.39.1