Merge pull request libretro#17928 from BinBashBanana/master

Rewrite RWebAudio driver

Author: LibretroAdmin

CHANGES.md

@@ -3,6 +3,7 @@
 - EMSCRIPTEN/RWEBCAM: Fix camera driver
 - EMSCRIPTEN/RWEBINPUT: Add accelerometer/gyroscope support
 - EMSCRIPTEN/RWEBPAD: Add rumble support
+- EMSCRIPTEN/RWEBAUDIO: Rewrite driver, set as default audio driver
 
 # 1.21.0
 - 3DS: Fix unique IDs for newer cores

Makefile.emscripten

@@ -27,7 +27,7 @@ HAVE_GLSL = 1
 HAVE_SCREENSHOTS = 1
 HAVE_REWIND = 1
 HAVE_AUDIOMIXER = 1
-HAVE_CC_RESAMPLER = 1
+HAVE_CC_RESAMPLER ?= 1
 HAVE_EGL ?= 0
 HAVE_OPENGLES = 1
 HAVE_RJPEG = 0
@@ -54,27 +54,21 @@ HAVE_BSV_MOVIE = 1
 HAVE_CHD ?= 0
 HAVE_NETPLAYDISCOVERY ?= 0
 
-HAVE_AL ?= 1
-
 # enables pthreads, requires special headers on the web server:
 # see https://web.dev/articles/coop-coep
 HAVE_THREADS ?= 0
 
 # requires HAVE_THREADS
 HAVE_AUDIOWORKLET ?= 0
 
-# WARNING -- READ BEFORE ENABLING
-# The rwebaudio driver is known to have several audio bugs, such as
-#  minor crackling, or the entire page freezing/crashing.
-#  It works perfectly on chrome, but even firefox has really bad audio quality.
-#  I should also note, the driver on iOS is completely broken (crashes the page).
-#  You have been warned.
-HAVE_RWEBAUDIO ?= 0
-
-# whether the browser thread is allowed to block to wait for audio to play,
-# may lead to the issues mentioned above.
-# currently this variable is only used by audioworklet;
-# rwebaudio will always busywait and openal will never busywait.
+# doesn't work on PROXY_TO_PTHREAD
+HAVE_RWEBAUDIO ?= 1
+
+# requires ASYNC or PROXY_TO_PTHREAD
+HAVE_AL ?= 0
+
+# whether the browser thread is allowed to block to wait for audio to play, not CPU usage-friendly!
+# currently this variable is only used by rwebaudio and audioworklet; openal will never busywait.
 ALLOW_AUDIO_BUSYWAIT ?= 0
 
 # minimal asyncify; better performance than full asyncify,
@@ -196,6 +190,9 @@ endif
 ifeq ($(HAVE_RWEBAUDIO), 1)
    LDFLAGS += --js-library emscripten/library_rwebaudio.js
    DEFINES += -DHAVE_RWEBAUDIO
+   ifeq ($(PROXY_TO_PTHREAD), 1)
+      $(error ERROR: RWEBAUDIO is incompatible with PROXY_TO_PTHREAD)
+   endif
 endif
 
 ifeq ($(HAVE_AUDIOWORKLET), 1)
@@ -205,18 +202,24 @@ ifeq ($(HAVE_AUDIOWORKLET), 1)
    ifeq ($(HAVE_THREADS), 0)
       $(error ERROR: AUDIOWORKLET requires HAVE_THREADS)
    endif
-   ifeq ($(PROXY_TO_PTHREAD), 1)
-   else ifeq ($(ASYNC), 1)
+endif
+
+ifeq ($(HAVE_AL), 1)
+   LDFLAGS += -lopenal
+   DEFINES += -DHAVE_AL
+endif
+
+ifeq ($(PROXY_TO_PTHREAD), 1)
+else ifeq ($(ASYNC), 1)
+else
+   DEFINES += -DEMSCRIPTEN_AUDIO_EXTERNAL_BLOCK
+   ifeq ($(MIN_ASYNC), 1)
+      DEFINES += -DEMSCRIPTEN_AUDIO_ASYNC_BLOCK
    else
-      DEFINES += -DEMSCRIPTEN_AUDIO_EXTERNAL_BLOCK
-      ifeq ($(MIN_ASYNC), 1)
-         DEFINES += -DEMSCRIPTEN_AUDIO_ASYNC_BLOCK
-      else
-         DEFINES += -DEMSCRIPTEN_AUDIO_FAKE_BLOCK
-      endif
-      ifneq ($(ALLOW_AUDIO_BUSYWAIT), 1)
-         DEFINES += -DEMSCRIPTEN_AUDIO_EXTERNAL_WRITE_BLOCK
-      endif
+      DEFINES += -DEMSCRIPTEN_AUDIO_FAKE_BLOCK
+   endif
+   ifneq ($(ALLOW_AUDIO_BUSYWAIT), 1)
+      DEFINES += -DEMSCRIPTEN_AUDIO_EXTERNAL_WRITE_BLOCK
    endif
 endif
 
