Bunch More Work. Actually sort of usable now in limited ways!

Actually compiles, bunch of bug fixes etc, has a (very bad) WAV decoder,
a simple test app, etc.

Still a lot to go, but it's looping a sound with a custom mid-data loop point
and explicit stop point that it fades in over time. It's progress!

Author: icculus

include/SDL3_mixer/SDL_mixer.h

@@ -59,9 +59,10 @@ extern SDL_DECLSPEC Mix_Audio * SDLCALL Mix_LoadAudio_IO(SDL_IOStream *io, bool
 extern SDL_DECLSPEC Mix_Audio * SDLCALL Mix_LoadAudio(const char *path, bool predecode);
 extern SDL_DECLSPEC Mix_Audio * SDLCALL Mix_LoadAudioWithProperties(SDL_PropertiesID props);  // lets you specify things like "here's a path to MIDI instrument files outside of this file", etc.
 
-#define MIX_PROP_AUDIO_LOAD_IOSTREAM_POINTER "SDL_mixer.audio_load.iostream"
-#define MIX_PROP_AUDIO_LOAD_CLOSEIO_BOOLEAN "SDL_mixer.audio_load.closeio"
-#define MIX_PROP_AUDIO_LOAD_PREDECODE_BOOLEAN "SDL_mixer.audio_load.predecode"
+#define MIX_PROP_AUDIO_LOAD_IOSTREAM_POINTER "SDL_mixer.audio.load.iostream"
+#define MIX_PROP_AUDIO_LOAD_CLOSEIO_BOOLEAN "SDL_mixer.audio.load.closeio"
+#define MIX_PROP_AUDIO_LOAD_PREDECODE_BOOLEAN "SDL_mixer.audio.load.predecode"
+#define MIX_PROP_AUDIO_DECODER_STRING "SDL_mixer.audio.decoder"
 
 
 extern SDL_DECLSPEC SDL_PropertiesID SDLCALL Mix_GetAudioProperties(Mix_Audio *audio);  // we can store audio format-specific metadata in here (artist/album/etc info...)

src/SDL_mixer.c

@@ -25,11 +25,12 @@ typedef struct Mix_Decoder
 {
     const char *name;
     bool (SDLCALL *init)(void);   // initialize the decoder (load external libraries, etc).
-    bool (SDLCALL *prepare_audio)(const void *data, size_t datalen, SDL_AudioSpec *spec, SDL_PropertiesID props, SDL_PropertiesID *metadata_props);  // see if it's a supported format, init spec, set metadata in props.
-    bool (SDLCALL *init_track)(const void *data, size_t datalen, const SDL_AudioSpec *spec, SDL_PropertiesID metadata_props, void **userdata);
+    bool (SDLCALL *init_audio)(const void *data, size_t datalen, SDL_AudioSpec *spec, SDL_PropertiesID props, void **audio_userdata);  // see if it's a supported format, init spec, set metadata in props, allocate static userdata.
+    bool (SDLCALL *init_track)(void *audio_userdata, const void *data, size_t datalen, const SDL_AudioSpec *spec, SDL_PropertiesID metadata_props, void **userdata);
     int  (SDLCALL *decode)(void *userdata, void *buffer, size_t buflen);
     bool (SDLCALL *seek)(void *userdata, Uint64 frame);
     void (SDLCALL *quit_track)(void *userdata);
+    void (SDLCALL *quit_audio)(void *audio_userdata);
     void (SDLCALL *quit)(void);   // deinitialize the decoder (unload external libraries, etc).
 } Mix_Decoder;
 
@@ -48,6 +49,7 @@ struct Mix_Audio
     size_t buflen;
     SDL_AudioSpec spec;
     const Mix_Decoder *decoder;
+    void *decoder_userdata;
     Mix_Audio *prev;  // double-linked list for all_audios.
     Mix_Audio *next;
 };
@@ -58,17 +60,17 @@ struct Mix_Track
     size_t input_buffer_len;  // number of bytes allocated to input_buffer.
     Mix_Audio *input_audio;    // non-NULL if used with Mix_SetTrackAudioStream. Holds a reference.
     SDL_AudioStream *input_stream;  // non-NULL if used with Mix_SetTrackAudioStream. Not owned by SDL_mixer!
