From 6aaedb813fa11ba0679c3051bc2eb28646b9506c Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Sat, 30 Aug 2025 16:53:58 -0700 Subject: Update to SDL3 --- src/contrib/SDL-3.2.20/test/testaudio.c | 1274 +++++++++++++++++++++++++++++++ 1 file changed, 1274 insertions(+) create mode 100644 src/contrib/SDL-3.2.20/test/testaudio.c (limited to 'src/contrib/SDL-3.2.20/test/testaudio.c') diff --git a/src/contrib/SDL-3.2.20/test/testaudio.c b/src/contrib/SDL-3.2.20/test/testaudio.c new file mode 100644 index 0000000..8abb3b2 --- /dev/null +++ b/src/contrib/SDL-3.2.20/test/testaudio.c @@ -0,0 +1,1274 @@ +/* + Copyright (C) 1997-2025 Sam Lantinga + + 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. +*/ + +#define SDL_MAIN_USE_CALLBACKS 1 +#include +#include +#include +#include "testutils.h" + +#define POOF_LIFETIME 250 +#define VISUALIZER_WIDTH 100 +#define VISUALIZER_HEIGHT 50 + +typedef struct Texture +{ + SDL_Texture *texture; + float w; + float h; +} Texture; + +typedef enum ThingType +{ + THING_NULL, + THING_PHYSDEV, + THING_PHYSDEV_RECORDING, + THING_LOGDEV, + THING_LOGDEV_RECORDING, + THING_TRASHCAN, + THING_STREAM, + THING_POOF, + THING_WAV +} ThingType; + + +typedef struct Thing Thing; + +struct Thing +{ + ThingType what; + + union { + struct { + SDL_AudioDeviceID devid; + bool recording; + SDL_AudioSpec spec; + char *name; + } physdev; + struct { + SDL_AudioDeviceID devid; + bool recording; + SDL_AudioSpec spec; + Thing *physdev; + bool visualizer_enabled; + bool visualizer_updated; + SDL_Texture *visualizer; + SDL_Mutex *postmix_lock; + float *postmix_buffer; + int postmix_buflen; + int postmix_allocated; + SDL_AudioSpec postmix_spec; + SDL_AtomicInt postmix_updated; + } logdev; + struct { + SDL_AudioSpec spec; + Uint8 *buf; + Uint32 buflen; + } wav; + struct { + float startw; + float starth; + float centerx; + float centery; + } poof; + struct { + SDL_AudioStream *stream; + int total_bytes; + Uint64 next_level_update; + Uint8 levels[5]; + } stream; + } data; + + Thing *line_connected_to; + char *titlebar; + SDL_FRect rect; + float z; + Uint8 r, g, b, a; + float progress; + float meter; + float scale; + Uint64 createticks; + Texture *texture; + const ThingType *can_be_dropped_onto; + + void (*ontick)(Thing *thing, Uint64 now); + void (*ondrag)(Thing *thing, int button, float x, float y); + void (*ondrop)(Thing *thing, int button, float x, float y); + void (*ondraw)(Thing *thing, SDL_Renderer *renderer); + void (*onmousewheel)(Thing *thing, float y); + + Thing *prev; + Thing *next; +}; + + +static Uint64 app_ready_ticks = 0; +static SDLTest_CommonState *state = NULL; + +static Thing *things = NULL; + +static Thing *mouseover_thing = NULL; +static Thing *droppable_highlighted_thing = NULL; +static Thing *dragging_thing = NULL; +static int dragging_button = -1; +static int dragging_button_real = -1; +static bool ctrl_held = false; +static bool alt_held = false; + +static Texture *physdev_texture = NULL; +static Texture *logdev_texture = NULL; +static Texture *audio_texture = NULL; +static Texture *trashcan_texture = NULL; +static Texture *soundboard_texture = NULL; +static Texture *soundboard_levels_texture = NULL; + + +static void SetTitleBar(const char *fmt, ...) +{ + char *title = NULL; + va_list ap; + va_start(ap, fmt); + SDL_vasprintf(&title, fmt, ap); + va_end(ap); + + SDL_SetWindowTitle(state->windows[0], title); + SDL_free(title); +} + +static void SetDefaultTitleBar(void) +{ + SetTitleBar("testaudio: %s", SDL_GetCurrentAudioDriver()); +} + +static Thing *FindThingAtPoint(const float x, const float y) +{ + const SDL_FPoint pt = { x, y }; + Thing *result = NULL; + Thing *i; + for (i = things; i; i = i->next) { + if ((i != dragging_thing) && SDL_PointInRectFloat(&pt, &i->rect)) { + result = i; /* keep going, though, because things drawn on top are later in the list. */ + } + } + return result; +} + +static Thing *UpdateMouseOver(const float x, const float y) +{ + Thing *thing; + + if (dragging_thing) { + thing = dragging_thing; + } else { + thing = FindThingAtPoint(x, y); + } + + mouseover_thing = thing; + + if (!thing) { + SetDefaultTitleBar(); + } else if (thing->titlebar) { + SetTitleBar("%s", thing->titlebar); + } + + return thing; +} + +static Thing *CreateThing(ThingType what, float x, float y, float z, float w, float h, Texture *texture, const char *titlebar) +{ + Thing *last = NULL; + Thing *i; + Thing *thing; + + thing = (Thing *) SDL_calloc(1, sizeof (Thing)); + if (!thing) { + SDL_Log("Out of memory!"); + return NULL; + } + + if ((w < 0) || (h < 0)) { + SDL_assert(texture != NULL); + if (w < 0) { + w = texture->w; + } + if (h < 0) { + h = texture->h; + } + } + + thing->what = what; + thing->rect.x = x; + thing->rect.y = y; + thing->rect.w = w; + thing->rect.h = h; + thing->z = z; + thing->r = 255; + thing->g = 255; + thing->b = 255; + thing->a = 255; + thing->scale = 1.0f; + thing->createticks = SDL_GetTicks(); + thing->texture = texture; + thing->titlebar = titlebar ? SDL_strdup(titlebar) : NULL; /* if allocation fails, oh well. */ + + /* insert in list by Z order (furthest from the "camera" first, so they get drawn over; negative Z is not drawn at all). */ + if (!things) { + things = thing; + return thing; + } + + for (i = things; i; i = i->next) { + if (z > i->z) { /* insert here. */ + thing->next = i; + thing->prev = i->prev; + + SDL_assert(i->prev == last); + + if (i->prev) { + i->prev->next = thing; + } else { + SDL_assert(i == things); + things = thing; + } + i->prev = thing; + return thing; + } + last = i; + } + + if (last) { + last->next = thing; + thing->prev = last; + } + return thing; +} + +static void DestroyThing(Thing *thing) +{ + if (!thing) { + return; + } + + if (mouseover_thing == thing) { + mouseover_thing = NULL; + } + + if (droppable_highlighted_thing == thing) { + droppable_highlighted_thing = NULL; + } + + if (dragging_thing == thing) { + dragging_thing = NULL; + } + + switch (thing->what) { + case THING_POOF: break; + case THING_NULL: break; + case THING_TRASHCAN: break; + + case THING_LOGDEV: + case THING_LOGDEV_RECORDING: + SDL_CloseAudioDevice(thing->data.logdev.devid); + if (state->renderers[0] != NULL) { + SDL_DestroyTexture(thing->data.logdev.visualizer); + } + SDL_DestroyMutex(thing->data.logdev.postmix_lock); + SDL_free(thing->data.logdev.postmix_buffer); + break; + + case THING_PHYSDEV: + case THING_PHYSDEV_RECORDING: + SDL_free(thing->data.physdev.name); + break; + + case THING_WAV: + SDL_free(thing->data.wav.buf); + break; + + case THING_STREAM: + SDL_DestroyAudioStream(thing->data.stream.stream); + break; + } + + if (thing->prev) { + SDL_assert(thing != things); + thing->prev->next = thing->next; + } else { + SDL_assert(thing == things); + things = thing->next; + } + + if (thing->next) { + thing->next->prev = thing->prev; + } + + SDL_free(thing->titlebar); + SDL_free(thing); +} + +static void DrawOneThing(SDL_Renderer *renderer, Thing *thing) +{ + SDL_FRect dst; + SDL_memcpy(&dst, &thing->rect, sizeof (SDL_FRect)); + if (thing->scale != 1.0f) { + const float centerx = thing->rect.x + (thing->rect.w / 2); + const float centery = thing->rect.y + (thing->rect.h / 2); + const int w = thing->texture ? (int) thing->texture->w : 128; + const int h = thing->texture ? (int) thing->texture->h : 128; + dst.w = w * thing->scale; + dst.h = h * thing->scale; + dst.x = centerx - (dst.w / 2); + dst.y = centery - (dst.h / 2); + } + + if (thing->texture) { + if (droppable_highlighted_thing == thing) { + SDL_SetRenderDrawColor(renderer, 255, 0, 255, 100); + SDL_RenderFillRect(renderer, &dst); + } + SDL_SetRenderDrawColor(renderer, thing->r, thing->g, thing->b, thing->a); + SDL_RenderTexture(renderer, thing->texture->texture, NULL, &dst); + } else { + SDL_SetRenderDrawColor(renderer, thing->r, thing->g, thing->b, thing->a); + SDL_RenderFillRect(renderer, &dst); + } + + if (thing->ondraw) { + thing->ondraw(thing, renderer); + } + + if (thing->progress > 0.0f) { + SDL_FRect r = { thing->rect.x, thing->rect.y + (thing->rect.h + 2.0f), 0.0f, 10.0f }; + r.w = thing->rect.w * ((thing->progress > 1.0f) ? 1.0f : thing->progress); + SDL_SetRenderDrawColor(renderer, 255, 255, 255, 128); + SDL_RenderFillRect(renderer, &r); + } + + if (thing->meter > 0.0f) { + SDL_FRect r; + r.w = 10.0f; + r.h = thing->rect.h * ((thing->meter > 1.0f) ? 1.0f : thing->meter); + r.x = thing->rect.x + thing->rect.w + 2.0f; + r.y = (thing->rect.y + thing->rect.h) - r.h; + SDL_SetRenderDrawColor(renderer, 255, 255, 255, 128); + SDL_RenderFillRect(renderer, &r); + } +} + +static void DrawThings(SDL_Renderer *renderer) +{ + Thing *i; + + /* draw connecting lines first, so they're behind everything else. */ + for (i = things; i && (i->z >= 0.0f); i = i->next) { + Thing *dst = i->line_connected_to; + if (dst) { + SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255); + SDL_RenderLine(renderer, i->rect.x + (i->rect.w / 2), i->rect.y + (i->rect.h / 2), dst->rect.x + (dst->rect.w / 2), dst->rect.y + (dst->rect.h / 2)); + } + } + + /* Draw the actual things. */ + for (i = things; i && (i->z >= 0.0f); i = i->next) { + if (i != dragging_thing) { + DrawOneThing(renderer, i); + } + } + + if (dragging_thing) { + DrawOneThing(renderer, dragging_thing); /* draw last so it's always on top. */ + } +} + +static void Draw(void) +{ + SDL_Renderer *renderer = state->renderers[0]; + if (renderer) { /* might be NULL if we're shutting down. */ + SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND); + SDL_SetRenderDrawColor(renderer, 64, 0, 64, 255); + SDL_RenderClear(renderer); + DrawThings(renderer); + SDL_RenderPresent(renderer); + } +} + +static void RepositionRowOfThings(const ThingType what, const float y) +{ + int total_things = 0; + float texw = 0.0f; + float texh = 0.0f; + Thing *i; + + for (i = things; i; i = i->next) { + if (i->what == what) { + texw = i->rect.w; + texh = i->rect.h; + total_things++; + } + } + + if (total_things > 0) { + int w, h; + SDL_GetWindowSize(state->windows[0], &w, &h); + const float spacing = w / ((float) total_things); + float x = (spacing - texw) / 2.0f; + for (i = things; i; i = i->next) { + if (i->what == what) { + i->rect.x = x; + i->rect.y = (y >= 0.0f) ? y : ((h + y) - texh); + x += spacing; + } + } + } +} + +static const char *AudioChansToStr(const int channels) +{ + switch (channels) { + case 1: return "mono"; + case 2: return "stereo"; + case 3: return "2.1"; + case 4: return "quad"; + case 5: return "4.1"; + case 6: return "5.1"; + case 7: return "6.1"; + case 8: return "7.1"; + default: break; + } + return "?"; +} + +static void PoofThing_ondrag(Thing *thing, int button, float x, float y) +{ + dragging_thing = NULL; /* refuse to be dragged. */ +} + +static void PoofThing_ontick(Thing *thing, Uint64 now) +{ + const int lifetime = POOF_LIFETIME; + const int elapsed = (int) (now - thing->createticks); + if (elapsed > lifetime) { + DestroyThing(thing); + } else { + const float pct = ((float) elapsed) / ((float) lifetime); + thing->a = (Uint8) (int) (255.0f - (pct * 255.0f)); + thing->scale = 1.0f - pct; /* shrink to nothing! */ + } +} + +static Thing *CreatePoofThing(Thing *poofing_thing) +{ + const float centerx = poofing_thing->rect.x + (poofing_thing->rect.w / 2); + const float centery = poofing_thing->rect.y + (poofing_thing->rect.h / 2); + const float z = poofing_thing->z; + Thing *thing = CreateThing(THING_POOF, poofing_thing->rect.x, poofing_thing->rect.y, z, poofing_thing->rect.w, poofing_thing->rect.h, poofing_thing->texture, NULL); + if (thing) { + thing->data.poof.startw = poofing_thing->rect.w; + thing->data.poof.starth = poofing_thing->rect.h; + thing->data.poof.centerx = centerx; + thing->data.poof.centery = centery; + thing->ontick = PoofThing_ontick; + thing->ondrag = PoofThing_ondrag; + } + return thing; +} + +static void DestroyThingInPoof(Thing *thing) +{ + if (thing) { + if (thing->what != THING_POOF) { + CreatePoofThing(thing); + } + DestroyThing(thing); + } +} + +/* this poofs a thing and additionally poofs all things connected to the thing. */ +static void TrashThing(Thing *thing) +{ + Thing *i, *next; + for (i = things; i; i = next) { + next = i->next; + if (i->line_connected_to == thing) { + TrashThing(i); + next = things; /* start over in case this blew up the list. */ + } + } + DestroyThingInPoof(thing); +} + +static void StreamThing_ontick(Thing *thing, Uint64 now) +{ + if (!thing->line_connected_to) { + return; + } + + /* are we playing? See if we're done, or update state. */ + if (thing->line_connected_to->what == THING_LOGDEV) { + const int available = SDL_GetAudioStreamAvailable(thing->data.stream.stream); + if (!available) { + DestroyThingInPoof(thing); + return; + } else { + thing->progress = 1.0f - (thing->data.stream.total_bytes ? (((float) (available)) / ((float) thing->data.stream.total_bytes)) : 0.0f); + } + } + + if (thing->data.stream.next_level_update <= now) { + Uint64 perf = SDL_GetPerformanceCounter(); + int i; + for (i = 0; i < SDL_arraysize(thing->data.stream.levels); i++) { + thing->data.stream.levels[i] = (Uint8) (perf % 6); + perf >>= 3; + } + thing->data.stream.next_level_update += 150; + } +} + +static void StreamThing_ondrag(Thing *thing, int button, float x, float y) +{ + if (button == SDL_BUTTON_RIGHT) { /* this is kinda hacky, but use this to disconnect from a playing source. */ + if (thing->line_connected_to) { + SDL_UnbindAudioStream(thing->data.stream.stream); /* unbind from current device */ + if (thing->line_connected_to->what == THING_LOGDEV_RECORDING) { + SDL_FlushAudioStream(thing->data.stream.stream); + } + thing->line_connected_to = NULL; + } + } +} + +static void StreamThing_ondrop(Thing *thing, int button, float x, float y) +{ + if (droppable_highlighted_thing) { + if (droppable_highlighted_thing->what == THING_TRASHCAN) { + TrashThing(thing); + } else if (((droppable_highlighted_thing->what == THING_LOGDEV) || (droppable_highlighted_thing->what == THING_LOGDEV_RECORDING)) && (droppable_highlighted_thing != thing->line_connected_to)) { + /* connect to a logical device! */ + SDL_Log("Binding audio stream ('%s') to logical device %u", thing->titlebar, (unsigned int) droppable_highlighted_thing->data.logdev.devid); + if (thing->line_connected_to) { + SDL_UnbindAudioStream(thing->data.stream.stream); /* unbind from current device */ + if (thing->line_connected_to->what == THING_LOGDEV_RECORDING) { + SDL_FlushAudioStream(thing->data.stream.stream); + } + } + + SDL_BindAudioStream(droppable_highlighted_thing->data.logdev.devid, thing->data.stream.stream); /* bind to new device! */ + thing->data.stream.total_bytes = SDL_GetAudioStreamAvailable(thing->data.stream.stream); + thing->progress = 0.0f; /* ontick will adjust this if we're on a playback device.*/ + thing->data.stream.next_level_update = SDL_GetTicks() + 100; + thing->line_connected_to = droppable_highlighted_thing; + } + } +} + +static void StreamThing_onmousewheel(Thing *thing, float y) +{ + thing->meter += y * 0.01f; + thing->meter = SDL_clamp(thing->meter, 0.0f, 1.0f); + SDL_SetAudioStreamGain(thing->data.stream.stream, thing->meter); +} + +static void StreamThing_ondraw(Thing *thing, SDL_Renderer *renderer) +{ + if (thing->line_connected_to) { /* are we playing? Update progress bar, and bounce the levels a little. */ + static const float xlocs[5] = { 18, 39, 59, 79, 99 }; + static const float ylocs[5] = { 49, 39, 29, 19, 10 }; + const float blockw = soundboard_levels_texture->w; + const float blockh = soundboard_levels_texture->h / 5.0f; + int i, j; + SDL_SetRenderDrawColor(renderer, thing->r, thing->g, thing->b, thing->a); + for (i = 0; i < SDL_arraysize(thing->data.stream.levels); i++) { + const int level = (int) thing->data.stream.levels[i]; + const float x = xlocs[i]; + for (j = 0; j < level; j++) { + const SDL_FRect src = { 0, soundboard_levels_texture->h - ((j+1) * blockh), blockw, blockh }; + const SDL_FRect dst = { thing->rect.x + x, thing->rect.y + ylocs[j], blockw, blockh }; + SDL_RenderTexture(renderer, soundboard_levels_texture->texture, &src, &dst); + } + } + } +} + +static Thing *CreateStreamThing(const SDL_AudioSpec *spec, const Uint8 *buf, const Uint32 buflen, const char *fname, const float x, const float y) +{ + static const ThingType can_be_dropped_onto[] = { THING_TRASHCAN, THING_LOGDEV, THING_LOGDEV_RECORDING, THING_NULL }; + Thing *thing = CreateThing(THING_STREAM, x, y, 0, -1, -1, soundboard_texture, fname); + if (thing) { + SDL_Log("Adding audio stream for %s", fname ? fname : "(null)"); + thing->data.stream.stream = SDL_CreateAudioStream(spec, spec); + if (buf && buflen) { + SDL_PutAudioStreamData(thing->data.stream.stream, buf, (int) buflen); + SDL_FlushAudioStream(thing->data.stream.stream); + thing->data.stream.total_bytes = SDL_GetAudioStreamAvailable(thing->data.stream.stream); + } + thing->ontick = StreamThing_ontick; + thing->ondrag = StreamThing_ondrag; + thing->ondrop = StreamThing_ondrop; + thing->ondraw = StreamThing_ondraw; + thing->onmousewheel = StreamThing_onmousewheel; + thing->can_be_dropped_onto = can_be_dropped_onto; + thing->meter = 1.0f; /* gain. */ + } + return thing; +} + +static void WavThing_ondrag(Thing *thing, int button, float x, float y) +{ + if (button == SDL_BUTTON_RIGHT) { /* drag out a new audio stream. */ + dragging_thing = CreateStreamThing(&thing->data.wav.spec, thing->data.wav.buf, thing->data.wav.buflen, thing->titlebar, x - (thing->rect.w / 2), y - (thing->rect.h / 2)); + } +} + +static void WavThing_ondrop(Thing *thing, int button, float x, float y) +{ + if (droppable_highlighted_thing) { + if (droppable_highlighted_thing->what == THING_TRASHCAN) { + TrashThing(thing); + } + } +} + +static Thing *LoadWavThing(const char *fname, float x, float y) +{ + Thing *thing = NULL; + char *path; + SDL_AudioSpec spec; + Uint8 *buf = NULL; + Uint32 buflen = 0; + + path = GetNearbyFilename(fname); + if (path) { + fname = path; + } + + if (SDL_LoadWAV(fname, &spec, &buf, &buflen)) { + static const ThingType can_be_dropped_onto[] = { THING_TRASHCAN, THING_NULL }; + char *titlebar = NULL; + const char *nodirs = SDL_strrchr(fname, '/'); + #ifdef SDL_PLATFORM_WINDOWS + const char *nodirs2 = SDL_strrchr(nodirs ? nodirs : fname, '\\'); + if (nodirs2) { + nodirs = nodirs2; + } + #endif + + SDL_Log("Adding WAV file '%s'", fname); + + if (nodirs) { + nodirs++; + } else { + nodirs = fname; + } + + SDL_asprintf(&titlebar, "WAV file (\"%s\", %s, %s, %uHz)", nodirs, SDL_GetAudioFormatName(spec.format), AudioChansToStr(spec.channels), (unsigned int) spec.freq); + thing = CreateThing(THING_WAV, x - (audio_texture->w / 2), y - (audio_texture->h / 2), 5, -1, -1, audio_texture, titlebar); + if (thing) { + SDL_free(titlebar); + SDL_memcpy(&thing->data.wav.spec, &spec, sizeof (SDL_AudioSpec)); + thing->data.wav.buf = buf; + thing->data.wav.buflen = buflen; + thing->can_be_dropped_onto = can_be_dropped_onto; + thing->ondrag = WavThing_ondrag; + thing->ondrop = WavThing_ondrop; + } + } + + SDL_free(path); + + return thing; +} + +static Thing *LoadStockWavThing(const char *fname) +{ + char *path = GetNearbyFilename(fname); + Thing *thing = LoadWavThing(path ? path : fname, 0.0f, 0.0f); /* will reposition in a moment. */ + SDL_free(path); + return thing; +} + +static void LoadStockWavThings(void) +{ + LoadStockWavThing("sample.wav"); + RepositionRowOfThings(THING_WAV, -10.0f); +} + +static void DestroyTexture(Texture *tex) +{ + if (tex) { + if (state->renderers[0] != NULL) { /* if the renderer went away, this pointer is already bogus. */ + SDL_DestroyTexture(tex->texture); + } + SDL_free(tex); + } +} + +static Texture *CreateTexture(const char *fname) +{ + Texture *tex = (Texture *) SDL_calloc(1, sizeof (Texture)); + if (!tex) { + SDL_Log("Out of memory!"); + } else { + int texw, texh; + tex->texture = LoadTexture(state->renderers[0], fname, true, &texw, &texh); + if (!tex->texture) { + SDL_Log("Failed to load '%s': %s", fname, SDL_GetError()); + SDL_free(tex); + return NULL; + } + SDL_SetTextureBlendMode(tex->texture, SDL_BLENDMODE_BLEND); + tex->w = (float) texw; + tex->h = (float) texh; + } + return tex; +} + +static Thing *CreateLogicalDeviceThing(Thing *parent, SDL_AudioDeviceID which, float x, float y); + +static void DeviceThing_ondrag(Thing *thing, int button, float x, float y) +{ + if ((button == SDL_BUTTON_MIDDLE) && (thing->what == THING_LOGDEV_RECORDING)) { /* drag out a new stream. This is a UX mess. :/ */ + dragging_thing = CreateStreamThing(&thing->data.logdev.spec, NULL, 0, NULL, x, y); + if (dragging_thing) { + dragging_thing->data.stream.next_level_update = SDL_GetTicks() + 100; + SDL_BindAudioStream(thing->data.logdev.devid, dragging_thing->data.stream.stream); /* bind to new device! */ + dragging_thing->line_connected_to = thing; + } + } else if (button == SDL_BUTTON_RIGHT) { /* drag out a new logical device. */ + const SDL_AudioDeviceID which = ((thing->what == THING_LOGDEV) || (thing->what == THING_LOGDEV_RECORDING)) ? thing->data.logdev.devid : thing->data.physdev.devid; + const SDL_AudioDeviceID devid = SDL_OpenAudioDevice(which, NULL); + dragging_thing = devid ? CreateLogicalDeviceThing(thing, devid, x - (thing->rect.w / 2), y - (thing->rect.h / 2)) : NULL; + } +} + +static void SetLogicalDeviceTitlebar(Thing *thing) +{ + SDL_AudioSpec *spec = &thing->data.logdev.spec; + int frames = 0; + SDL_GetAudioDeviceFormat(thing->data.logdev.devid, spec, &frames); + SDL_free(thing->titlebar); + SDL_asprintf(&thing->titlebar, "Logical device #%u (%s, %s, %s, %uHz, %d frames)", (unsigned int) thing->data.logdev.devid, thing->data.logdev.recording ? "RECORDING" : "PLAYBACK", SDL_GetAudioFormatName(spec->format), AudioChansToStr(spec->channels), (unsigned int) spec->freq, frames); +} + +static void LogicalDeviceThing_ondrop(Thing *thing, int button, float x, float y) +{ + if (droppable_highlighted_thing) { + if (droppable_highlighted_thing->what == THING_TRASHCAN) { + TrashThing(thing); + } + } +} + +static void SDLCALL PostmixCallback(void *userdata, const SDL_AudioSpec *spec, float *buffer, int buflen) +{ + Thing *thing = (Thing *) userdata; + + SDL_LockMutex(thing->data.logdev.postmix_lock); + + if (thing->data.logdev.postmix_allocated < buflen) { + void *ptr = SDL_realloc(thing->data.logdev.postmix_buffer, buflen); + if (!ptr) { + SDL_UnlockMutex(thing->data.logdev.postmix_lock); + return; /* oh well. */ + } + thing->data.logdev.postmix_buffer = (float *) ptr; + thing->data.logdev.postmix_allocated = buflen; + } + + SDL_copyp(&thing->data.logdev.postmix_spec, spec); + SDL_memcpy(thing->data.logdev.postmix_buffer, buffer, buflen); + thing->data.logdev.postmix_buflen = buflen; + SDL_SetAtomicInt(&thing->data.logdev.postmix_updated, 1); + + SDL_UnlockMutex(thing->data.logdev.postmix_lock); +} + +static void UpdateVisualizer(SDL_Renderer *renderer, SDL_Texture *visualizer, const int channels, const float *buffer, const int buflen) +{ + static const SDL_Color channel_colors[8] = { + { 255, 255, 255, 255 }, + { 255, 0, 0, 255 }, + { 0, 255, 0, 255 }, + { 0, 0, 255, 255 }, + { 255, 255, 0, 255 }, + { 0, 255, 255, 255 }, + { 255, 0, 255, 255 }, + { 127, 127, 127, 255 } + }; + + SDL_SetRenderTarget(renderer, visualizer); + SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0); + SDL_RenderClear(renderer); + + if (buffer && buflen) { + const int frames = (buflen / sizeof (float)) / channels; + const int skip = frames / (VISUALIZER_WIDTH * 2); + int i, j; + + for (i = channels - 1; i >= 0; i--) { + const SDL_Color *color = &channel_colors[i % SDL_arraysize(channel_colors)]; + SDL_FPoint points[VISUALIZER_WIDTH + 2]; + float prevx = 0.0f; + int pointidx = 1; + + points[0].x = 0.0f; + points[0].y = VISUALIZER_HEIGHT * 0.5f; + + for (j = 0; j < (SDL_arraysize(points)-1); j++) { + const float val = buffer[((j * skip) * channels) + i]; + const float x = prevx + 2; + const float y = (VISUALIZER_HEIGHT * 0.5f) - (VISUALIZER_HEIGHT * (val * 0.5f)); + SDL_assert(pointidx < SDL_arraysize(points)); + points[pointidx].x = x; + points[pointidx].y = y; + pointidx++; + prevx = x; + } + + SDL_SetRenderDrawColor(renderer, color->r, color->g, color->b, 255); + SDL_RenderLines(renderer, points, pointidx); + } + } + + SDL_SetRenderTarget(renderer, NULL); +} + +static void LogicalDeviceThing_ontick(Thing *thing, Uint64 now) +{ + const bool ismousedover = (thing == mouseover_thing); + + if (!thing->data.logdev.visualizer || !thing->data.logdev.postmix_lock) { /* need these to work, skip if they failed. */ + return; + } + + if (thing->data.logdev.visualizer_enabled != ismousedover) { + thing->data.logdev.visualizer_enabled = ismousedover; + if (!ismousedover) { + SDL_SetAudioPostmixCallback(thing->data.logdev.devid, NULL, NULL); + } else { + if (thing->data.logdev.postmix_buffer) { + SDL_memset(thing->data.logdev.postmix_buffer, '\0', thing->data.logdev.postmix_buflen); + } + SDL_SetAtomicInt(&thing->data.logdev.postmix_updated, 1); /* so this will at least clear the texture later. */ + SDL_SetAudioPostmixCallback(thing->data.logdev.devid, PostmixCallback, thing); + } + } +} + +static void LogicalDeviceThing_ondraw(Thing *thing, SDL_Renderer *renderer) +{ + if (thing->data.logdev.visualizer_enabled) { + SDL_FRect dst; + dst.w = thing->rect.w; + dst.h = thing->rect.h; + dst.x = thing->rect.x + ((thing->rect.w - dst.w) / 2); + dst.y = thing->rect.y + ((thing->rect.h - dst.h) / 2); + + if (SDL_GetAtomicInt(&thing->data.logdev.postmix_updated)) { + float *buffer; + int channels; + int buflen; + + SDL_LockMutex(thing->data.logdev.postmix_lock); + channels = thing->data.logdev.postmix_spec.channels; + buflen = thing->data.logdev.postmix_buflen; + buffer = (float *) SDL_malloc(thing->data.logdev.postmix_buflen); + if (buffer) { + SDL_memcpy(buffer, thing->data.logdev.postmix_buffer, thing->data.logdev.postmix_buflen); + SDL_SetAtomicInt(&thing->data.logdev.postmix_updated, 0); + } + SDL_UnlockMutex(thing->data.logdev.postmix_lock); + + UpdateVisualizer(renderer, thing->data.logdev.visualizer, channels, buffer, buflen); + SDL_free(buffer); + } + + SDL_SetRenderDrawColor(renderer, 255, 255, 255, 30); + SDL_RenderTexture(renderer, thing->data.logdev.visualizer, NULL, &dst); + } +} + +static void LogicalDeviceThing_onmousewheel(Thing *thing, float y) +{ + thing->meter += y * 0.01f; + thing->meter = SDL_clamp(thing->meter, 0.0f, 1.0f); + SDL_SetAudioDeviceGain(thing->data.logdev.devid, thing->meter); +} + +static Thing *CreateLogicalDeviceThing(Thing *parent, SDL_AudioDeviceID which, float x, float y) +{ + static const ThingType can_be_dropped_onto[] = { THING_TRASHCAN, THING_NULL }; + Thing *physthing = ((parent->what == THING_LOGDEV) || (parent->what == THING_LOGDEV_RECORDING)) ? parent->data.logdev.physdev : parent; + const bool recording = physthing->data.physdev.recording; + Thing *thing; + + SDL_Log("Adding logical audio device %u", (unsigned int) which); + thing = CreateThing(recording ? THING_LOGDEV_RECORDING : THING_LOGDEV, x, y, 5, -1, -1, logdev_texture, NULL); + if (thing) { + thing->data.logdev.devid = which; + thing->data.logdev.recording = recording; + thing->data.logdev.physdev = physthing; + thing->data.logdev.visualizer = SDL_CreateTexture(state->renderers[0], SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, VISUALIZER_WIDTH, VISUALIZER_HEIGHT); + thing->data.logdev.postmix_lock = SDL_CreateMutex(); + if (thing->data.logdev.visualizer) { + SDL_SetTextureBlendMode(thing->data.logdev.visualizer, SDL_BLENDMODE_BLEND); + } + thing->line_connected_to = physthing; + thing->meter = 1.0f; + thing->ontick = LogicalDeviceThing_ontick; + thing->ondrag = DeviceThing_ondrag; + thing->ondrop = LogicalDeviceThing_ondrop; + thing->ondraw = LogicalDeviceThing_ondraw; + thing->onmousewheel = LogicalDeviceThing_onmousewheel; + thing->can_be_dropped_onto = can_be_dropped_onto; + + SetLogicalDeviceTitlebar(thing); + } + return thing; +} + +static void SetPhysicalDeviceTitlebar(Thing *thing) +{ + int frames = 0; + SDL_AudioSpec *spec = &thing->data.physdev.spec; + SDL_GetAudioDeviceFormat(thing->data.physdev.devid, spec, &frames); + SDL_free(thing->titlebar); + if (thing->data.physdev.devid == SDL_AUDIO_DEVICE_DEFAULT_RECORDING) { + SDL_asprintf(&thing->titlebar, "Default system device (RECORDING, %s, %s, %uHz, %d frames)", SDL_GetAudioFormatName(spec->format), AudioChansToStr(spec->channels), (unsigned int) spec->freq, frames); + } else if (thing->data.physdev.devid == SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK) { + SDL_asprintf(&thing->titlebar, "Default system device (PLAYBACK, %s, %s, %uHz, %d frames)", SDL_GetAudioFormatName(spec->format), AudioChansToStr(spec->channels), (unsigned int) spec->freq, frames); + } else { + SDL_asprintf(&thing->titlebar, "Physical device #%u (%s, \"%s\", %s, %s, %uHz, %d frames)", (unsigned int) thing->data.physdev.devid, thing->data.physdev.recording ? "RECORDING" : "PLAYBACK", thing->data.physdev.name, SDL_GetAudioFormatName(spec->format), AudioChansToStr(spec->channels), (unsigned int) spec->freq, frames); + } +} + +static void PhysicalDeviceThing_ondrop(Thing *thing, int button, float x, float y) +{ + if (droppable_highlighted_thing) { + if (droppable_highlighted_thing->what == THING_TRASHCAN) { + TrashThing(thing); + } + } +} + +static void PhysicalDeviceThing_ontick(Thing *thing, Uint64 now) +{ + const int lifetime = POOF_LIFETIME; + const int elapsed = (int) (now - thing->createticks); + if (elapsed > lifetime) { + thing->scale = 1.0f; + thing->a = 255; + thing->ontick = NULL; /* no more ticking. */ + } else { + const float pct = ((float) elapsed) / ((float) lifetime); + thing->a = (Uint8) (int) (pct * 255.0f); + thing->scale = pct; /* grow to normal size */ + } +} + + +static Thing *CreatePhysicalDeviceThing(const SDL_AudioDeviceID which, const bool recording) +{ + static const ThingType can_be_dropped_onto[] = { THING_TRASHCAN, THING_NULL }; + static float next_physdev_x = 0; + Thing *thing; + int winw, winh; + + SDL_GetWindowSize(state->windows[0], &winw, &winh); + if (next_physdev_x > (winw-physdev_texture->w)) { + next_physdev_x = 0; + } + + SDL_Log("Adding physical audio device %u", (unsigned int) which); + thing = CreateThing(recording ? THING_PHYSDEV_RECORDING : THING_PHYSDEV, next_physdev_x, 170, 5, -1, -1, physdev_texture, NULL); + if (thing) { + const char *name = SDL_GetAudioDeviceName(which); + thing->data.physdev.devid = which; + thing->data.physdev.recording = recording; + thing->data.physdev.name = name ? SDL_strdup(name) : NULL; + thing->ondrag = DeviceThing_ondrag; + thing->ondrop = PhysicalDeviceThing_ondrop; + thing->ontick = PhysicalDeviceThing_ontick; + thing->can_be_dropped_onto = can_be_dropped_onto; + + SetPhysicalDeviceTitlebar(thing); + if (SDL_GetTicks() <= (app_ready_ticks + 2000)) { /* assume this is the initial batch if it happens in the first two seconds. */ + RepositionRowOfThings(THING_PHYSDEV, 10.0f); /* don't rearrange them after the initial add. */ + RepositionRowOfThings(THING_PHYSDEV_RECORDING, 170.0f); /* don't rearrange them after the initial add. */ + next_physdev_x = 0.0f; + } else { + next_physdev_x += physdev_texture->w * 1.5f; + } + } + + return thing; +} + +static Thing *CreateTrashcanThing(void) +{ + int winw, winh; + SDL_GetWindowSize(state->windows[0], &winw, &winh); + return CreateThing(THING_TRASHCAN, winw - trashcan_texture->w, winh - trashcan_texture->h, 10, -1, -1, trashcan_texture, "Drag things here to remove them."); +} + +static Thing *CreateDefaultPhysicalDevice(const bool recording) +{ + return CreatePhysicalDeviceThing(recording ? SDL_AUDIO_DEVICE_DEFAULT_RECORDING : SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, recording); +} + +static void TickThings(void) +{ + Thing *i; + Thing *next; + const Uint64 now = SDL_GetTicks(); + for (i = things; i; i = next) { + next = i->next; /* in case this deletes itself. */ + if (i->ontick) { + i->ontick(i, now); + } + } +} + +static void WindowResized(const int newwinw, const int newwinh) +{ + Thing *i; + const float neww = (float) newwinw; + const float newh = (float) newwinh; + const float oldw = (float) state->window_w; + const float oldh = (float) state->window_h; + for (i = things; i; i = i->next) { + const float halfw = i->rect.w / 2.0f; + const float halfh = i->rect.h / 2.0f; + const float x = (i->rect.x + halfw) / oldw; + const float y = (i->rect.y + halfh) / oldh; + i->rect.x = (x * neww) - halfw; + i->rect.y = (y * newh) - halfh; + } + state->window_w = newwinw; + state->window_h = newwinh; +} + +SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[]) +{ + int i; + + state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO | SDL_INIT_AUDIO); + if (!state) { + return SDL_APP_FAILURE; + } + + state->window_flags |= SDL_WINDOW_RESIZABLE; + + for (i = 1; i < argc;) { + int consumed = SDLTest_CommonArg(state, i); + if (consumed == 0) { + consumed = -1; + /* add our own command lines here. */ + } + if (consumed < 0) { + static const char *options[] = { + /* add our own command lines here. */ + /*"[--blend none|blend|add|mod|mul|sub]",*/ + NULL + }; + SDLTest_CommonLogUsage(state, argv[0], options); + return SDL_APP_FAILURE; + } + i += consumed; + } + + if (!SDLTest_CommonInit(state)) { + return SDL_APP_FAILURE; + } + + if (state->audio_id) { + SDL_CloseAudioDevice(state->audio_id); + state->audio_id = 0; + } + + SetDefaultTitleBar(); + + if ((physdev_texture = CreateTexture("physaudiodev.bmp")) == NULL) { return SDL_APP_FAILURE; } + if ((logdev_texture = CreateTexture("logaudiodev.bmp")) == NULL) { return SDL_APP_FAILURE; } + if ((audio_texture = CreateTexture("audiofile.bmp")) == NULL) { return SDL_APP_FAILURE; } + if ((trashcan_texture = CreateTexture("trashcan.bmp")) == NULL) { return SDL_APP_FAILURE; } + if ((soundboard_texture = CreateTexture("soundboard.bmp")) == NULL) { return SDL_APP_FAILURE; } + if ((soundboard_levels_texture = CreateTexture("soundboard_levels.bmp")) == NULL) { return SDL_APP_FAILURE; } + + LoadStockWavThings(); + CreateTrashcanThing(); + CreateDefaultPhysicalDevice(false); + CreateDefaultPhysicalDevice(true); + + return SDL_APP_CONTINUE; +} + + +static bool saw_event = false; + +SDL_AppResult SDL_AppEvent(void *appstate, SDL_Event *event) +{ + Thing *thing = NULL; + + saw_event = true; + SDL_ConvertEventToRenderCoordinates(SDL_GetRenderer(SDL_GetWindowFromEvent(event)), event); + + switch (event->type) { + case SDL_EVENT_MOUSE_MOTION: + thing = UpdateMouseOver(event->motion.x, event->motion.y); + if ((dragging_button == -1) && event->motion.state) { + if (event->motion.state & SDL_BUTTON_LMASK) { + /* for people that don't have all three buttons... */ + if (ctrl_held) { + dragging_button = SDL_BUTTON_RIGHT; + } else if (alt_held) { + dragging_button = SDL_BUTTON_MIDDLE; + } else { + dragging_button = SDL_BUTTON_LEFT; + } + dragging_button_real = SDL_BUTTON_LEFT; + } else if (event->motion.state & SDL_BUTTON_RMASK) { + dragging_button = SDL_BUTTON_RIGHT; + dragging_button_real = SDL_BUTTON_RIGHT; + } else if (event->motion.state & SDL_BUTTON_MMASK) { + dragging_button = SDL_BUTTON_MIDDLE; + dragging_button_real = SDL_BUTTON_MIDDLE; + } + + if (dragging_button != -1) { + dragging_thing = thing; + if (thing && thing->ondrag) { + thing->ondrag(thing, dragging_button, event->motion.x, event->motion.y); + } + } + } + + droppable_highlighted_thing = NULL; + if (dragging_thing) { + dragging_thing->rect.x = event->motion.x - (dragging_thing->rect.w / 2); + dragging_thing->rect.y = event->motion.y - (dragging_thing->rect.h / 2); + if (dragging_thing->can_be_dropped_onto) { + thing = FindThingAtPoint(event->motion.x, event->motion.y); + if (thing) { + int i; + for (i = 0; dragging_thing->can_be_dropped_onto[i]; i++) { + if (dragging_thing->can_be_dropped_onto[i] == thing->what) { + droppable_highlighted_thing = thing; + break; + } + } + } + } + } + break; + + case SDL_EVENT_MOUSE_BUTTON_DOWN: + thing = UpdateMouseOver(event->button.x, event->button.y); + break; + + case SDL_EVENT_MOUSE_BUTTON_UP: + if (dragging_button_real == event->button.button) { + Thing *dropped_thing = dragging_thing; + dragging_thing = NULL; + dragging_button = -1; + dragging_button_real = -1; + if (dropped_thing && dropped_thing->ondrop) { + dropped_thing->ondrop(dropped_thing, event->button.button, event->button.x, event->button.y); + } + droppable_highlighted_thing = NULL; + } + thing = UpdateMouseOver(event->button.x, event->button.y); + break; + + case SDL_EVENT_MOUSE_WHEEL: + thing = UpdateMouseOver(event->wheel.mouse_x, event->wheel.mouse_y); + if (thing && thing->onmousewheel) { + thing->onmousewheel(thing, event->wheel.y * ((event->wheel.direction == SDL_MOUSEWHEEL_FLIPPED) ? -1.0f : 1.0f)); + } + break; + + case SDL_EVENT_KEY_DOWN: + case SDL_EVENT_KEY_UP: + ctrl_held = ((event->key.mod & SDL_KMOD_CTRL) != 0); + alt_held = ((event->key.mod & SDL_KMOD_ALT) != 0); + break; + + case SDL_EVENT_DROP_FILE: + SDL_Log("Drop file! '%s'", event->drop.data); + LoadWavThing(event->drop.data, event->drop.x, event->drop.y); + /* SDL frees event->drop.data for you when you use SDL_AppEvent(). */ + break; + + case SDL_EVENT_WINDOW_RESIZED: + WindowResized(event->window.data1, event->window.data2); + break; + + case SDL_EVENT_AUDIO_DEVICE_ADDED: + CreatePhysicalDeviceThing(event->adevice.which, event->adevice.recording); + break; + + case SDL_EVENT_AUDIO_DEVICE_REMOVED: { + const SDL_AudioDeviceID which = event->adevice.which; + Thing *i, *next; + SDL_Log("Removing audio device %u", (unsigned int) which); + for (i = things; i; i = next) { + next = i->next; + if (((i->what == THING_PHYSDEV) || (i->what == THING_PHYSDEV_RECORDING)) && (i->data.physdev.devid == which)) { + TrashThing(i); + next = things; /* in case we mangled the list. */ + } else if (((i->what == THING_LOGDEV) || (i->what == THING_LOGDEV_RECORDING)) && (i->data.logdev.devid == which)) { + TrashThing(i); + next = things; /* in case we mangled the list. */ + } + } + break; + } + + default: break; + } + + return SDLTest_CommonEventMainCallbacks(state, event); +} + +SDL_AppResult SDL_AppIterate(void *appstate) +{ + if (app_ready_ticks == 0) { + app_ready_ticks = SDL_GetTicks(); + } + + TickThings(); + Draw(); + + if (saw_event) { + saw_event = false; /* reset this so we know when SDL_AppEvent() runs again */ + } else { + SDL_Delay(10); + } + + return SDL_APP_CONTINUE; +} + +void SDL_AppQuit(void *appstate, SDL_AppResult result) +{ + while (things) { + DestroyThing(things); /* make sure all the audio devices are closed, etc. */ + } + + DestroyTexture(physdev_texture); + DestroyTexture(logdev_texture); + DestroyTexture(audio_texture); + DestroyTexture(trashcan_texture); + DestroyTexture(soundboard_texture); + DestroyTexture(soundboard_levels_texture); + SDLTest_CommonQuit(state); +} + -- cgit v1.2.3