@@ -227,16 +230,11 @@ endif
 # explanation of some of these defines:
 # EMSCRIPTEN_AUDIO_EXTERNAL_BLOCK: audio blocking occurs in the main loop instead of in the audio driver functions.
 # EMSCRIPTEN_AUDIO_EXTERNAL_WRITE_BLOCK: along with above, enables external blocking in the write function.
-# ALLOW_AUDIO_BUSYWAIT: write function will busywait. init function may still use an external block.
+# EMSCRIPTEN_AUDIO_BUSYWAIT: write function will busywait. init function may still use an external block.
 # EMSCRIPTEN_AUDIO_ASYNC_BLOCK: external block uses emscripten_sleep (requires MIN_ASYNC).
 # EMSCRIPTEN_AUDIO_FAKE_BLOCK: external block uses main loop timing (doesn't require asyncify).
 # when building with either PROXY_TO_PTHREAD or ASYNC (full asyncify), none of the above are required.
 
-ifeq ($(HAVE_AL), 1)
-   LDFLAGS += -lopenal
-   DEFINES += -DHAVE_AL
-endif
-
 ifeq ($(HAVE_THREADS), 1)
    LDFLAGS += -pthread -s PTHREAD_POOL_SIZE=$(PTHREAD_POOL_SIZE)
    CFLAGS += -pthread -s SHARED_MEMORY

audio/drivers/rwebaudio.c

@@ -1,6 +1,7 @@
 /*  RetroArch - A frontend for libretro.
  *  Copyright (C) 2010-2015 - Michael Lelli
  *  Copyright (C) 2011-2017 - Daniel De Matteis
+ *  Copyright (C) 2025      - OlyB
  *
  *  RetroArch is free software: you can redistribute it and/or modify it under the terms
  *  of the GNU General Public License as published by the Free Software Found-
@@ -17,81 +18,230 @@
 #include <stdlib.h>
 #include <unistd.h>
 #include <boolean.h>
+#include <retro_timers.h>
 
 #include "../audio_driver.h"
+#include "../../verbosity.h"
+#include "../../frontend/drivers/platform_emscripten.h"
+
+#define RWEBAUDIO_BUFFER_SIZE_MS 10
 
 /* forward declarations */
 unsigned RWebAudioSampleRate(void);
 void *RWebAudioInit(unsigned latency);
-ssize_t RWebAudioWrite(const void *s, size_t len);
+ssize_t RWebAudioQueueBuffer(size_t num_frames, float *left, float *right);
 bool RWebAudioStop(void);
 bool RWebAudioStart(void);
 void RWebAudioSetNonblockState(bool state);
 void RWebAudioFree(void);
-size_t RWebAudioWriteAvail(void);
-size_t RWebAudioBufferSize(void);
+size_t RWebAudioWriteAvailFrames(void);
+size_t RWebAudioBufferSizeFrames(void);
+void RWebAudioRecalibrateTime(void);
+bool RWebAudioResumeCtx(void);
 