-    void *decoder_state;  // Mix_Decoder-specific data for this run, if any.
+    void *decoder_userdata;  // Mix_Decoder-specific data for this run, if any.
     SDL_AudioSpec input_spec;  // data from input_stream or input_audio is in this format.
     SDL_AudioSpec output_spec;  // processed data we send to SDL is in this format.
     SDL_AudioStream *output_stream;  // the stream that is bound to the audio device.
     Mix_TrackState state;  // playing, paused, stopped.
     Uint64 position;   // sample frames played from start of file.
-    Uint64 silence_frames;  // number of frames of silence to mix at the end of the track.
+    Sint64 silence_frames;  // number of frames of silence to mix at the end of the track.
     Sint64 max_frames;   // consider audio at EOF after this many sample frames.
     bool fire_and_forget;  // true if this is a Mix_Track managed internally for fire-and-forget playback.
-    int fade_frames;  // fade in or out for this many sample frames.
-    Uint64 fade_start_frame;  // fade in or out starting on this sample frame.
+    Sint64 total_fade_frames;  // fade in or out for this many sample frames.
+    Sint64 fade_frames;  // remaining frames to fade.
     int fade_direction;  // -1: fade out  0: don't fade  1: fade in
     int loops_remaining;  // seek to loop_start and continue this many more times at end of input. Negative to loop forever.
     int loop_start;      // sample frame position for loops to begin, so you can play an intro once and then loop from an internal point thereafter.
@@ -82,6 +84,13 @@ struct Mix_Track
     Mix_Track *fire_and_forget_next;  // linked list for the fire-and-forget pool.
 };
 
+// these are not (currently) available in the public API, and may change names or functionality, or be removed.
+#define MIX_PROP_DECODER_NAME_STRING "SDL_mixer.decoder.name"
+#define MIX_PROP_DECODER_FORMAT_NUMBER "SDL_mixer.decoder.format"
+#define MIX_PROP_DECODER_CHANNELS_NUMBER "SDL_mixer.decoder.channels"
+#define MIX_PROP_DECODER_FREQ_NUMBER "SDL_mixer.decoder.format"
+
+
 
 // these might not all be available, but they are all declared here as if they are.
 extern Mix_Decoder Mix_Decoder_WAV;

src/SDL_mixer_internal.h

