audio/pwaudio.c

   1 /*
   2  * QEMU PipeWire audio driver
   3  *
   4  * Copyright (c) 2023 Red Hat Inc.
   5  *
   6  * Author: Dorinda Bassey       <dbassey@redhat.com>
   7  *
   8  * SPDX-License-Identifier: GPL-2.0-or-later
   9  */
  10
  11 #include "qemu/osdep.h"
  12 #include "qemu/module.h"
  13 #include "audio.h"
  14 #include <errno.h>
  15 #include "qemu/error-report.h"
  16 #include <spa/param/audio/format-utils.h>
  17 #include <spa/utils/ringbuffer.h>
  18 #include <spa/utils/result.h>
  19 #include <spa/param/props.h>
  20
  21 #include <pipewire/pipewire.h>
  22 #include "trace.h"
  23
  24 #define AUDIO_CAP "pipewire"
  25 #define RINGBUFFER_SIZE    (1u << 22)
  26 #define RINGBUFFER_MASK    (RINGBUFFER_SIZE - 1)
  27
  28 #include "audio_int.h"
  29
  30 typedef struct pwvolume {
  31     uint32_t channels;
  32     float values[SPA_AUDIO_MAX_CHANNELS];
  33 } pwvolume;
  34
  35 typedef struct pwaudio {
  36     Audiodev *dev;
  37     struct pw_thread_loop *thread_loop;
  38     struct pw_context *context;
  39
  40     struct pw_core *core;
  41     struct spa_hook core_listener;
  42     int last_seq, pending_seq, error;
  43 } pwaudio;
  44
  45 typedef struct PWVoice {
  46     pwaudio *g;
  47     struct pw_stream *stream;
  48     struct spa_hook stream_listener;
  49     struct spa_audio_info_raw info;
  50     uint32_t highwater_mark;
  51     uint32_t frame_size, req;
  52     struct spa_ringbuffer ring;
  53     uint8_t buffer[RINGBUFFER_SIZE];
  54
  55     pwvolume volume;
  56     bool muted;
  57 } PWVoice;
  58
  59 typedef struct PWVoiceOut {
  60     HWVoiceOut hw;
  61     PWVoice v;
  62 } PWVoiceOut;
  63
  64 typedef struct PWVoiceIn {
  65     HWVoiceIn hw;
  66     PWVoice v;
  67 } PWVoiceIn;
  68
  69 #define PW_VOICE_IN(v) ((PWVoiceIn *)v)
  70 #define PW_VOICE_OUT(v) ((PWVoiceOut *)v)
  71
  72 static void
  73 stream_destroy(void *data)
  74 {
  75     PWVoice *v = (PWVoice *) data;
  76     spa_hook_remove(&v->stream_listener);
  77     v->stream = NULL;
  78 }
  79
  80 /* output data processing function to read stuffs from the buffer */
  81 static void
  82 playback_on_process(void *data)
  83 {
  84     PWVoice *v = data;
  85     void *p;
  86     struct pw_buffer *b;
  87     struct spa_buffer *buf;
  88     uint32_t req, index, n_bytes;
  89     int32_t avail;
  90
  91     assert(v->stream);
  92
  93     /* obtain a buffer to read from */
  94     b = pw_stream_dequeue_buffer(v->stream);
  95     if (b == NULL) {
  96         error_report("out of buffers: %s", strerror(errno));
  97         return;
  98     }
  99
 100     buf = b->buffer;
 101     p = buf->datas[0].data;
 102     if (p == NULL) {
 103         return;
 104     }
 105     /* calculate the total no of bytes to read data from buffer */
 106     req = b->requested * v->frame_size;
 107     if (req == 0) {
 108         req = v->req;
 109     }
 110     n_bytes = SPA_MIN(req, buf->datas[0].maxsize);
 111
 112     /* get no of available bytes to read data from buffer */
 113     avail = spa_ringbuffer_get_read_index(&v->ring, &index);
 114
 115     if (avail <= 0) {
 116         PWVoiceOut *vo = container_of(data, PWVoiceOut, v);
 117         audio_pcm_info_clear_buf(&vo->hw.info, p, n_bytes / v->frame_size);
 118     } else {
 119         if ((uint32_t) avail < n_bytes) {
 120             /*
 121              * PipeWire immediately calls this callback again if we provide
 122              * less than n_bytes. Then audio_pcm_info_clear_buf() fills the
 123              * rest of the buffer with silence.
 124              */
 125             n_bytes = avail;
 126         }
 127
 128         spa_ringbuffer_read_data(&v->ring,
 129                                     v->buffer, RINGBUFFER_SIZE,
 130                                     index & RINGBUFFER_MASK, p, n_bytes);
 131
 132         index += n_bytes;
 133         spa_ringbuffer_read_update(&v->ring, index);
 134
 135     }
 136     buf->datas[0].chunk->offset = 0;
 137     buf->datas[0].chunk->stride = v->frame_size;
 138     buf->datas[0].chunk->size = n_bytes;
 139
 140     /* queue the buffer for playback */
 141     pw_stream_queue_buffer(v->stream, b);
 142 }
 143
 144 /* output data processing function to generate stuffs in the buffer */
 145 static void
 146 capture_on_process(void *data)
 147 {
 148     PWVoice *v = (PWVoice *) data;
 149     void *p;
 150     struct pw_buffer *b;
 151     struct spa_buffer *buf;
 152     int32_t filled;
 153     uint32_t index, offs, n_bytes;
 154
 155     assert(v->stream);
 156
 157     /* obtain a buffer */
 158     b = pw_stream_dequeue_buffer(v->stream);
 159     if (b == NULL) {
 160         error_report("out of buffers: %s", strerror(errno));
 161         return;
 162     }
 163
 164     /* Write data into buffer */
 165     buf = b->buffer;
 166     p = buf->datas[0].data;
 167     if (p == NULL) {
 168         return;
 169     }
 170     offs = SPA_MIN(buf->datas[0].chunk->offset, buf->datas[0].maxsize);
 171     n_bytes = SPA_MIN(buf->datas[0].chunk->size, buf->datas[0].maxsize - offs);
 172
 173     filled = spa_ringbuffer_get_write_index(&v->ring, &index);
 174
 175
 176     if (filled < 0) {
 177         error_report("%p: underrun write:%u filled:%d", p, index, filled);
 178     } else {
 179         if ((uint32_t) filled + n_bytes > RINGBUFFER_SIZE) {
 180             error_report("%p: overrun write:%u filled:%d + size:%u > max:%u",
 181             p, index, filled, n_bytes, RINGBUFFER_SIZE);
 182         }
 183     }
 184     spa_ringbuffer_write_data(&v->ring,
 185                                 v->buffer, RINGBUFFER_SIZE,
 186                                 index & RINGBUFFER_MASK,
 187                                 SPA_PTROFF(p, offs, void), n_bytes);
 188     index += n_bytes;
 189     spa_ringbuffer_write_update(&v->ring, index);
 190
 191     /* queue the buffer for playback */
 192     pw_stream_queue_buffer(v->stream, b);
 193 }
 194
 195 static void
 196 on_stream_state_changed(void *data, enum pw_stream_state old,
 197                         enum pw_stream_state state, const char *error)
 198 {
 199     PWVoice *v = (PWVoice *) data;
 200
 201     trace_pw_state_changed(pw_stream_get_node_id(v->stream),
 202                            pw_stream_state_as_string(state));
 203 }
 204
 205 static const struct pw_stream_events capture_stream_events = {
 206     PW_VERSION_STREAM_EVENTS,
 207     .destroy = stream_destroy,
 208     .state_changed = on_stream_state_changed,
 209     .process = capture_on_process
 210 };
 211
 212 static const struct pw_stream_events playback_stream_events = {
 213     PW_VERSION_STREAM_EVENTS,
 214     .destroy = stream_destroy,
 215     .state_changed = on_stream_state_changed,
 216     .process = playback_on_process
 217 };
 218
 219 static size_t
 220 qpw_read(HWVoiceIn *hw, void *data, size_t len)
 221 {
 222     PWVoiceIn *pw = (PWVoiceIn *) hw;
 223     PWVoice *v = &pw->v;
 224     pwaudio *c = v->g;
 225     const char *error = NULL;
 226     size_t l;
 227     int32_t avail;
 228     uint32_t index;
 229
 230     pw_thread_loop_lock(c->thread_loop);
 231     if (pw_stream_get_state(v->stream, &error) != PW_STREAM_STATE_STREAMING) {
 232         /* wait for stream to become ready */
 233         l = 0;
 234         goto done_unlock;
 235     }
 236     /* get no of available bytes to read data from buffer */
 237     avail = spa_ringbuffer_get_read_index(&v->ring, &index);
 238
 239     trace_pw_read(avail, index, len);
 240
 241     if (avail < (int32_t) len) {
 242         len = avail;
 243     }
 244
 245     spa_ringbuffer_read_data(&v->ring,
 246                              v->buffer, RINGBUFFER_SIZE,
 247                              index & RINGBUFFER_MASK, data, len);
 248     index += len;
 249     spa_ringbuffer_read_update(&v->ring, index);
 250     l = len;
 251
 252 done_unlock:
 253     pw_thread_loop_unlock(c->thread_loop);
 254     return l;
 255 }
 256
 257 static size_t qpw_buffer_get_free(HWVoiceOut *hw)
 258 {
 259     PWVoiceOut *pw = (PWVoiceOut *)hw;
 260     PWVoice *v = &pw->v;
 261     pwaudio *c = v->g;
 262     const char *error = NULL;
 263     int32_t filled, avail;
 264     uint32_t index;
 265
 266     pw_thread_loop_lock(c->thread_loop);
 267     if (pw_stream_get_state(v->stream, &error) != PW_STREAM_STATE_STREAMING) {
 268         /* wait for stream to become ready */
 269         avail = 0;
 270         goto done_unlock;
 271     }
 272
 273     filled = spa_ringbuffer_get_write_index(&v->ring, &index);
 274     avail = v->highwater_mark - filled;
 275
 276 done_unlock:
 277     pw_thread_loop_unlock(c->thread_loop);
 278     return avail;
 279 }
 280
 281 static size_t
 282 qpw_write(HWVoiceOut *hw, void *data, size_t len)
 283 {
 284     PWVoiceOut *pw = (PWVoiceOut *) hw;
 285     PWVoice *v = &pw->v;
 286     pwaudio *c = v->g;
 287     const char *error = NULL;
 288     int32_t filled, avail;
 289     uint32_t index;
 290
 291     pw_thread_loop_lock(c->thread_loop);
 292     if (pw_stream_get_state(v->stream, &error) != PW_STREAM_STATE_STREAMING) {
 293         /* wait for stream to become ready */
 294         len = 0;
 295         goto done_unlock;
 296     }
 297     filled = spa_ringbuffer_get_write_index(&v->ring, &index);
 298     avail = v->highwater_mark - filled;
 299
 300     trace_pw_write(filled, avail, index, len);
 301
 302     if (len > avail) {
 303         len = avail;
 304     }
 305
 306     if (filled < 0) {
 307         error_report("%p: underrun write:%u filled:%d", pw, index, filled);
 308     } else {
 309         if ((uint32_t) filled + len > RINGBUFFER_SIZE) {
 310             error_report("%p: overrun write:%u filled:%d + size:%zu > max:%u",
 311             pw, index, filled, len, RINGBUFFER_SIZE);
 312         }
 313     }
 314
 315     spa_ringbuffer_write_data(&v->ring,
 316                                 v->buffer, RINGBUFFER_SIZE,
 317                                 index & RINGBUFFER_MASK, data, len);
 318     index += len;
 319     spa_ringbuffer_write_update(&v->ring, index);
 320
 321 done_unlock:
 322     pw_thread_loop_unlock(c->thread_loop);
 323     return len;
 324 }
 325
 326 static int
 327 audfmt_to_pw(AudioFormat fmt, int endianness)
 328 {
 329     int format;
 330
 331     switch (fmt) {
 332     case AUDIO_FORMAT_S8:
 333         format = SPA_AUDIO_FORMAT_S8;
 334         break;
 335     case AUDIO_FORMAT_U8:
 336         format = SPA_AUDIO_FORMAT_U8;
 337         break;
 338     case AUDIO_FORMAT_S16:
 339         format = endianness ? SPA_AUDIO_FORMAT_S16_BE : SPA_AUDIO_FORMAT_S16_LE;
 340         break;
 341     case AUDIO_FORMAT_U16:
 342         format = endianness ? SPA_AUDIO_FORMAT_U16_BE : SPA_AUDIO_FORMAT_U16_LE;
 343         break;
 344     case AUDIO_FORMAT_S32:
 345         format = endianness ? SPA_AUDIO_FORMAT_S32_BE : SPA_AUDIO_FORMAT_S32_LE;
 346         break;
 347     case AUDIO_FORMAT_U32:
 348         format = endianness ? SPA_AUDIO_FORMAT_U32_BE : SPA_AUDIO_FORMAT_U32_LE;
 349         break;
 350     case AUDIO_FORMAT_F32:
 351         format = endianness ? SPA_AUDIO_FORMAT_F32_BE : SPA_AUDIO_FORMAT_F32_LE;
 352         break;
 353     default:
 354         dolog("Internal logic error: Bad audio format %d\n", fmt);
 355         format = SPA_AUDIO_FORMAT_U8;
 356         break;
 357     }
 358     return format;
 359 }
 360
 361 static AudioFormat
 362 pw_to_audfmt(enum spa_audio_format fmt, int *endianness,
 363              uint32_t *sample_size)
 364 {
 365     switch (fmt) {
 366     case SPA_AUDIO_FORMAT_S8:
 367         *sample_size = 1;
 368         return AUDIO_FORMAT_S8;
 369     case SPA_AUDIO_FORMAT_U8:
 370         *sample_size = 1;
 371         return AUDIO_FORMAT_U8;
 372     case SPA_AUDIO_FORMAT_S16_BE:
 373         *sample_size = 2;
 374         *endianness = 1;
 375         return AUDIO_FORMAT_S16;
 376     case SPA_AUDIO_FORMAT_S16_LE:
 377         *sample_size = 2;
 378         *endianness = 0;
 379         return AUDIO_FORMAT_S16;
 380     case SPA_AUDIO_FORMAT_U16_BE:
 381         *sample_size = 2;
 382         *endianness = 1;
 383         return AUDIO_FORMAT_U16;
 384     case SPA_AUDIO_FORMAT_U16_LE:
 385         *sample_size = 2;
 386         *endianness = 0;
 387         return AUDIO_FORMAT_U16;
 388     case SPA_AUDIO_FORMAT_S32_BE:
 389         *sample_size = 4;
 390         *endianness = 1;
 391         return AUDIO_FORMAT_S32;
 392     case SPA_AUDIO_FORMAT_S32_LE:
 393         *sample_size = 4;
 394         *endianness = 0;
 395         return AUDIO_FORMAT_S32;
 396     case SPA_AUDIO_FORMAT_U32_BE:
 397         *sample_size = 4;
 398         *endianness = 1;
 399         return AUDIO_FORMAT_U32;
 400     case SPA_AUDIO_FORMAT_U32_LE:
 401         *sample_size = 4;
 402         *endianness = 0;
 403         return AUDIO_FORMAT_U32;
 404     case SPA_AUDIO_FORMAT_F32_BE:
 405         *sample_size = 4;
 406         *endianness = 1;
 407         return AUDIO_FORMAT_F32;
 408     case SPA_AUDIO_FORMAT_F32_LE:
 409         *sample_size = 4;
 410         *endianness = 0;
 411         return AUDIO_FORMAT_F32;
 412     default:
 413         *sample_size = 1;
 414         dolog("Internal logic error: Bad spa_audio_format %d\n", fmt);
 415         return AUDIO_FORMAT_U8;
 416     }
 417 }
 418
 419 static int
 420 qpw_stream_new(pwaudio *c, PWVoice *v, const char *stream_name,
 421                const char *name, enum spa_direction dir)
 422 {
 423     int res;
 424     uint32_t n_params;
 425     const struct spa_pod *params[2];
 426     uint8_t buffer[1024];
 427     struct spa_pod_builder b;
 428     uint64_t buf_samples;
 429     struct pw_properties *props;
 430
 431     props = pw_properties_new(NULL, NULL);
 432     if (!props) {
 433         error_report("Failed to create PW properties: %s", g_strerror(errno));
 434         return -1;
 435     }
 436
 437     /* 75% of the timer period for faster updates */
 438     buf_samples = (uint64_t)v->g->dev->timer_period * v->info.rate
 439                     * 3 / 4 / 1000000;
 440     pw_properties_setf(props, PW_KEY_NODE_LATENCY, "%" PRIu64 "/%u",
 441                        buf_samples, v->info.rate);
 442
 443     trace_pw_period(buf_samples, v->info.rate);
 444     if (name) {
 445         pw_properties_set(props, PW_KEY_TARGET_OBJECT, name);
 446     }
 447     v->stream = pw_stream_new(c->core, stream_name, props);
 448     if (v->stream == NULL) {
 449         error_report("Failed to create PW stream: %s", g_strerror(errno));
 450         return -1;
 451     }
 452
 453     if (dir == SPA_DIRECTION_INPUT) {
 454         pw_stream_add_listener(v->stream,
 455                             &v->stream_listener, &capture_stream_events, v);
 456     } else {
 457         pw_stream_add_listener(v->stream,
 458                             &v->stream_listener, &playback_stream_events, v);
 459     }
 460
 461     n_params = 0;
 462     spa_pod_builder_init(&b, buffer, sizeof(buffer));
 463     params[n_params++] = spa_format_audio_raw_build(&b,
 464                             SPA_PARAM_EnumFormat,
 465                             &v->info);
 466
 467     /* connect the stream to a sink or source */
 468     res = pw_stream_connect(v->stream,
 469                             dir ==
 470                             SPA_DIRECTION_INPUT ? PW_DIRECTION_INPUT :
 471                             PW_DIRECTION_OUTPUT, PW_ID_ANY,
 472                             PW_STREAM_FLAG_AUTOCONNECT |
 473                             PW_STREAM_FLAG_INACTIVE |
 474                             PW_STREAM_FLAG_MAP_BUFFERS |
 475                             PW_STREAM_FLAG_RT_PROCESS, params, n_params);
 476     if (res < 0) {
 477         error_report("Failed to connect PW stream: %s", g_strerror(errno));
 478         pw_stream_destroy(v->stream);
 479         return -1;
 480     }
 481
 482     return 0;
 483 }
 484
 485 static void
 486 qpw_set_position(uint32_t channels, uint32_t position[SPA_AUDIO_MAX_CHANNELS])
 487 {
 488     memcpy(position, (uint32_t[SPA_AUDIO_MAX_CHANNELS]) { SPA_AUDIO_CHANNEL_UNKNOWN, },
 489            sizeof(uint32_t) * SPA_AUDIO_MAX_CHANNELS);
 490     /*
 491      * TODO: This currently expects the only frontend supporting more than 2
 492      * channels is the usb-audio.  We will need some means to set channel
 493      * order when a new frontend gains multi-channel support.
 494      */
 495     switch (channels) {
 496     case 8:
 497         position[6] = SPA_AUDIO_CHANNEL_SL;
 498         position[7] = SPA_AUDIO_CHANNEL_SR;
 499         /* fallthrough */
 500     case 6:
 501         position[2] = SPA_AUDIO_CHANNEL_FC;
 502         position[3] = SPA_AUDIO_CHANNEL_LFE;
 503         position[4] = SPA_AUDIO_CHANNEL_RL;
 504         position[5] = SPA_AUDIO_CHANNEL_RR;
 505         /* fallthrough */
 506     case 2:
 507         position[0] = SPA_AUDIO_CHANNEL_FL;
 508         position[1] = SPA_AUDIO_CHANNEL_FR;
 509         break;
 510     case 1:
 511         position[0] = SPA_AUDIO_CHANNEL_MONO;
 512         break;
 513     default:
 514         dolog("Internal error: unsupported channel count %d\n", channels);
 515     }
 516 }
 517
 518 static int
 519 qpw_init_out(HWVoiceOut *hw, struct audsettings *as, void *drv_opaque)
 520 {
 521     PWVoiceOut *pw = (PWVoiceOut *) hw;
 522     PWVoice *v = &pw->v;
 523     struct audsettings obt_as = *as;
 524     pwaudio *c = v->g = drv_opaque;
 525     AudiodevPipewireOptions *popts = &c->dev->u.pipewire;
 526     AudiodevPipewirePerDirectionOptions *ppdo = popts->out;
 527     int r;
 528
 529     pw_thread_loop_lock(c->thread_loop);
 530
 531     v->info.format = audfmt_to_pw(as->fmt, as->endianness);
 532     v->info.channels = as->nchannels;
 533     qpw_set_position(as->nchannels, v->info.position);
 534     v->info.rate = as->freq;
 535
 536     obt_as.fmt =
 537         pw_to_audfmt(v->info.format, &obt_as.endianness, &v->frame_size);
 538     v->frame_size *= as->nchannels;
 539
 540     v->req = (uint64_t)c->dev->timer_period * v->info.rate
 541         * 1 / 2 / 1000000 * v->frame_size;
 542
 543     /* call the function that creates a new stream for playback */
 544     r = qpw_stream_new(c, v, ppdo->stream_name ? : c->dev->id,
 545                        ppdo->name, SPA_DIRECTION_OUTPUT);
 546     if (r < 0) {
 547         pw_thread_loop_unlock(c->thread_loop);
 548         return -1;
 549     }
 550
 551     /* report the audio format we support */
 552     audio_pcm_init_info(&hw->info, &obt_as);
 553
 554     /* report the buffer size to qemu */
 555     hw->samples = audio_buffer_frames(
 556         qapi_AudiodevPipewirePerDirectionOptions_base(ppdo), &obt_as, 46440);
 557     v->highwater_mark = MIN(RINGBUFFER_SIZE,
 558                             (ppdo->has_latency ? ppdo->latency : 46440)
 559                             * (uint64_t)v->info.rate / 1000000 * v->frame_size);
 560
 561     pw_thread_loop_unlock(c->thread_loop);
 562     return 0;
 563 }
 564
 565 static int
 566 qpw_init_in(HWVoiceIn *hw, struct audsettings *as, void *drv_opaque)
 567 {
 568     PWVoiceIn *pw = (PWVoiceIn *) hw;
 569     PWVoice *v = &pw->v;
 570     struct audsettings obt_as = *as;
 571     pwaudio *c = v->g = drv_opaque;
 572     AudiodevPipewireOptions *popts = &c->dev->u.pipewire;
 573     AudiodevPipewirePerDirectionOptions *ppdo = popts->in;
 574     int r;
 575
 576     pw_thread_loop_lock(c->thread_loop);
 577
 578     v->info.format = audfmt_to_pw(as->fmt, as->endianness);
 579     v->info.channels = as->nchannels;
 580     qpw_set_position(as->nchannels, v->info.position);
 581     v->info.rate = as->freq;
 582
 583     obt_as.fmt =
 584         pw_to_audfmt(v->info.format, &obt_as.endianness, &v->frame_size);
 585     v->frame_size *= as->nchannels;
 586
 587     /* call the function that creates a new stream for recording */
 588     r = qpw_stream_new(c, v, ppdo->stream_name ? : c->dev->id,
 589                        ppdo->name, SPA_DIRECTION_INPUT);
 590     if (r < 0) {
 591         pw_thread_loop_unlock(c->thread_loop);
 592         return -1;
 593     }
 594
 595     /* report the audio format we support */
 596     audio_pcm_init_info(&hw->info, &obt_as);
 597
 598     /* report the buffer size to qemu */
 599     hw->samples = audio_buffer_frames(
 600         qapi_AudiodevPipewirePerDirectionOptions_base(ppdo), &obt_as, 46440);
 601
 602     pw_thread_loop_unlock(c->thread_loop);
 603     return 0;
 604 }
 605
 606 static void
 607 qpw_voice_fini(PWVoice *v)
 608 {
 609     pwaudio *c = v->g;
 610
 611     if (!v->stream) {
 612         return;
 613     }
 614     pw_thread_loop_lock(c->thread_loop);
 615     pw_stream_destroy(v->stream);
 616     v->stream = NULL;
 617     pw_thread_loop_unlock(c->thread_loop);
 618 }
 619
 620 static void
 621 qpw_fini_out(HWVoiceOut *hw)
 622 {
 623     qpw_voice_fini(&PW_VOICE_OUT(hw)->v);
 624 }
 625
 626 static void
 627 qpw_fini_in(HWVoiceIn *hw)
 628 {
 629     qpw_voice_fini(&PW_VOICE_IN(hw)->v);
 630 }
 631
 632 static void
 633 qpw_voice_set_enabled(PWVoice *v, bool enable)
 634 {
 635     pwaudio *c = v->g;
 636     pw_thread_loop_lock(c->thread_loop);
 637     pw_stream_set_active(v->stream, enable);
 638     pw_thread_loop_unlock(c->thread_loop);
 639 }
 640
 641 static void
 642 qpw_enable_out(HWVoiceOut *hw, bool enable)
 643 {
 644     qpw_voice_set_enabled(&PW_VOICE_OUT(hw)->v, enable);
 645 }
 646
 647 static void
 648 qpw_enable_in(HWVoiceIn *hw, bool enable)
 649 {
 650     qpw_voice_set_enabled(&PW_VOICE_IN(hw)->v, enable);
 651 }
 652
 653 static void
 654 qpw_voice_set_volume(PWVoice *v, Volume *vol)
 655 {
 656     pwaudio *c = v->g;
 657     int i, ret;
 658
 659     pw_thread_loop_lock(c->thread_loop);
 660     v->volume.channels = vol->channels;
 661
 662     for (i = 0; i < vol->channels; ++i) {
 663         v->volume.values[i] = (float)vol->vol[i] / 255;
 664     }
 665
 666     ret = pw_stream_set_control(v->stream,
 667         SPA_PROP_channelVolumes, v->volume.channels, v->volume.values, 0);
 668     trace_pw_vol(ret == 0 ? "success" : "failed");
 669
 670     v->muted = vol->mute;
 671     float val = v->muted ? 1.f : 0.f;
 672     ret = pw_stream_set_control(v->stream, SPA_PROP_mute, 1, &val, 0);
 673     pw_thread_loop_unlock(c->thread_loop);
 674 }
 675
 676 static void
 677 qpw_volume_out(HWVoiceOut *hw, Volume *vol)
 678 {
 679     qpw_voice_set_volume(&PW_VOICE_OUT(hw)->v, vol);
 680 }
 681
 682 static void
 683 qpw_volume_in(HWVoiceIn *hw, Volume *vol)
 684 {
 685     qpw_voice_set_volume(&PW_VOICE_IN(hw)->v, vol);
 686 }
 687
 688 static int wait_resync(pwaudio *pw)
 689 {
 690     int res;
 691     pw->pending_seq = pw_core_sync(pw->core, PW_ID_CORE, pw->pending_seq);
 692
 693     while (true) {
 694         pw_thread_loop_wait(pw->thread_loop);
 695
 696         res = pw->error;
 697         if (res < 0) {
 698             pw->error = 0;
 699             return res;
 700         }
 701         if (pw->pending_seq == pw->last_seq) {
 702             break;
 703         }
 704     }
 705     return 0;
 706 }
 707
 708 static void
 709 on_core_error(void *data, uint32_t id, int seq, int res, const char *message)
 710 {
 711     pwaudio *pw = data;
 712
 713     error_report("error id:%u seq:%d res:%d (%s): %s",
 714                 id, seq, res, spa_strerror(res), message);
 715
 716     /* stop and exit the thread loop */
 717     pw_thread_loop_signal(pw->thread_loop, FALSE);
 718 }
 719
 720 static void
 721 on_core_done(void *data, uint32_t id, int seq)
 722 {
 723     pwaudio *pw = data;
 724     assert(id == PW_ID_CORE);
 725     pw->last_seq = seq;
 726     if (pw->pending_seq == seq) {
 727         /* stop and exit the thread loop */
 728         pw_thread_loop_signal(pw->thread_loop, FALSE);
 729     }
 730 }
 731
 732 static const struct pw_core_events core_events = {
 733     PW_VERSION_CORE_EVENTS,
 734     .done = on_core_done,
 735     .error = on_core_error,
 736 };
 737
 738 static void *
 739 qpw_audio_init(Audiodev *dev)
 740 {
 741     g_autofree pwaudio *pw = g_new0(pwaudio, 1);
 742
 743     assert(dev->driver == AUDIODEV_DRIVER_PIPEWIRE);
 744     trace_pw_audio_init();
 745
 746     pw_init(NULL, NULL);
 747
 748     pw->dev = dev;
 749     pw->thread_loop = pw_thread_loop_new("PipeWire thread loop", NULL);
 750     if (pw->thread_loop == NULL) {
 751         error_report("Could not create PipeWire loop: %s", g_strerror(errno));
 752         goto fail;
 753     }
 754
 755     pw->context =
 756         pw_context_new(pw_thread_loop_get_loop(pw->thread_loop), NULL, 0);
 757     if (pw->context == NULL) {
 758         error_report("Could not create PipeWire context: %s", g_strerror(errno));
 759         goto fail;
 760     }
 761
 762     if (pw_thread_loop_start(pw->thread_loop) < 0) {
 763         error_report("Could not start PipeWire loop: %s", g_strerror(errno));
 764         goto fail;
 765     }
 766
 767     pw_thread_loop_lock(pw->thread_loop);
 768
 769     pw->core = pw_context_connect(pw->context, NULL, 0);
 770     if (pw->core == NULL) {
 771         pw_thread_loop_unlock(pw->thread_loop);
 772         goto fail;
 773     }
 774
 775     if (pw_core_add_listener(pw->core, &pw->core_listener,
 776                              &core_events, pw) < 0) {
 777         pw_thread_loop_unlock(pw->thread_loop);
 778         goto fail;
 779     }
 780     if (wait_resync(pw) < 0) {
 781         pw_thread_loop_unlock(pw->thread_loop);
 782     }
 783
 784     pw_thread_loop_unlock(pw->thread_loop);
 785
 786     return g_steal_pointer(&pw);
 787
 788 fail:
 789     AUD_log(AUDIO_CAP, "Failed to initialize PW context");
 790     if (pw->thread_loop) {
 791         pw_thread_loop_stop(pw->thread_loop);
 792     }
 793     g_clear_pointer(&pw->context, pw_context_destroy);
 794     g_clear_pointer(&pw->thread_loop, pw_thread_loop_destroy);
 795     return NULL;
 796 }
 797
 798 static void
 799 qpw_audio_fini(void *opaque)
 800 {
 801     pwaudio *pw = opaque;
 802
 803     if (pw->thread_loop) {
 804         pw_thread_loop_stop(pw->thread_loop);
 805     }
 806
 807     if (pw->core) {
 808         spa_hook_remove(&pw->core_listener);
 809         spa_zero(pw->core_listener);
 810         pw_core_disconnect(pw->core);
 811     }
 812
 813     if (pw->context) {
 814         pw_context_destroy(pw->context);
 815     }
 816     pw_thread_loop_destroy(pw->thread_loop);
 817
 818     g_free(pw);
 819 }
 820
 821 static struct audio_pcm_ops qpw_pcm_ops = {
 822     .init_out = qpw_init_out,
 823     .fini_out = qpw_fini_out,
 824     .write = qpw_write,
 825     .buffer_get_free = qpw_buffer_get_free,
 826     .run_buffer_out = audio_generic_run_buffer_out,
 827     .enable_out = qpw_enable_out,
 828     .volume_out = qpw_volume_out,
 829     .volume_in = qpw_volume_in,
 830
 831     .init_in = qpw_init_in,
 832     .fini_in = qpw_fini_in,
 833     .read = qpw_read,
 834     .run_buffer_in = audio_generic_run_buffer_in,
 835     .enable_in = qpw_enable_in
 836 };
 837
 838 static struct audio_driver pw_audio_driver = {
 839     .name = "pipewire",
 840     .descr = "http://www.pipewire.org/",
 841     .init = qpw_audio_init,
 842     .fini = qpw_audio_fini,
 843     .pcm_ops = &qpw_pcm_ops,
 844     .can_be_default = 1,
 845     .max_voices_out = INT_MAX,
 846     .max_voices_in = INT_MAX,
 847     .voice_size_out = sizeof(PWVoiceOut),
 848     .voice_size_in = sizeof(PWVoiceIn),
 849 };
 850
 851 static void
 852 register_audio_pw(void)
 853 {
 854     audio_driver_register(&pw_audio_driver);
 855 }
 856
 857 type_init(register_audio_pw);