rgame 0.1.0 → 0.3.0

data/ext/rgame_core/app/app.c

@@ -95,7 +95,11 @@ struct rgame_app {
     int drawing;
 };
 
-rgame_app *rgame_app_create(int width, int height, const char *title) {
+/* Desktop fullscreen, never a mode change — see the header for why. Named once
+ * so the creation flags and the runtime toggle cannot disagree. */
+#define RGAME_FULLSCREEN_FLAG SDL_WINDOW_FULLSCREEN_DESKTOP
+
+rgame_app *rgame_app_create(int width, int height, const char *title, int fullscreen) {
     if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMECONTROLLER) != 0) {
         SDL_Log("SDL_Init failed: %s", SDL_GetError());
         return NULL;
@@ -114,7 +118,8 @@ rgame_app *rgame_app_create(int width, int height, const char *title) {
         title,
         SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
         width, height,
-        SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN);
+        SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN |
+            (fullscreen ? RGAME_FULLSCREEN_FLAG : 0u));
     if (!app->window) {
         SDL_Log("SDL_CreateWindow failed: %s", SDL_GetError());
         free(app);
@@ -227,14 +232,168 @@ void rgame_app_gl_restore(const rgame_gl_context_save *saved) {
  * the compiler checks — it must not include SDL. These assertions close that
  * gap at compile time, so the two can never drift apart silently.
  */
-_Static_assert(RGAME_KEY_RETURN == SDL_SCANCODE_RETURN, "key id must match SDL scancode");
-_Static_assert(RGAME_KEY_ESCAPE == SDL_SCANCODE_ESCAPE, "key id must match SDL scancode");
-_Static_assert(RGAME_KEY_SPACE == SDL_SCANCODE_SPACE, "key id must match SDL scancode");
-_Static_assert(RGAME_KEY_F1 == SDL_SCANCODE_F1, "key id must match SDL scancode");
-_Static_assert(RGAME_KEY_RIGHT == SDL_SCANCODE_RIGHT, "key id must match SDL scancode");
-_Static_assert(RGAME_KEY_LEFT == SDL_SCANCODE_LEFT, "key id must match SDL scancode");
-_Static_assert(RGAME_KEY_DOWN == SDL_SCANCODE_DOWN, "key id must match SDL scancode");
-_Static_assert(RGAME_KEY_UP == SDL_SCANCODE_UP, "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_A == SDL_SCANCODE_A,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_B == SDL_SCANCODE_B,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_C == SDL_SCANCODE_C,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_D == SDL_SCANCODE_D,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_E == SDL_SCANCODE_E,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_F == SDL_SCANCODE_F,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_G == SDL_SCANCODE_G,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_H == SDL_SCANCODE_H,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_I == SDL_SCANCODE_I,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_J == SDL_SCANCODE_J,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_K == SDL_SCANCODE_K,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_L == SDL_SCANCODE_L,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_M == SDL_SCANCODE_M,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_N == SDL_SCANCODE_N,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_O == SDL_SCANCODE_O,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_P == SDL_SCANCODE_P,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_Q == SDL_SCANCODE_Q,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_R == SDL_SCANCODE_R,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_S == SDL_SCANCODE_S,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_T == SDL_SCANCODE_T,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_U == SDL_SCANCODE_U,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_V == SDL_SCANCODE_V,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_W == SDL_SCANCODE_W,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_X == SDL_SCANCODE_X,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_Y == SDL_SCANCODE_Y,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_Z == SDL_SCANCODE_Z,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_1 == SDL_SCANCODE_1,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_2 == SDL_SCANCODE_2,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_3 == SDL_SCANCODE_3,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_4 == SDL_SCANCODE_4,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_5 == SDL_SCANCODE_5,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_6 == SDL_SCANCODE_6,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_7 == SDL_SCANCODE_7,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_8 == SDL_SCANCODE_8,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_9 == SDL_SCANCODE_9,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_0 == SDL_SCANCODE_0,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_RETURN == SDL_SCANCODE_RETURN,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_ESCAPE == SDL_SCANCODE_ESCAPE,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_BACKSPACE == SDL_SCANCODE_BACKSPACE,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_TAB == SDL_SCANCODE_TAB,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_SPACE == SDL_SCANCODE_SPACE,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_MINUS == SDL_SCANCODE_MINUS,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_EQUALS == SDL_SCANCODE_EQUALS,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_LEFTBRACKET == SDL_SCANCODE_LEFTBRACKET,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_RIGHTBRACKET == SDL_SCANCODE_RIGHTBRACKET,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_BACKSLASH == SDL_SCANCODE_BACKSLASH,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_SEMICOLON == SDL_SCANCODE_SEMICOLON,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_APOSTROPHE == SDL_SCANCODE_APOSTROPHE,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_GRAVE == SDL_SCANCODE_GRAVE,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_COMMA == SDL_SCANCODE_COMMA,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_PERIOD == SDL_SCANCODE_PERIOD,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_SLASH == SDL_SCANCODE_SLASH,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_CAPSLOCK == SDL_SCANCODE_CAPSLOCK,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_F1 == SDL_SCANCODE_F1,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_F2 == SDL_SCANCODE_F2,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_F3 == SDL_SCANCODE_F3,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_F4 == SDL_SCANCODE_F4,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_F5 == SDL_SCANCODE_F5,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_F6 == SDL_SCANCODE_F6,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_F7 == SDL_SCANCODE_F7,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_F8 == SDL_SCANCODE_F8,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_F9 == SDL_SCANCODE_F9,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_F10 == SDL_SCANCODE_F10,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_F11 == SDL_SCANCODE_F11,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_F12 == SDL_SCANCODE_F12,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_INSERT == SDL_SCANCODE_INSERT,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_HOME == SDL_SCANCODE_HOME,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_PAGEUP == SDL_SCANCODE_PAGEUP,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_DELETE == SDL_SCANCODE_DELETE,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_END == SDL_SCANCODE_END,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_PAGEDOWN == SDL_SCANCODE_PAGEDOWN,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_RIGHT == SDL_SCANCODE_RIGHT,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_LEFT == SDL_SCANCODE_LEFT,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_DOWN == SDL_SCANCODE_DOWN,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_UP == SDL_SCANCODE_UP,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_LCTRL == SDL_SCANCODE_LCTRL,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_LSHIFT == SDL_SCANCODE_LSHIFT,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_LALT == SDL_SCANCODE_LALT,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_RCTRL == SDL_SCANCODE_RCTRL,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_RSHIFT == SDL_SCANCODE_RSHIFT,
+               "key id must match SDL scancode");
+_Static_assert(RGAME_KEY_RALT == SDL_SCANCODE_RALT,
+               "key id must match SDL scancode");
 
 /* The snapshot array must be exactly as long as SDL's keyboard state array,
  * since filling it is a straight copy. */
@@ -313,7 +472,13 @@ static void rgame_app_poll_events(rgame_app *app, const rgame_app_callbacks *cb)
             break;
         }
         case SDL_WINDOWEVENT:
-            if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
+            /* SIZE_CHANGED rather than RESIZED, and the difference matters:
+             * SDL sends RESIZED only when something *outside* the program
+             * resized the window, and SIZE_CHANGED for that case as well as for
+             * a size this program asked for. Toggling fullscreen is the second
+             * kind, so a listener on RESIZED alone never hears about it and the
+             * game carries on laying out for the old size. */
+            if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
                 /* The viewport is set from the current size every frame, in the
                  * backend's begin_frame, so there is nothing to update here. */
                 if (cb->resize) {
@@ -400,6 +565,9 @@ void rgame_app_run(rgame_app *app, const rgame_app_callbacks *cb) {
 
             rgame_draw_backend backend = rgame_gl_backend_table(&app->gl);
             rgame_canvas_submit(&app->canvas, &backend);
+            if (cb->frame_end) {
+                cb->frame_end(cb->userdata);
+            }
             SDL_GL_SwapWindow(app->window);
         }
     }
@@ -599,6 +767,23 @@ int rgame_app_push_clip(rgame_app *app, int x, int y, int width, int height) {
     return 1;
 }
 
+void rgame_app_push_layer(rgame_app *app, double base) {
+    rgame_canvas *canvas = drawing_canvas(app);
+    if (canvas) {
+        rgame_canvas_push_layer(canvas, base);
+    }
+}
+
+double rgame_app_layer(rgame_app *app) {
+    rgame_canvas *canvas = drawing_canvas(app);
+    return canvas ? rgame_canvas_layer(canvas) : 0.0;
+}
+
+unsigned int rgame_app_next_layer_slot(rgame_app *app, int band) {
+    rgame_canvas *canvas = drawing_canvas(app);
+    return canvas ? rgame_canvas_next_slot(canvas, band) : 0;
+}
+
 void rgame_app_pop(rgame_app *app) {
     rgame_canvas *canvas = drawing_canvas(app);
     if (canvas) {
@@ -691,6 +876,25 @@ void rgame_app_set_title(rgame_app *app, const char *title) {
     SDL_SetWindowTitle(app->window, title);
 }
 
+void rgame_app_set_fullscreen(rgame_app *app, int fullscreen) {
+    if (!app) {
+        return;
+    }
+    SDL_SetWindowFullscreen(app->window, fullscreen ? RGAME_FULLSCREEN_FLAG : 0u);
+}
+
+int rgame_app_fullscreen(const rgame_app *app) {
+    if (!app) {
+        return 0;
+    }
+    /* Tested against the whole mask rather than for any bit in it:
+     * SDL_WINDOW_FULLSCREEN_DESKTOP is SDL_WINDOW_FULLSCREEN plus one more,
+     * so `flags & FLAG` is also true of an exclusive-fullscreen window — which
+     * this engine never asks for, but a caller could have set behind our back. */
+    Uint32 flags = SDL_GetWindowFlags(app->window);
+    return (flags & RGAME_FULLSCREEN_FLAG) == RGAME_FULLSCREEN_FLAG;
+}
+
 int rgame_app_input_down(const rgame_app *app, int device, int button_id) {
     return rgame_input_state_down(&app->input, device, button_id);
 }

data/ext/rgame_core/app/locale.c

@@ -0,0 +1,67 @@
+/*
+ * locale.c — the user's preferred locales, as the operating system reports
+ * them through SDL.
+ *
+ * rgame_preferred_locales is a thin shim over SDL_GetPreferredLocales; the
+ * joining and the buffer contract are rgame_locale_append, which is pure and
+ * Check-tested. Choosing among the locales is not here at all: it is
+ * RGame::Engine::I18n.choose, specced headless.
+ *
+ * SDL answers without SDL_Init (measured on 2.0.20 under Linux, where it reads
+ * LANG and then LANGUAGE), so none of this belongs to an app.
+ */
+
+#include "app/locale.h"
+
+#include <SDL2/SDL.h>
+#include <string.h>
+
+#include "rgame/core.h"
+
+static size_t append_text(char *out, size_t capacity, size_t length, const char *text) {
+    for (; *text; text++, length++) {
+        if (length + 1 < capacity) {
+            out[length] = *text;
+        }
+    }
+    return length;
+}
+
+size_t rgame_locale_append(char *out, size_t capacity, size_t length, const char *language,
+                           const char *country) {
+    if (language == NULL || language[0] == '\0') {
+        return length;
+    }
+
+    if (length > 0) {
+        length = append_text(out, capacity, length, ",");
+    }
+    length = append_text(out, capacity, length, language);
+    if (country != NULL && country[0] != '\0') {
+        length = append_text(out, capacity, length, "-");
+        length = append_text(out, capacity, length, country);
+    }
+
+    if (capacity > 0) {
+        out[length < capacity ? length : capacity - 1] = '\0';
+    }
+    return length;
+}
+
+size_t rgame_preferred_locales(char *out, size_t capacity) {
+    if (capacity > 0) {
+        out[0] = '\0';
+    }
+
+    SDL_Locale *locales = SDL_GetPreferredLocales();
+    if (locales == NULL) {
+        return 0;
+    }
+
+    size_t length = 0;
+    for (const SDL_Locale *locale = locales; locale->language != NULL; locale++) {
+        length = rgame_locale_append(out, capacity, length, locale->language, locale->country);
+    }
+    SDL_free(locales);
+    return length;
+}

data/ext/rgame_core/app/locale.h

@@ -0,0 +1,28 @@
+#ifndef RGAME_LOCALE_H
+#define RGAME_LOCALE_H
+
+#include <stddef.h>
+
+/*
+ * The pure half of reading the user's preferred locales: joining them into one
+ * "de-AT,en" string in a caller's buffer. No SDL, so the Check suite covers the
+ * truncation contract on every platform, whatever locales the machine it runs
+ * on happens to prefer. locale.c's rgame_preferred_locales is the SDL shim
+ * that feeds it.
+ */
+
+/*
+ * Appends one locale to a list whose full length so far is `length`: a comma
+ * unless the list is empty, then `language`, then "-" and `country` when a
+ * country is given. Returns the list's new full length.
+ *
+ * It behaves like snprintf: `out` receives as much as fits in `capacity`,
+ * always NUL-terminated when `capacity` is non-zero, and the return value is
+ * the length the whole list needs, so a result >= `capacity` means it was
+ * truncated. `length` may already exceed `capacity`. A NULL or empty
+ * `language` appends nothing.
+ */
+size_t rgame_locale_append(char *out, size_t capacity, size_t length, const char *language,
+                           const char *country);
+
+#endif /* RGAME_LOCALE_H */

data/ext/rgame_core/audio/audio.c

@@ -44,6 +44,20 @@
 struct rgame_audio {
     ma_resource_manager resources;
     ma_engine engine;
+    /*
+     * Set only on Windows, only when construction fell back to `noDevice`
+     * because there was nothing to open — see create_audio. Exists so
+     * rgame_audio_backend can still answer "Null" for this engine, matching
+     * what every other no-hardware case on every platform already reports,
+     * even though this engine has no `ma_device` at all for the normal
+     * lookup to find.
+     */
+    int forced_no_device;
+    /*
+     * How many things still need this engine: the owner counts as one, and so
+     * does every sample and song loaded from it. See audio_release.
+     */
+    int refs;
 };
 
 struct rgame_sample {
@@ -131,6 +145,43 @@ static rgame_audio *create_audio(int offline, unsigned int sample_rate, char *er
      * no sound card — a build server, a container — gets a working engine that
      * plays silence rather than an error a game has to handle. Verified: with
      * ALSA and PulseAudio unavailable, the chosen backend is "Null".
+     *
+     * That fallback is *inside* the real backend's own device-open attempt —
+     * it only helps if opening fails cleanly. Verified on Linux, which is the
+     * one platform where it demonstrably does, and where an earlier attempt to
+     * generalise the workaround below broke a leg that had been working.
+     *
+     * On Windows, a machine with zero playback devices at all (every GitHub
+     * Actions Windows runner, among others: confirmed via
+     * `Get-CimInstance Win32_SoundDevice`) crashes instead of failing inside
+     * WASAPI's default-device lookup, so the fallback above never gets a
+     * chance to run.
+     *
+     * Windows alone gets an extra step first: enumerate devices (read-only,
+     * does not attempt to open anything, so it does not hit whatever WASAPI's
+     * own open path gets wrong with no endpoint to find) and, when there are
+     * none, fall back to `noDevice` — the same mode the offline constructor
+     * below uses — rather than the auto-detect list's own real-backend open
+     * attempt.
+     *
+     * macOS looks like the same bug and is not, which is worth stating because
+     * extending this branch to it does nothing. A device-less Mac still
+     * enumerates a playback device, so a zero-device test never fires there;
+     * its equivalent crash is CoreAudio being initialised in a **forked
+     * child**, which macOS forbids outright. That belongs to the test harness
+     * rather than here — see test/test_main.c.
+     *
+     * An *explicit* null-backend device was tried first and rejected: it still
+     * spins up a real background device thread, and that thread crashed inside
+     * a Ruby process in a way the plain-C Check build of the same code never
+     * did. `noDevice` sidesteps the question entirely: with no device and no
+     * background thread, there is nothing left that could crash the way a
+     * thread can.
+     *
+     * Linux is deliberately excluded rather than merely untested. Generalising
+     * this to every platform is what broke its leg once already, and its own
+     * fallback is proven — so the rule here is that a platform opts in on the
+     * strength of a measured crash, not on the logic looking harmless.
      */
     ma_engine_config engine = ma_engine_config_init();
     engine.pResourceManager = &audio->resources;
@@ -141,6 +192,24 @@ static rgame_audio *create_audio(int offline, unsigned int sample_rate, char *er
         engine.channels = 2;
         engine.sampleRate = sample_rate;
     }
+#ifdef _WIN32
+    else {
+        ma_context probe;
+        if (ma_context_init(NULL, 0, NULL, &probe) == MA_SUCCESS) {
+            ma_uint32 playback_count = 0;
+            ma_result enum_result =
+                ma_context_get_devices(&probe, NULL, &playback_count, NULL, NULL);
+            ma_context_uninit(&probe);
+
+            if (enum_result == MA_SUCCESS && playback_count == 0) {
+                engine.noDevice = MA_TRUE;
+                engine.channels = 2;
+                engine.sampleRate = 44100;
+                audio->forced_no_device = 1;
+            }
+        }
+    }
+#endif
 
     if (ma_engine_init(&engine, &audio->engine) != MA_SUCCESS) {
         ma_resource_manager_uninit(&audio->resources);
@@ -149,6 +218,8 @@ static rgame_audio *create_audio(int offline, unsigned int sample_rate, char *er
         return NULL;
     }
 
+    /* The caller's own claim. Sounds add theirs as they are loaded. */
+    audio->refs = 1;
     return audio;
 }
 
@@ -170,8 +241,28 @@ unsigned int rgame_audio_read(rgame_audio *audio, float *out, unsigned int frame
     return (unsigned int)read;
 }
 
-void rgame_audio_destroy(rgame_audio *audio) {
-    if (!audio) {
+/*
+ * Drops one claim on the device, and tears it down when the last one goes.
+ *
+ * The device has to outlive every sound made from it, and a refcount is what
+ * makes that true regardless of the order things are released in. That order is
+ * not ours to choose: Ruby's collector frees unreachable objects in whatever
+ * order it sweeps them, so a Song and the Audio it came from can be freed in
+ * the same pass with the Audio going first. Tearing down a *streaming* voice
+ * then asks the resource manager's job thread to acknowledge it — and that
+ * thread went with the engine, so the wait never returns and the process hangs
+ * rather than crashing.
+ *
+ * Marking the device from the sound, which audio_ext.c does, is a different
+ * guarantee: it keeps the device alive while a sound is still *reachable*. It
+ * says nothing about two objects that became garbage together.
+ *
+ * So the owner holds a reference, every sound holds one, and the last one out
+ * does the uninit. Same shape as the refcounted texture sheet in
+ * graphics/texture.c, and for the same kind of reason.
+ */
+static void audio_release(rgame_audio *audio) {
+    if (!audio || --audio->refs > 0) {
         return;
     }
 
@@ -182,6 +273,10 @@ void rgame_audio_destroy(rgame_audio *audio) {
     free(audio);
 }
 
+void rgame_audio_destroy(rgame_audio *audio) {
+    audio_release(audio);
+}
+
 void rgame_audio_set_volume(rgame_audio *audio, float volume) {
     if (audio) {
         ma_engine_set_volume(&audio->engine, clamp_volume(volume));
@@ -199,6 +294,16 @@ const char *rgame_audio_backend(const rgame_audio *audio) {
         return "none";
     }
 
+    /* The forced-noDevice fallback (see create_audio) has no ma_device for
+     * the normal lookup below to find, but it is standing in for exactly what
+     * the Null backend already means elsewhere — no hardware, silence — so it
+     * answers the same way rather than the more literal but less useful
+     * "none", which every other caller of this function reserves for "there
+     * is no audio object at all". */
+    if (audio->forced_no_device) {
+        return "Null";
+    }
+
     ma_device *device = ma_engine_get_device((ma_engine *)&audio->engine);
     return device ? ma_get_backend_name(device->pContext->backend) : "none";
 }
@@ -293,6 +398,7 @@ rgame_sample *rgame_sample_load(rgame_audio *audio, const char *path, char *err,
     strcpy(sample->path, path);
 
     sample->audio = audio;
+    audio->refs++;
     live_sounds++;
     return sample;
 }
@@ -320,8 +426,10 @@ void rgame_sample_destroy(rgame_sample *sample) {
      * same file hold their own, so the last one out frees it. */
     ma_sound_uninit(&sample->decoded);
     free(sample->path);
+    rgame_audio *audio = sample->audio;
     free(sample);
     live_sounds--;
+    audio_release(audio);
 }
 
 void rgame_sample_play(rgame_sample *sample) {
@@ -396,6 +504,7 @@ rgame_song *rgame_song_load(rgame_audio *audio, const char *path, char *err, siz
     }
 
     song->audio = audio;
+    audio->refs++;
     live_sounds++;
     return song;
 }
@@ -406,8 +515,10 @@ void rgame_song_destroy(rgame_song *song) {
     }
 
     ma_sound_uninit(&song->sound);
+    rgame_audio *audio = song->audio;
     free(song);
     live_sounds--;
+    audio_release(audio);
 }
 
 void rgame_song_play(rgame_song *song, int looping) {