@@ -0,0 +1,128 @@
+/*
+  SDL_mixer:  An audio mixer library based on the SDL library
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "SDL_mixer_internal.h"
+
+typedef struct RAW_UserData
+{
+    const Uint8 *data;
+    size_t datalen;
+    size_t position;
+    size_t framesize;
+    size_t total_frames;
+} RAW_UserData;
+
+static bool RAW_init(void)
+{
+    return true;  // always succeeds.
+}
+
+static bool RAW_init_audio(const void *data, size_t datalen, SDL_AudioSpec *spec, SDL_PropertiesID props, void **audio_userdata)
+{
+    const char *decoder_name = SDL_GetStringProperty(props, MIX_PROP_AUDIO_DECODER_STRING, NULL);
+    if (!decoder_name || (SDL_strcasecmp(decoder_name, "raw") != 0)) {
+        return false;
+    }
+
+    const Sint64 si64fmt = SDL_GetNumberProperty(props, MIX_PROP_DECODER_FORMAT_NUMBER, -1);
+    const Sint64 si64channels = SDL_GetNumberProperty(props, MIX_PROP_DECODER_CHANNELS_NUMBER, -1);
+    const Sint64 si64freq = SDL_GetNumberProperty(props, MIX_PROP_DECODER_FREQ_NUMBER, -1);
+
+    if ((si64fmt <= 0) || (si64channels <= 0) || (si64freq <= 0)) {
+        return false;
+    }
+
+    spec->format = (SDL_AudioFormat) si64fmt;
+    spec->channels = (int) si64channels;
+    spec->freq = (int) si64freq;
+
+    // we don't have to inspect the data, we treat anything as valid.
+    *audio_userdata = NULL;
+
+    return true;
+}
+
+static bool RAW_init_track(void *audio_userdata, const void *data, size_t datalen, const SDL_AudioSpec *spec, SDL_PropertiesID props, void **userdata)
+{
+    RAW_UserData *d = (RAW_UserData *) SDL_calloc(1, sizeof (*d));
+    if (!d) {
+        return false;
+    }
+
+    // Clamp data to complete sample frames, just in case.
+    d->data = data;
+    d->framesize = SDL_AUDIO_FRAMESIZE(*spec);
+    d->total_frames = datalen / d->framesize;
+    d->datalen = d->total_frames * d->framesize;
+    *userdata = d;
+
+    return true;
+}
+
+static int RAW_decode(void *userdata, void *buffer, size_t buflen)
+{
+    RAW_UserData *d = (RAW_UserData *) userdata;
+    const size_t remaining = d->datalen - d->position;
+    const size_t cpy = SDL_min(buflen, remaining);
+    if (cpy) {
+        SDL_memcpy(buffer, d->data + d->position, cpy);
+        d->position += cpy;
+    }
+    return cpy;
+}
+
+static bool RAW_seek(void *userdata, Uint64 frame)
+{
+    RAW_UserData *d = (RAW_UserData *) userdata;
+    if (frame > d->total_frames) {
+        return SDL_SetError("Seek past end of data");
+    }
+    d->position = (size_t) (frame * d->framesize);
+    return true;
+}
+
+static void RAW_quit_track(void *userdata)
+{
+    SDL_free(userdata);
+}
+
+static void RAW_quit_audio(void *audio_userdata)
+{
+    SDL_assert(!audio_userdata);
+}
+
+static void RAW_quit(void)
+{
+    // no-op.
+}
+
+Mix_Decoder Mix_Decoder_RAW = {
+    "RAW",
+    RAW_init,
+    RAW_init_audio,
+    RAW_init_track,
+    RAW_decode,
+    RAW_seek,
+    RAW_quit_track,
+    RAW_quit_audio,
+    RAW_quit
+};
+

src/decoder_raw.c

@@ -21,21 +21,109 @@
 
 #include "SDL_mixer_internal.h"
 
+typedef struct WAV_AudioUserData
+{
+    Uint8 *data;
+    Uint32 datalen;
+} WAV_AudioUserData;
+
+typedef struct WAV_UserData
+{
+    const Uint8 *data;
+    size_t datalen;
+    size_t position;
+    size_t framesize;
+    size_t total_frames;
+} WAV_UserData;
+
+
 static bool WAV_init(void)
-static bool WAV_prepare_audio(const void *data, size_t datalen, SDL_AudioSpec *spec, SDL_PropertiesID props)
-static bool WAV_init_track(const void *data, size_t datalen, const SDL_AudioSpec *spec, SDL_PropertiesID metadata_props, void **userdata)
-static int  WAV_decode(void *userdata, void *buffer, size_t buflen)
+{
+    return true;  // already available without external dependencies.
+}
+
+static bool WAV_init_audio(const void *data, size_t datalen, SDL_AudioSpec *spec, SDL_PropertiesID props, void **audio_userdata)
+{
+    WAV_AudioUserData *d = (WAV_AudioUserData *) SDL_calloc(1, sizeof (*d));
+    if (!d) {
+        return false;
+    }
+
+    // this is obviously wrong.
+    if (!SDL_LoadWAV_IO(SDL_IOFromConstMem(data, datalen), true, spec, &d->data, &d->datalen)) {
+        SDL_free(d);
+        return false;
+    }
+
+    *audio_userdata = d;
+
+    return true;
+}
+
+static bool WAV_init_track(void *audio_userdata, const void *data, size_t datalen, const SDL_AudioSpec *spec, SDL_PropertiesID props, void **userdata)
+{
+    WAV_AudioUserData *ad = (WAV_AudioUserData *) audio_userdata;
+    WAV_UserData *d = (WAV_UserData *) SDL_calloc(1, sizeof (*d));
+    if (!d) {
+        return false;
+    }
+
+    // Clamp data to complete sample frames, just in case.
+    d->data = ad->data;
+    d->framesize = SDL_AUDIO_FRAMESIZE(*spec);
+    d->total_frames = ad->datalen / d->framesize;
+    d->datalen = (size_t) (d->total_frames * d->framesize);
+    *userdata = d;
+
+    return true;
+}
+
+static int WAV_decode(void *userdata, void *buffer, size_t buflen)
+{
+    WAV_UserData *d = (WAV_UserData *) userdata;
+    const size_t remaining = d->datalen - d->position;
+    const size_t cpy = SDL_min(buflen, remaining);
+    if (cpy) {
+        SDL_memcpy(buffer, d->data + d->position, cpy);
+        d->position += cpy;
+    }
+    return cpy;
+}
+
 static bool WAV_seek(void *userdata, Uint64 frame)
+{
+    WAV_UserData *d = (WAV_UserData *) userdata;
+    if (frame > d->total_frames) {
+        return SDL_SetError("Seek past end of data");
+    }
+    d->position = (size_t) (frame * d->framesize);
+    return true;
+}
+
 static void WAV_quit_track(void *userdata)
+{
+    SDL_free(userdata);
+}
+
+static void WAV_quit_audio(void *audio_userdata)
+{
+    SDL_free(audio_userdata);
+}
+
 static void WAV_quit(void)
+{
+    // no-op.
+}
 
 Mix_Decoder Mix_Decoder_WAV = {
     "WAV",
     WAV_init,
+    WAV_init_audio,
     WAV_init_track,
     WAV_decode,
     WAV_seek,
     WAV_quit_track,
+    WAV_quit_audio,
     WAV_quit
 };
 

src/decoder_wav.c

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+gcc -O0 -Wall -ggdb3 -I../include -o testmixer SDL_mixer.c decoder_wav.c decoder_raw.c testmixer.c `pkg-config sdl3 --cflags --libs`
+

src/make.sh

@@ -0,0 +1,56 @@
+#define SDL_MAIN_USE_CALLBACKS 1  /* use the callbacks instead of main() */
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_main.h>
+#include "SDL3_mixer/SDL_mixer.h"
+
+//static SDL_Window *window = NULL;
+//static SDL_Renderer *renderer = NULL;
+static Mix_Track *track = NULL;
+
+SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[])
+{
+    SDL_SetAppMetadata("Test SDL_mixer", "1.0", "org.libsdl.testmixer");
+
+    if (!SDL_Init(SDL_INIT_VIDEO)) {   // it's safe to SDL_INIT_AUDIO, but SDL_mixer will do it for us.
+        SDL_Log("Couldn't initialize SDL: %s", SDL_GetError());
+        return SDL_APP_FAILURE;
+//    } else if (!SDL_CreateWindowAndRenderer("testmixer", 640, 480, 0, &window, &renderer)) {
+//        SDL_Log("Couldn't create window/renderer: %s", SDL_GetError());
+//        return SDL_APP_FAILURE;
+    } else if (!Mix_OpenAudio(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, NULL)) {
+        SDL_Log("Couldn't create mixer: %s", SDL_GetError());
+        return SDL_APP_FAILURE;
+    }
+
+    Mix_Audio *audio = Mix_LoadAudio("sample.wav", false);
+    track = Mix_CreateTrack();
+
+    Mix_SetTrackAudio(track, audio);
+    Mix_PlayTrack(track, Mix_TrackMSToFrames(track, 9440), 3, 0, Mix_TrackMSToFrames(track, 6097), Mix_TrackMSToFrames(track, 30000), Mix_TrackMSToFrames(track, 3000));
+//Sint64 maxFrames, int loops, Sint64 startpos, Sint64 loop_start, Sint64 fadeIn, Sint64 append_silence_frames);
+
+    return SDL_APP_CONTINUE;
+}
+
+SDL_AppResult SDL_AppEvent(void *appstate, SDL_Event *event)
+{
+    if (event->type == SDL_EVENT_QUIT) {
+        return SDL_APP_SUCCESS;
+    }
+    return SDL_APP_CONTINUE;
+}
+
+SDL_AppResult SDL_AppIterate(void *appstate)
+{
+//    SDL_RenderClear(renderer);
+//    SDL_RenderPresent(renderer);
+    return Mix_Playing(track) ? SDL_APP_CONTINUE : SDL_APP_SUCCESS;
+}
+
+void SDL_AppQuit(void *appstate, SDL_AppResult result)
+{
+    // SDL will clean up the window/renderer for us.
+    // SDL_mixer will clean up the track and audio.
+    Mix_CloseAudio();
+}
+