-typedef struct rweb_audio
+typedef struct rwebaudio_data
 {
-   bool is_paused;
-} rweb_audio_t;
+   size_t tmpbuf_frames;
+   size_t tmpbuf_offset;
+   float *tmpbuf_left;
+   float *tmpbuf_right;
+   bool nonblock;
+   bool running;
+#ifdef EMSCRIPTEN_AUDIO_FAKE_BLOCK
+   bool block_requested;
+#endif
+} rwebaudio_data_t;
+
+static rwebaudio_data_t *rwebaudio_static_data = NULL;
 
 static void rwebaudio_free(void *data)
 {
+   rwebaudio_data_t *rwebaudio = (rwebaudio_data_t*)data;
+   if (!rwebaudio)
+      return;
+
    RWebAudioFree();
-   free(data);
+   if (rwebaudio->tmpbuf_left)
+      free(rwebaudio->tmpbuf_left);
+   if (rwebaudio->tmpbuf_right)
+      free(rwebaudio->tmpbuf_right);
+   free(rwebaudio);
+   rwebaudio_static_data = NULL;
 }
 
 static void *rwebaudio_init(const char *device, unsigned rate, unsigned latency,
       unsigned block_frames,
       unsigned *new_rate)
 {
-   rweb_audio_t *rwebaudio = (rweb_audio_t*)calloc(1, sizeof(rweb_audio_t));
+   rwebaudio_data_t *rwebaudio;
+   if (rwebaudio_static_data)
+   {
+      RARCH_ERR("[RWebAudio] Tried to start already running driver!\n");
+      return NULL;
+   }
+
+   rwebaudio = (rwebaudio_data_t*)calloc(1, sizeof(rwebaudio_data_t));
    if (!rwebaudio)
       return NULL;
-   if (RWebAudioInit(latency))
-      *new_rate         = RWebAudioSampleRate();
+   if (!RWebAudioInit(latency))
+   {
+      RARCH_ERR("[RWebAudio] Failed to initialize driver!\n");
+      return NULL;
+   }
+   rwebaudio_static_data = rwebaudio;
+   *new_rate = RWebAudioSampleRate();
+   rwebaudio->tmpbuf_frames = RWEBAUDIO_BUFFER_SIZE_MS * *new_rate / 1000;
+   rwebaudio->tmpbuf_left   = memalign(sizeof(float), rwebaudio->tmpbuf_frames * sizeof(float));
+   rwebaudio->tmpbuf_right  = memalign(sizeof(float), rwebaudio->tmpbuf_frames * sizeof(float));
+   RARCH_LOG("[RWebAudio] Device rate: %d Hz.\n", *new_rate);
+   RARCH_LOG("[RWebAudio] Buffer size: %lu bytes.\n", RWebAudioBufferSizeFrames() * 2 * sizeof(float));
    return rwebaudio;
 }
 
 static ssize_t rwebaudio_write(void *data, const void *s, size_t len)
 {
-   return RWebAudioWrite(s, len);
+   rwebaudio_data_t *rwebaudio = (rwebaudio_data_t*)data;
+   const float *samples = (const float*)s;
+   size_t num_frames = len / 2 / sizeof(float);
+   size_t written = 0;
+   if (!rwebaudio)
+      return -1;
+
+   while (num_frames)
+   {
+      rwebaudio->tmpbuf_left[rwebaudio->tmpbuf_offset]  = *(samples++);
+      rwebaudio->tmpbuf_right[rwebaudio->tmpbuf_offset] = *(samples++);
+      num_frames--;
+      if (++rwebaudio->tmpbuf_offset == rwebaudio->tmpbuf_frames)
+      {
+         size_t queued = RWebAudioQueueBuffer(rwebaudio->tmpbuf_frames, rwebaudio->tmpbuf_left, rwebaudio->tmpbuf_right);
+         rwebaudio->tmpbuf_offset = 0;
+         /* fast-forward or context is suspended */
+         if (queued < rwebaudio->tmpbuf_frames)
+            break;
+         written += queued;
+      }
+   }
+
+   if (rwebaudio->nonblock)
+      return written;
+
+#ifdef EMSCRIPTEN_AUDIO_EXTERNAL_WRITE_BLOCK
+#ifdef EMSCRIPTEN_AUDIO_FAKE_BLOCK
+   if (RWebAudioWriteAvailFrames() == 0)
+   {
+      rwebaudio->block_requested = true;
+      platform_emscripten_enter_fake_block(1);
+   }
+#endif
+   /* async external block doesn't need to do anything else */
+#else
+   while (RWebAudioWriteAvailFrames() == 0)
+   {
+#ifdef EMSCRIPTEN_FULL_ASYNCIFY
+      retro_sleep(1);
+#endif
+      RWebAudioResumeCtx();
+   }
+#endif
+
+   return written;
 }
 
-static bool rwebaudio_stop(void *data)
+#ifdef EMSCRIPTEN_AUDIO_EXTERNAL_BLOCK
+/* returns true if fake block should continue */
+bool rwebaudio_external_block(void)
 {
-   rweb_audio_t *rwebaudio = (rweb_audio_t*)data;
+   rwebaudio_data_t *rwebaudio = rwebaudio_static_data;
+
    if (!rwebaudio)
       return false;
-   rwebaudio->is_paused = true;
-   return RWebAudioStop();
+
+#ifdef EMSCRIPTEN_AUDIO_FAKE_BLOCK
+   if (!rwebaudio->block_requested)
+      return false;
+#endif
+
+#ifdef EMSCRIPTEN_AUDIO_EXTERNAL_WRITE_BLOCK
+   while (!rwebaudio->nonblock && RWebAudioWriteAvailFrames() == 0)
+   {
+      RWebAudioResumeCtx();
+#ifdef EMSCRIPTEN_AUDIO_ASYNC_BLOCK
+      retro_sleep(1);
+#else
+      return true;
+#endif
+   }
+#endif
+
+#ifdef EMSCRIPTEN_AUDIO_FAKE_BLOCK
+   rwebaudio->block_requested = false;
+   platform_emscripten_exit_fake_block();
+   return true; /* return to RAF if needed */
+#endif
+   return false;
 }
+#endif
 
-static void rwebaudio_set_nonblock_state(void *data, bool state)
+void rwebaudio_recalibrate_time(void)
 {
-   RWebAudioSetNonblockState(state);
+   if (rwebaudio_static_data)
+      RWebAudioRecalibrateTime();
 }
 
-static bool rwebaudio_alive(void *data)
+static bool rwebaudio_stop(void *data)
 {
-   rweb_audio_t *rwebaudio = (rweb_audio_t*)data;
+   rwebaudio_data_t *rwebaudio = (rwebaudio_data_t*)data;
    if (!rwebaudio)
       return false;
-   return !rwebaudio->is_paused;
+   rwebaudio->running = false;
+   return RWebAudioStop();
 }
 
 static bool rwebaudio_start(void *data, bool is_shutdown)
 {
-   rweb_audio_t *rwebaudio = (rweb_audio_t*)data;
+   rwebaudio_data_t *rwebaudio = (rwebaudio_data_t*)data;
    if (!rwebaudio)
       return false;
-   rwebaudio->is_paused = false;
+   rwebaudio->running = true;
    return RWebAudioStart();
 }
 
-static size_t rwebaudio_write_avail(void *data) {return RWebAudioWriteAvail();}
-static size_t rwebaudio_buffer_size(void *data) {return RWebAudioBufferSize();}
+static bool rwebaudio_alive(void *data)
+{
+   rwebaudio_data_t *rwebaudio = (rwebaudio_data_t*)data;
+   if (!rwebaudio)
+      return false;
+   return rwebaudio->running;
+}
+
+static void rwebaudio_set_nonblock_state(void *data, bool state)
+{
+   rwebaudio_data_t *rwebaudio = (rwebaudio_data_t*)data;
+   if (!rwebaudio)
+      return;
+   rwebaudio->nonblock = state;
+   RWebAudioSetNonblockState(state);
+}
+
+static size_t rwebaudio_write_avail(void *data)
+{
+   rwebaudio_data_t *rwebaudio = (rwebaudio_data_t*)data;
+   size_t avail_frames;
+   if (!rwebaudio)
+      return 0;
+
+   avail_frames = RWebAudioWriteAvailFrames();
+   if (avail_frames > rwebaudio->tmpbuf_offset)
+      return (avail_frames - rwebaudio->tmpbuf_offset) * 2 * sizeof(float);
+   return 0;
+}
+
+static size_t rwebaudio_buffer_size(void *data)
+{
+   return RWebAudioBufferSizeFrames() * 2 * sizeof(float);
+}
+
 static bool rwebaudio_use_float(void *data) { return true; }
 
 audio_driver_t audio_rwebaudio = {

config.def.h

@@ -1177,7 +1177,7 @@
 
 /* Desired audio latency in milliseconds. Might not be honored
  * if driver can't provide given latency. */
-#if defined(ANDROID) || defined(RETROFW) || defined(MIYOO) || (defined(EMSCRIPTEN) && !defined(HAVE_AUDIOWORKLET))
+#if defined(ANDROID) || defined(RETROFW) || defined(MIYOO) || (defined(EMSCRIPTEN) && defined(HAVE_AL))
 /* For most Android devices, 64ms is way too low. */
 #define DEFAULT_OUT_LATENCY 128
 #define DEFAULT_IN_LATENCY 128
@@ -1683,7 +1683,7 @@
 
 #if defined(__QNX__) || defined(_XBOX1) || defined(_XBOX360) || (defined(__MACH__) && defined(IOS)) || defined(ANDROID) || defined(WIIU) || defined(HAVE_NEON) || defined(GEKKO) || defined(__ARM_NEON__) || defined(__PS3__)
 #define DEFAULT_AUDIO_RESAMPLER_QUALITY_LEVEL RESAMPLER_QUALITY_LOWER
-#elif defined(PSP) || defined(_3DS) || defined(VITA) || defined(PS2) || defined(DINGUX) || defined(EMSCRIPTEN)
+#elif defined(PSP) || defined(_3DS) || defined(VITA) || defined(PS2) || defined(DINGUX)
 #define DEFAULT_AUDIO_RESAMPLER_QUALITY_LEVEL RESAMPLER_QUALITY_LOWEST
 #else
 #define DEFAULT_AUDIO_RESAMPLER_QUALITY_LEVEL RESAMPLER_QUALITY_NORMAL