1603 lines
68 KiB
C
1603 lines
68 KiB
C
// spectrogram.c - Spectrogram viewer with region selection and playback
|
|
// Based on Unity Audio-Experiments project
|
|
|
|
#define _POSIX_C_SOURCE 200809L
|
|
#define _DEFAULT_SOURCE
|
|
|
|
#include "raylib.h"
|
|
#include "resource_dir.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
#include <complex.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
|
|
#ifndef M_PI
|
|
#define M_PI 3.14159265358979323846
|
|
#endif
|
|
|
|
// Define CYAN if not available
|
|
#ifndef CYAN
|
|
#define CYAN (Color){ 0, 255, 255, 255 }
|
|
#endif
|
|
|
|
// ============================================================================
|
|
// Configuration
|
|
// ============================================================================
|
|
|
|
#define FFT_SIZE_DEFAULT 2048
|
|
#define FFT_SIZE_MAX 2048
|
|
#define FFT_SIZE_MIN 128
|
|
#define HOP_RATIO 4 // FFT_SIZE / HOP_SIZE = 4 means 75% overlap
|
|
#define MAX_SAMPLE_RATE 48000
|
|
#define LOUDNESS_FLOOR_DB -80.0f
|
|
|
|
// Colormap types
|
|
typedef enum {
|
|
COLORMAP_GRAYS = 0,
|
|
COLORMAP_INFERNO,
|
|
COLORMAP_VIRIDIS,
|
|
COLORMAP_PLASMA,
|
|
COLORMAP_HOT,
|
|
COLORMAP_COOL,
|
|
COLORMAP_COUNT
|
|
} ColormapType;
|
|
|
|
// ============================================================================
|
|
// Data Structures
|
|
// ============================================================================
|
|
|
|
typedef struct {
|
|
float* samples;
|
|
int numSamples;
|
|
int sampleRate;
|
|
int channels;
|
|
float duration;
|
|
} AudioSignal;
|
|
|
|
typedef struct {
|
|
float frequency;
|
|
float amplitude;
|
|
float phase;
|
|
} FrequencyData;
|
|
|
|
typedef struct {
|
|
FrequencyData* spectrum;
|
|
FrequencyData* derivativeSpectrum; // STFT with derivative window (for synchrosqueezing)
|
|
int numBins;
|
|
int sampleOffset;
|
|
int sampleCount;
|
|
} StftSegment;
|
|
|
|
typedef struct {
|
|
StftSegment* segments;
|
|
int numSegments;
|
|
int sampleRate;
|
|
int totalSamples;
|
|
bool useHannWindow;
|
|
} StftResult;
|
|
|
|
typedef struct {
|
|
AudioSignal signal;
|
|
StftResult stft;
|
|
Image spectrogramImage;
|
|
Texture2D spectrogramTexture;
|
|
bool loaded;
|
|
bool stftComputed;
|
|
|
|
// Time selection (0-1 normalized)
|
|
float timeSelectionStart;
|
|
float timeSelectionEnd;
|
|
bool isTimeSelecting;
|
|
|
|
// Frequency selection (0-1 normalized)
|
|
float freqSelectionStart;
|
|
float freqSelectionEnd;
|
|
bool isFreqSelecting;
|
|
|
|
// Viewport/zoom controls
|
|
float viewStart; // 0-1, start of visible time region
|
|
float viewEnd; // 0-1, end of visible time region
|
|
float freqViewStart; // 0-1, start of visible frequency region (0 = 0Hz)
|
|
float freqViewEnd; // 0-1, end of visible frequency region (1 = Nyquist)
|
|
bool isPanning;
|
|
float panStartViewStart;
|
|
float panStartViewEnd;
|
|
float panStartFreqViewStart;
|
|
float panStartFreqViewEnd;
|
|
Vector2 panStartPos;
|
|
|
|
// Cached visible texture
|
|
Texture2D visibleTexture;
|
|
int cachedVisibleStart;
|
|
int cachedVisibleEnd;
|
|
int cachedVisibleStartY;
|
|
int cachedVisibleEndY;
|
|
bool visibleTextureValid;
|
|
|
|
// Display settings
|
|
float amplitudeFloorDb;
|
|
float amplitudeCeilingDb;
|
|
ColormapType colormap;
|
|
bool showGrid;
|
|
int fftSize; // Current FFT size (128-2048)
|
|
|
|
// File browser state
|
|
bool showFileBrowser;
|
|
char browserPath[512];
|
|
char** browserFiles;
|
|
bool* browserIsDir;
|
|
int browserFileCount;
|
|
int browserScroll;
|
|
int browserSelected;
|
|
bool isBrowsing;
|
|
|
|
// Playback state
|
|
bool isPlaying;
|
|
bool playbackFinished; // Track if playback completed naturally
|
|
} SpectrogramApp;
|
|
|
|
// ============================================================================
|
|
// Global State
|
|
// ============================================================================
|
|
|
|
static SpectrogramApp app = {0};
|
|
static Sound AudioPlaybackSound = {0};
|
|
static Texture2D colormapTexture = {0};
|
|
|
|
// ============================================================================
|
|
// Utility Functions
|
|
// ============================================================================
|
|
|
|
static float AmplitudeToDecibels(float amplitude)
|
|
{
|
|
if (amplitude < 0.0001f) amplitude = 0.0001f;
|
|
return 20.0f * log10f(amplitude);
|
|
}
|
|
|
|
static float Clamp(float value, float min, float max)
|
|
{
|
|
if (value < min) return min;
|
|
if (value > max) return max;
|
|
return value;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Colormap Functions
|
|
// ============================================================================
|
|
|
|
static Color GetColormapColor(float t, ColormapType type)
|
|
{
|
|
t = Clamp(t, 0.0f, 1.0f);
|
|
|
|
switch (type) {
|
|
case COLORMAP_GRAYS: {
|
|
unsigned char v = (unsigned char)(t * 255);
|
|
return (Color){ v, v, v, 255 };
|
|
}
|
|
case COLORMAP_INFERNO: {
|
|
float r = 0.0f, g = 0.0f, b = 0.0f;
|
|
if (t < 0.25f) { t = t / 0.25f; r = 0.0f + t * 0.5f; g = 0.0f; b = 0.0f + t * 0.3f; }
|
|
else if (t < 0.5f) { t = (t - 0.25f) / 0.25f; r = 0.5f + t * 0.5f; g = 0.0f + t * 0.3f; b = 0.3f + t * 0.4f; }
|
|
else if (t < 0.75f) { t = (t - 0.5f) / 0.25f; r = 1.0f; g = 0.3f + t * 0.5f; b = 0.7f + t * 0.2f; }
|
|
else { t = (t - 0.75f) / 0.25f; r = 1.0f; g = 0.8f + t * 0.2f; b = 0.9f + t * 0.1f; }
|
|
return (Color){ (unsigned char)(r * 255), (unsigned char)(g * 255), (unsigned char)(b * 255), 255 };
|
|
}
|
|
case COLORMAP_VIRIDIS: {
|
|
float r, g, b;
|
|
if (t < 0.25f) { t = t / 0.25f; r = 0.27f + t * 0.13f; g = 0.00f + t * 0.33f; b = 0.33f + t * 0.27f; }
|
|
else if (t < 0.5f) { t = (t - 0.25f) / 0.25f; r = 0.40f + t * 0.16f; g = 0.33f + t * 0.29f; b = 0.60f - t * 0.20f; }
|
|
else if (t < 0.75f) { t = (t - 0.5f) / 0.25f; r = 0.56f + t * 0.24f; g = 0.62f + t * 0.23f; b = 0.40f - t * 0.20f; }
|
|
else { t = (t - 0.75f) / 0.25f; r = 0.80f + t * 0.17f; g = 0.85f + t * 0.12f; b = 0.20f - t * 0.15f; }
|
|
return (Color){ (unsigned char)(r * 255), (unsigned char)(g * 255), (unsigned char)(b * 255), 255 };
|
|
}
|
|
case COLORMAP_PLASMA: {
|
|
float r = 0.05f + t * 0.9f;
|
|
float g = 0.0f + t * 0.6f + (t > 0.5f ? (t - 0.5f) * 0.4f : 0.0f);
|
|
float b = 0.6f - t * 0.5f;
|
|
return (Color){ (unsigned char)(r * 255), (unsigned char)(g * 255), (unsigned char)(b * 255), 255 };
|
|
}
|
|
case COLORMAP_HOT: {
|
|
float r = Clamp(t * 3.0f, 0.0f, 1.0f);
|
|
float g = Clamp((t - 0.33f) * 3.0f, 0.0f, 1.0f);
|
|
float b = Clamp((t - 0.66f) * 3.0f, 0.0f, 1.0f);
|
|
return (Color){ (unsigned char)(r * 255), (unsigned char)(g * 255), (unsigned char)(b * 255), 255 };
|
|
}
|
|
case COLORMAP_COOL: {
|
|
return (Color){ (unsigned char)(t * 255), (unsigned char)((1.0f - t) * 255), 255, 255 };
|
|
}
|
|
default: return GRAY;
|
|
}
|
|
}
|
|
|
|
static void GenerateColormapTexture(void)
|
|
{
|
|
if (colormapTexture.id != 0) UnloadTexture(colormapTexture);
|
|
Image img = GenImageColor(256, 1, WHITE);
|
|
Color* pixels = (Color*)img.data;
|
|
for (int i = 0; i < 256; i++) pixels[i] = GetColormapColor(i / 255.0f, app.colormap);
|
|
colormapTexture = LoadTextureFromImage(img);
|
|
UnloadImage(img);
|
|
}
|
|
|
|
// ============================================================================
|
|
// FFT Implementation
|
|
// ============================================================================
|
|
|
|
static void BitReverseCopy(float complex* input, float complex* output, int n)
|
|
{
|
|
int bits = 0, temp = n;
|
|
while (temp > 1) { bits++; temp >>= 1; }
|
|
for (int i = 0; i < n; i++) {
|
|
int j = 0, k = i;
|
|
for (int b = 0; b < bits; b++) { j = (j << 1) | (k & 1); k >>= 1; }
|
|
output[j] = input[i];
|
|
}
|
|
}
|
|
|
|
static void FFT(float complex* input, float complex* output, int n, bool inverse)
|
|
{
|
|
if (n <= 1) { output[0] = input[0]; return; }
|
|
BitReverseCopy(input, output, n);
|
|
for (int stage = 1; stage < n; stage *= 2) {
|
|
int step = stage * 2;
|
|
float angleStep = (inverse ? 2.0f : -2.0f) * (float)M_PI / step;
|
|
for (int k = 0; k < stage; k++) {
|
|
float complex twiddle = cexpf(I * angleStep * k);
|
|
for (int i = k; i < n; i += step) {
|
|
int j = i + stage;
|
|
float complex t = output[j] * twiddle;
|
|
output[j] = output[i] - t;
|
|
output[i] = output[i] + t;
|
|
}
|
|
}
|
|
}
|
|
if (inverse) for (int i = 0; i < n; i++) output[i] /= n;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Hann Window
|
|
// ============================================================================
|
|
|
|
static void ApplyHannWindow(float* samples, int n)
|
|
{
|
|
for (int i = 0; i < n; i++) {
|
|
float t = (float)i / (n - 1);
|
|
samples[i] *= 0.5f * (1.0f - cosf(2.0f * M_PI * t));
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// STFT Implementation
|
|
// ============================================================================
|
|
|
|
static void ComputeSTFT(AudioSignal* signal, StftResult* result, int fftSize)
|
|
{
|
|
int hopSize = fftSize / HOP_RATIO; // 75% overlap
|
|
int numSegments = (signal->numSamples - fftSize) / hopSize + 1;
|
|
if (numSegments <= 0) numSegments = 1;
|
|
|
|
result->numSegments = numSegments;
|
|
result->segments = (StftSegment*)malloc(numSegments * sizeof(StftSegment));
|
|
result->sampleRate = signal->sampleRate;
|
|
result->totalSamples = signal->numSamples;
|
|
result->useHannWindow = true;
|
|
|
|
int numBins = fftSize / 2 + 1;
|
|
float* windowedSamples = (float*)malloc(fftSize * sizeof(float));
|
|
float* derivWindowedSamples = (float*)malloc(fftSize * sizeof(float));
|
|
float complex *complexInput = (float complex*)malloc(fftSize * sizeof(float complex));
|
|
float complex* fftOutput = (float complex*)malloc(fftSize * sizeof(float complex));
|
|
|
|
for (int seg = 0; seg < numSegments; seg++) {
|
|
int offset = seg * hopSize;
|
|
int samplesToCopy = fftSize;
|
|
if (offset + samplesToCopy > signal->numSamples) {
|
|
samplesToCopy = signal->numSamples - offset;
|
|
memset(windowedSamples, 0, fftSize * sizeof(float));
|
|
memset(derivWindowedSamples, 0, fftSize * sizeof(float));
|
|
} else {
|
|
memcpy(windowedSamples, signal->samples + offset, fftSize * sizeof(float));
|
|
memcpy(derivWindowedSamples, signal->samples + offset, fftSize * sizeof(float));
|
|
}
|
|
|
|
// Apply Hann window: h(t) = 0.5 * (1 - cos(2πt))
|
|
// And derivative window: h'(t) = π * sin(2πt)
|
|
for (int i = 0; i < fftSize; i++) {
|
|
float t = (float)i / (fftSize - 1);
|
|
float hann = 0.5f * (1.0f - cosf(2.0f * M_PI * t));
|
|
float derivHann = M_PI * sinf(2.0f * M_PI * t);
|
|
windowedSamples[i] *= hann;
|
|
derivWindowedSamples[i] *= derivHann;
|
|
}
|
|
|
|
// Compute normal STFT (V_f)
|
|
for (int i = 0; i < fftSize; i++) complexInput[i] = windowedSamples[i] + 0.0f * I;
|
|
FFT(complexInput, fftOutput, fftSize, false);
|
|
|
|
result->segments[seg].numBins = numBins;
|
|
result->segments[seg].sampleOffset = offset;
|
|
result->segments[seg].sampleCount = samplesToCopy;
|
|
result->segments[seg].spectrum = (FrequencyData*)malloc(numBins * sizeof(FrequencyData));
|
|
|
|
for (int bin = 0; bin < numBins; bin++) {
|
|
result->segments[seg].spectrum[bin].frequency = (float)bin * signal->sampleRate / fftSize;
|
|
result->segments[seg].spectrum[bin].amplitude = (bin == 0) ? cabsf(fftOutput[bin]) / fftSize : 2.0f * cabsf(fftOutput[bin]) / fftSize;
|
|
result->segments[seg].spectrum[bin].phase = cargf(fftOutput[bin]);
|
|
}
|
|
|
|
// Compute derivative-window STFT (V_fd) for synchrosqueezing
|
|
result->segments[seg].derivativeSpectrum = (FrequencyData*)malloc(numBins * sizeof(FrequencyData));
|
|
for (int i = 0; i < fftSize; i++) complexInput[i] = derivWindowedSamples[i] + 0.0f * I;
|
|
FFT(complexInput, fftOutput, fftSize, false);
|
|
|
|
for (int bin = 0; bin < numBins; bin++) {
|
|
result->segments[seg].derivativeSpectrum[bin].frequency = (float)bin * signal->sampleRate / fftSize;
|
|
result->segments[seg].derivativeSpectrum[bin].amplitude = cabsf(fftOutput[bin]) / fftSize;
|
|
result->segments[seg].derivativeSpectrum[bin].phase = cargf(fftOutput[bin]);
|
|
}
|
|
}
|
|
free(windowedSamples); free(derivWindowedSamples); free(complexInput); free(fftOutput);
|
|
}
|
|
|
|
static void FreeSTFT(StftResult* result)
|
|
{
|
|
for (int i = 0; i < result->numSegments; i++) {
|
|
free(result->segments[i].spectrum);
|
|
if (result->segments[i].derivativeSpectrum) free(result->segments[i].derivativeSpectrum);
|
|
}
|
|
free(result->segments);
|
|
result->segments = NULL;
|
|
result->numSegments = 0;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Audio Loading
|
|
// ============================================================================
|
|
|
|
// Convert audio file to WAV using ffmpeg (if available)
|
|
static bool ConvertToFFmpegWAV(const char* inputPath, char* outputPath, size_t outputSize)
|
|
{
|
|
// Create temp WAV path
|
|
snprintf(outputPath, outputSize, "/tmp/rspektrum_temp_converted.wav");
|
|
|
|
// Build ffmpeg command
|
|
char cmd[1024];
|
|
snprintf(cmd, sizeof(cmd), "ffmpeg -y -loglevel quiet -i \"%s\" -ar 48000 -ac 1 -f wav \"%s\" 2>&1", inputPath, outputPath);
|
|
|
|
int result = system(cmd);
|
|
|
|
if (result == 0 && FileExists(outputPath)) {
|
|
TraceLog(LOG_INFO, "FFmpeg conversion successful: %s", outputPath);
|
|
return true;
|
|
}
|
|
|
|
TraceLog(LOG_WARNING, "FFmpeg conversion failed or not available");
|
|
return false;
|
|
}
|
|
|
|
static bool LoadWavFile(const char* filepath, AudioSignal* signal)
|
|
{
|
|
const char* ext = GetFileExtension(filepath);
|
|
char convertedPath[512] = { 0 };
|
|
bool isConverted = false;
|
|
|
|
// Check if we need to convert via ffmpeg
|
|
bool isWav = ext && (strcmp(ext, ".wav") == 0 || strcmp(ext, ".WAV") == 0);
|
|
|
|
if (!isWav) {
|
|
// Try ffmpeg conversion
|
|
if (ConvertToFFmpegWAV(filepath, convertedPath, sizeof(convertedPath))) {
|
|
filepath = convertedPath;
|
|
isConverted = true;
|
|
} else {
|
|
TraceLog(LOG_ERROR, "Unsupported format and ffmpeg not available: %s", filepath);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
Wave wave = LoadWave(filepath);
|
|
if (wave.data == NULL) {
|
|
TraceLog(LOG_ERROR, "Failed to open WAV file: %s", filepath);
|
|
if (isConverted) remove(convertedPath);
|
|
return false;
|
|
}
|
|
|
|
signal->sampleRate = wave.sampleRate;
|
|
signal->channels = wave.channels;
|
|
signal->numSamples = wave.frameCount * wave.channels;
|
|
signal->duration = (float)wave.frameCount / wave.sampleRate;
|
|
signal->samples = (float*)malloc(signal->numSamples * sizeof(float));
|
|
|
|
if (wave.sampleSize == 16) {
|
|
short* samples = (short*)wave.data;
|
|
for (int i = 0; i < signal->numSamples; i++) signal->samples[i] = samples[i] / 32768.0f;
|
|
} else if (wave.sampleSize == 32) {
|
|
float* samples = (float*)wave.data;
|
|
memcpy(signal->samples, samples, signal->numSamples * sizeof(float));
|
|
} else {
|
|
unsigned char* samples = (unsigned char*)wave.data;
|
|
for (int i = 0; i < signal->numSamples; i++) signal->samples[i] = (samples[i] - 128) / 128.0f;
|
|
}
|
|
|
|
if (wave.channels > 1) {
|
|
int monoSamples = wave.frameCount;
|
|
for (int i = 0; i < monoSamples; i++) {
|
|
float sum = 0.0f;
|
|
for (int c = 0; c < wave.channels; c++) sum += signal->samples[i * wave.channels + c];
|
|
signal->samples[i] = sum / wave.channels;
|
|
}
|
|
signal->numSamples = monoSamples;
|
|
}
|
|
UnloadWave(wave);
|
|
|
|
// Clean up temp file if converted
|
|
if (isConverted) {
|
|
remove(convertedPath);
|
|
TraceLog(LOG_INFO, "Cleaned up temp file: %s", convertedPath);
|
|
}
|
|
|
|
TraceLog(LOG_INFO, "Loaded WAV: %d Hz, %.2f sec, %d samples", signal->sampleRate, signal->duration, signal->numSamples);
|
|
return true;
|
|
}
|
|
|
|
static void FreeSignal(AudioSignal* signal)
|
|
{
|
|
if (signal->samples) { free(signal->samples); signal->samples = NULL; }
|
|
signal->numSamples = 0; signal->sampleRate = 0; signal->duration = 0.0f;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Spectrogram Generation
|
|
// ============================================================================
|
|
|
|
static void GenerateSpectrogramTexture(StftResult* stft, Image* image, Texture2D* texture)
|
|
{
|
|
if (stft->numSegments == 0) return;
|
|
int width = stft->numSegments;
|
|
int height = stft->segments[0].numBins;
|
|
int fftSize = (height - 1) * 2;
|
|
float freqPerBin = (float)stft->sampleRate / fftSize;
|
|
|
|
*image = GenImageColor(width, height, BLACK);
|
|
Color* pixels = (Color*)image->data;
|
|
|
|
// Find max amplitude for normalization
|
|
float maxAmplitude = 0.0001f;
|
|
for (int seg = 0; seg < stft->numSegments; seg++)
|
|
for (int bin = 0; bin < stft->segments[seg].numBins; bin++)
|
|
if (stft->segments[seg].spectrum[bin].amplitude > maxAmplitude)
|
|
maxAmplitude = stft->segments[seg].spectrum[bin].amplitude;
|
|
|
|
// ===== SYNCHROSQUEEZING =====
|
|
// Reassign energy to true frequencies using derivative STFT
|
|
|
|
// Accumulation buffer for reassigned energy
|
|
float* accumBuffer = (float*)calloc(width * height, sizeof(float));
|
|
|
|
// Noise threshold: only reassign bins with significant energy
|
|
float noiseThreshold = maxAmplitude * 0.01f; // 1% of max amplitude
|
|
|
|
for (int seg = 0; seg < width; seg++) {
|
|
for (int bin = 0; bin < height; bin++) {
|
|
FrequencyData* V_f = &stft->segments[seg].spectrum[bin];
|
|
FrequencyData* V_fd = &stft->segments[seg].derivativeSpectrum[bin];
|
|
|
|
float amplitude = V_f->amplitude;
|
|
|
|
// Skip noise bins
|
|
if (amplitude < noiseThreshold) continue;
|
|
|
|
// Compute instantaneous frequency using synchrosqueezing formula:
|
|
// ω̂ = bin_freq + Re[V_fd / (i * V_f)]
|
|
// Complex division: (a+bi)/(c+di) = ((ac+bd) + (bc-ad)i) / (c²+d²)
|
|
// We need Re[(a+bi) / (i*(c+di))] = Re[(a+bi) / (-d+ci)] = (ad+bc)/(c²+d²)
|
|
|
|
float V_f_real = amplitude * cosf(V_f->phase);
|
|
float V_f_imag = amplitude * sinf(V_f->phase);
|
|
float V_fd_real = V_fd->amplitude * cosf(V_fd->phase);
|
|
float V_fd_imag = V_fd->amplitude * sinf(V_fd->phase);
|
|
|
|
float denom = V_f_real * V_f_real + V_f_imag * V_f_imag;
|
|
|
|
float trueFreq = V_f->frequency; // Default to bin frequency
|
|
|
|
if (denom > 1e-10f) {
|
|
// Re[V_fd / (i * V_f)] = (-V_fd_real * V_f_imag + V_fd_imag * V_f_real) / denom
|
|
// Note the MINUS sign on the first term
|
|
float correction = (-V_fd_real * V_f_imag + V_fd_imag * V_f_real) / denom;
|
|
trueFreq = V_f->frequency + correction;
|
|
}
|
|
|
|
// Clamp to valid range
|
|
if (trueFreq < 0) trueFreq = 0;
|
|
if (trueFreq >= stft->sampleRate / 2.0f) trueFreq = stft->sampleRate / 2.0f - 1;
|
|
|
|
// Map to bin coordinate
|
|
float targetBinF = trueFreq / freqPerBin;
|
|
if (targetBinF < 0) targetBinF = 0;
|
|
if (targetBinF >= height) targetBinF = height - 0.001f;
|
|
|
|
// Bilinear splatting to neighboring bins
|
|
int bin0 = (int)targetBinF;
|
|
int bin1 = bin0 + 1;
|
|
if (bin1 >= height) bin1 = height - 1;
|
|
|
|
float frac = targetBinF - bin0;
|
|
int idx0 = (height - 1 - bin0) * width + seg;
|
|
int idx1 = (height - 1 - bin1) * width + seg;
|
|
|
|
accumBuffer[idx0] += amplitude * (1 - frac);
|
|
accumBuffer[idx1] += amplitude * frac;
|
|
}
|
|
}
|
|
|
|
// Convert accumulation buffer to colors
|
|
for (int i = 0; i < width * height; i++) {
|
|
if (accumBuffer[i] > 0.0001f) {
|
|
float db = AmplitudeToDecibels(accumBuffer[i]);
|
|
float normalized = (db - app.amplitudeFloorDb) / (app.amplitudeCeilingDb - app.amplitudeFloorDb);
|
|
normalized = Clamp(normalized, 0.0f, 1.0f);
|
|
pixels[i] = GetColormapColor(normalized, app.colormap);
|
|
}
|
|
}
|
|
|
|
free(accumBuffer);
|
|
|
|
if (texture->id != 0) UnloadTexture(*texture);
|
|
*texture = LoadTextureFromImage(*image);
|
|
SetTextureFilter(*texture, TEXTURE_FILTER_BILINEAR);
|
|
}
|
|
|
|
// ============================================================================
|
|
// Audio Playback with FFT-based Bandpass Filter
|
|
// ============================================================================
|
|
|
|
static void ApplyBandpassFilterFFT(float* samples, int numSamples, int sampleRate, float freqLow, float freqHigh)
|
|
{
|
|
if (freqLow <= 0 && freqHigh >= sampleRate / 2.0f) return;
|
|
|
|
int fftSize = 1;
|
|
while (fftSize < numSamples) fftSize *= 2;
|
|
fftSize *= 2;
|
|
|
|
float* windowedSamples = (float*)calloc(fftSize, sizeof(float));
|
|
float complex *fftInput = (float complex*)malloc(fftSize * sizeof(float complex));
|
|
float complex *fftOutput = (float complex*)malloc(fftSize * sizeof(float complex));
|
|
|
|
for (int i = 0; i < numSamples; i++) {
|
|
float window = 0.5f * (1.0f - cosf(2.0f * M_PI * i / (numSamples - 1)));
|
|
windowedSamples[i] = samples[i] * window;
|
|
}
|
|
for (int i = 0; i < fftSize; i++) fftInput[i] = windowedSamples[i] + 0.0f * I;
|
|
|
|
FFT(fftInput, fftOutput, fftSize, false);
|
|
|
|
float freqPerBin = (float)sampleRate / fftSize;
|
|
for (int bin = 0; bin < fftSize / 2 + 1; bin++) {
|
|
float frequency = bin * freqPerBin;
|
|
float attenuation = 1.0f;
|
|
if (frequency < freqLow) {
|
|
float dist = (freqLow - frequency) / (freqPerBin * 10.0f);
|
|
attenuation = 1.0f / (1.0f + dist * dist * dist);
|
|
} else if (frequency > freqHigh) {
|
|
float dist = (frequency - freqHigh) / (freqPerBin * 10.0f);
|
|
attenuation = 1.0f / (1.0f + dist * dist * dist);
|
|
}
|
|
fftOutput[bin] *= attenuation;
|
|
if (bin > 0 && bin < fftSize / 2) fftOutput[fftSize - bin] *= attenuation;
|
|
}
|
|
|
|
float complex* ifftOutput = (float complex*)malloc(fftSize * sizeof(float complex));
|
|
FFT(fftOutput, ifftOutput, fftSize, true);
|
|
|
|
float filteredPeak = 0.0f;
|
|
for (int i = 0; i < numSamples; i++) {
|
|
samples[i] = crealf(ifftOutput[i]);
|
|
if (fabsf(samples[i]) > filteredPeak) filteredPeak = fabsf(samples[i]);
|
|
}
|
|
|
|
const float TARGET_PEAK = 0.9f;
|
|
if (filteredPeak > 0.0001f) {
|
|
float gain = TARGET_PEAK / filteredPeak;
|
|
if (gain > 10.0f) gain = 10.0f;
|
|
for (int i = 0; i < numSamples; i++) {
|
|
samples[i] *= gain;
|
|
if (samples[i] > 0.95f) samples[i] = 0.95f;
|
|
if (samples[i] < -0.95f) samples[i] = -0.95f;
|
|
}
|
|
}
|
|
|
|
free(windowedSamples); free(fftInput); free(fftOutput); free(ifftOutput);
|
|
}
|
|
|
|
static void ApplyBandpassFilter(float* samples, int numSamples, int sampleRate, float freqLow, float freqHigh)
|
|
{
|
|
ApplyBandpassFilterFFT(samples, numSamples, sampleRate, freqLow, freqHigh);
|
|
}
|
|
|
|
static void PlaySelectedRegion(void)
|
|
{
|
|
if (!app.loaded || !app.stftComputed) return;
|
|
|
|
int startSample = (int)(app.timeSelectionStart * app.signal.numSamples);
|
|
int endSample = (int)(app.timeSelectionEnd * app.signal.numSamples);
|
|
int numSamples = endSample - startSample;
|
|
if (numSamples <= 0 || startSample < 0 || endSample > app.signal.numSamples) return;
|
|
|
|
float* regionSamples = (float*)malloc(numSamples * sizeof(float));
|
|
memcpy(regionSamples, app.signal.samples + startSample, numSamples * sizeof(float));
|
|
|
|
float maxFreq = (float)app.signal.sampleRate / 2.0f;
|
|
float freqLow = app.freqSelectionStart * maxFreq;
|
|
float freqHigh = app.freqSelectionEnd * maxFreq;
|
|
if (freqLow > 10.0f || freqHigh < maxFreq - 10.0f) {
|
|
TraceLog(LOG_INFO, "Applying bandpass filter: %.0f - %.0f Hz", freqLow, freqHigh);
|
|
ApplyBandpassFilter(regionSamples, numSamples, app.signal.sampleRate, freqLow, freqHigh);
|
|
}
|
|
|
|
if (AudioPlaybackSound.frameCount != 0) UnloadSound(AudioPlaybackSound);
|
|
|
|
Wave wave = { .data = regionSamples, .frameCount = (unsigned int)numSamples,
|
|
.sampleRate = (unsigned int)app.signal.sampleRate, .sampleSize = 32, .channels = 1 };
|
|
AudioPlaybackSound = LoadSoundFromWave(wave);
|
|
PlaySound(AudioPlaybackSound);
|
|
TraceLog(LOG_INFO, "Playing: %.2f-%.2f sec, %.0f-%.0f Hz",
|
|
(float)startSample / app.signal.sampleRate, (float)endSample / app.signal.sampleRate, freqLow, freqHigh);
|
|
}
|
|
|
|
// ============================================================================
|
|
// File Browser
|
|
// ============================================================================
|
|
|
|
static void FreeBrowserFiles(void)
|
|
{
|
|
if (app.browserFiles) {
|
|
for (int i = 0; i < app.browserFileCount; i++) free(app.browserFiles[i]);
|
|
free(app.browserFiles);
|
|
free(app.browserIsDir);
|
|
app.browserFiles = NULL;
|
|
app.browserIsDir = NULL;
|
|
}
|
|
app.browserFileCount = 0;
|
|
}
|
|
|
|
static void ScanDirectory(const char* path)
|
|
{
|
|
FreeBrowserFiles();
|
|
strncpy(app.browserPath, path, sizeof(app.browserPath) - 1);
|
|
FilePathList files = LoadDirectoryFiles(path);
|
|
|
|
int dirCount = 0, wavCount = 0;
|
|
for (int i = 0; i < files.count; i++) {
|
|
const char* name = GetFileName(files.paths[i]);
|
|
if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) continue;
|
|
if (DirectoryExists(files.paths[i])) dirCount++;
|
|
else {
|
|
const char* ext = GetFileExtension(files.paths[i]);
|
|
if (ext && (strcmp(ext, ".wav") == 0 || strcmp(ext, ".WAV") == 0 ||
|
|
strcmp(ext, ".Wave") == 0 || strcmp(ext, ".Wav") == 0)) wavCount++;
|
|
}
|
|
}
|
|
|
|
int totalCount = dirCount + wavCount;
|
|
if (totalCount > 0) {
|
|
app.browserFiles = (char**)malloc(totalCount * sizeof(char*));
|
|
app.browserIsDir = (bool*)malloc(totalCount * sizeof(bool));
|
|
app.browserFileCount = 0;
|
|
|
|
for (int i = 0; i < files.count; i++) {
|
|
const char* name = GetFileName(files.paths[i]);
|
|
if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) continue;
|
|
if (DirectoryExists(files.paths[i])) {
|
|
app.browserFiles[app.browserFileCount] = strdup(name);
|
|
app.browserIsDir[app.browserFileCount] = true;
|
|
app.browserFileCount++;
|
|
}
|
|
}
|
|
for (int i = 0; i < files.count; i++) {
|
|
const char* name = GetFileName(files.paths[i]);
|
|
if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) continue;
|
|
if (!DirectoryExists(files.paths[i])) {
|
|
const char* ext = GetFileExtension(files.paths[i]);
|
|
if (ext && (strcmp(ext, ".wav") == 0 || strcmp(ext, ".WAV") == 0 ||
|
|
strcmp(ext, ".Wave") == 0 || strcmp(ext, ".Wav") == 0)) {
|
|
app.browserFiles[app.browserFileCount] = strdup(name);
|
|
app.browserIsDir[app.browserFileCount] = false;
|
|
app.browserFileCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
UnloadDirectoryFiles(files);
|
|
app.browserScroll = 0;
|
|
app.browserSelected = -1;
|
|
}
|
|
|
|
static void NavigateToParentDirectory(void)
|
|
{
|
|
const char* parent = GetPrevDirectoryPath(app.browserPath);
|
|
if (parent && strlen(parent) > 0) ScanDirectory(parent);
|
|
}
|
|
|
|
static void NavigateToDirectory(const char* dirName)
|
|
{
|
|
char newPath[512];
|
|
int written = snprintf(newPath, sizeof(newPath), "%s/%s", app.browserPath, dirName);
|
|
if (written < 0 || written >= (int)sizeof(newPath)) return; // Path too long
|
|
if (DirectoryExists(newPath)) ScanDirectory(newPath);
|
|
}
|
|
|
|
static void LoadSelectedFile(void)
|
|
{
|
|
if (app.browserSelected < 0 || app.browserSelected >= app.browserFileCount) return;
|
|
|
|
char filePath[512];
|
|
int written = snprintf(filePath, sizeof(filePath), "%s/%s", app.browserPath, app.browserFiles[app.browserSelected]);
|
|
if (written < 0 || written >= (int)sizeof(filePath)) return; // Path too long
|
|
|
|
if (app.browserIsDir[app.browserSelected]) {
|
|
NavigateToDirectory(app.browserFiles[app.browserSelected]);
|
|
} else if (FileExists(filePath) && LoadWavFile(filePath, &app.signal)) {
|
|
app.loaded = true;
|
|
app.stftComputed = false;
|
|
app.timeSelectionStart = app.viewStart = 0.0f;
|
|
app.timeSelectionEnd = app.viewEnd = 1.0f;
|
|
app.freqSelectionStart = 0.0f;
|
|
app.freqSelectionEnd = 1.0f;
|
|
app.showFileBrowser = false;
|
|
// Invalidate visible texture cache
|
|
if (app.visibleTexture.id != 0) UnloadTexture(app.visibleTexture);
|
|
app.visibleTexture = (Texture2D){ 0 };
|
|
app.visibleTextureValid = false;
|
|
TraceLog(LOG_INFO, "Loaded: %s", filePath);
|
|
}
|
|
}
|
|
|
|
static void DrawFileBrowser(void)
|
|
{
|
|
// Draw semi-transparent overlay first
|
|
DrawRectangle(0, 0, GetScreenWidth(), GetScreenHeight(), Fade(BLACK, 0.85f));
|
|
|
|
float bw = 650, bh = 550;
|
|
float bx = (GetScreenWidth() - bw) / 2, by = (GetScreenHeight() - bh) / 2;
|
|
|
|
DrawRectangle(bx, by, bw, bh, (Color){ 45, 45, 55, 255 });
|
|
DrawRectangleLinesEx((Rectangle){ bx, by, bw, bh }, 2, GRAY);
|
|
DrawRectangle(bx, by, bw, 35, (Color){ 60, 60, 75, 255 });
|
|
DrawText("File Browser - Select WAV File", bx + 15, by + 10, 18, WHITE);
|
|
|
|
// Path bar
|
|
DrawRectangle(bx + 15, by + 45, bw - 110, 28, (Color){ 30, 30, 40, 255 });
|
|
DrawRectangleLinesEx((Rectangle){ bx + 15, by + 45, bw - 110, 28 }, 1, GRAY);
|
|
|
|
char displayPath[300];
|
|
strncpy(displayPath, app.browserPath, sizeof(displayPath) - 1);
|
|
displayPath[sizeof(displayPath) - 1] = '\0';
|
|
if (strlen(displayPath) > 60) sprintf(displayPath, "...%s", app.browserPath + strlen(app.browserPath) - 57);
|
|
DrawText(displayPath, bx + 20, by + 51, 14, LIGHTGRAY);
|
|
|
|
// Up button
|
|
Rectangle upBtn = { bx + bw - 85, by + 45, 70, 28 };
|
|
if (CheckCollisionPointRec(GetMousePosition(), upBtn)) DrawRectangleRec(upBtn, (Color){ 80, 80, 90, 255 });
|
|
DrawText("UP (..)", upBtn.x + 10, upBtn.y + 7, 14, WHITE);
|
|
|
|
// File list
|
|
float lx = bx + 15, ly = by + 82, lw = bw - 30, lh = bh - 150;
|
|
DrawRectangle(lx, ly, lw, lh, (Color){ 25, 25, 35, 255 });
|
|
DrawRectangleLinesEx((Rectangle){ lx, ly, lw, lh }, 1, GRAY);
|
|
|
|
// Handle empty directory
|
|
int visibleItems = (int)(lh / 26);
|
|
if (visibleItems < 1) visibleItems = 1;
|
|
|
|
if (app.browserFileCount <= 0 || !app.browserFiles) {
|
|
DrawText("(No WAV files in directory)", lx + 20, ly + lh/2 - 10, 14, GRAY);
|
|
} else {
|
|
if (app.browserFileCount > visibleItems) {
|
|
float sh = (float)visibleItems / app.browserFileCount * lh;
|
|
if (sh < 10) sh = 10;
|
|
float sy = ly + (float)app.browserScroll / (app.browserFileCount - visibleItems) * (lh - sh);
|
|
DrawRectangle(lx + lw - 10, sy, 8, sh, GRAY);
|
|
}
|
|
|
|
int startItem = app.browserScroll;
|
|
int endItem = startItem + visibleItems + 1;
|
|
if (endItem > app.browserFileCount) endItem = app.browserFileCount;
|
|
|
|
for (int i = startItem; i < endItem; i++) {
|
|
if (i < 0 || i >= app.browserFileCount || !app.browserFiles[i] || !app.browserIsDir) continue;
|
|
|
|
float iy = ly + (i - startItem) * 26 + 2;
|
|
bool hovered = CheckCollisionPointRec((Vector2){ GetMouseX(), GetMouseY() }, (Rectangle){ lx + 2, iy, lw - 14, 24 });
|
|
|
|
if (i == app.browserSelected) DrawRectangle(lx + 2, iy, lw - 14, 24, (Color){ 50, 70, 120, 180 });
|
|
else if (hovered) DrawRectangle(lx + 2, iy, lw - 14, 24, (Color){ 60, 60, 80, 100 });
|
|
|
|
const char* icon = app.browserIsDir[i] ? "[DIR]" : "[WAV]";
|
|
Color iconCol = app.browserIsDir[i] ? (Color){ 255, 220, 80, 255 } : (Color){ 80, 200, 120, 255 };
|
|
DrawText(icon, lx + 8, iy + 5, 13, iconCol);
|
|
DrawText(app.browserFiles[i], lx + 55, iy + 5, 14, WHITE);
|
|
}
|
|
}
|
|
|
|
// Scroll with mouse wheel
|
|
if (CheckCollisionPointRec(GetMousePosition(), (Rectangle){ lx, ly, lw - 10, lh }) && app.browserFileCount > 0) {
|
|
int wheel = GetMouseWheelMove();
|
|
if (wheel > 0) app.browserScroll--;
|
|
if (wheel < 0) app.browserScroll++;
|
|
if (app.browserScroll < 0) app.browserScroll = 0;
|
|
int maxScroll = app.browserFileCount - visibleItems;
|
|
if (maxScroll < 0) maxScroll = 0;
|
|
if (app.browserScroll > maxScroll) app.browserScroll = maxScroll;
|
|
}
|
|
|
|
// Handle clicks
|
|
if (CheckCollisionPointRec(GetMousePosition(), upBtn) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) NavigateToParentDirectory();
|
|
|
|
if (CheckCollisionPointRec(GetMousePosition(), (Rectangle){ lx, ly, lw - 10, lh }) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON) && app.browserFileCount > 0) {
|
|
int clicked = app.browserScroll + (int)((GetMouseY() - ly) / 26);
|
|
if (clicked >= 0 && clicked < app.browserFileCount) {
|
|
app.browserSelected = clicked;
|
|
static double lastClick = 0;
|
|
if (GetTime() - lastClick < 0.3) LoadSelectedFile();
|
|
lastClick = GetTime();
|
|
}
|
|
}
|
|
|
|
// Buttons
|
|
float btnY = by + bh - 50;
|
|
Rectangle openBtn = { bx + bw - 160, btnY, 140, 38 };
|
|
Rectangle cancelBtn = { bx + 15, btnY, 110, 38 };
|
|
|
|
bool openHovered = CheckCollisionPointRec(GetMousePosition(), openBtn);
|
|
bool openClicked = openHovered && IsMouseButtonPressed(MOUSE_LEFT_BUTTON);
|
|
if (openHovered) DrawRectangleRec(openBtn, (Color){ 100, 100, 120, 255 });
|
|
else DrawRectangleRec(openBtn, (Color){ 80, 80, 90, 255 });
|
|
DrawRectangleLinesEx(openBtn, 1, WHITE);
|
|
DrawText("OPEN (Enter)", openBtn.x + 25, openBtn.y + 12, 16, WHITE);
|
|
|
|
DrawRectangleRec(cancelBtn, (Color){ 100, 40, 40, 255 });
|
|
DrawText("ESC Cancel", cancelBtn.x + 18, cancelBtn.y + 12, 16, WHITE);
|
|
|
|
if ((IsKeyPressed(KEY_ENTER) || openClicked) && app.browserSelected >= 0 && app.browserFileCount > 0) LoadSelectedFile();
|
|
if (IsKeyPressed(KEY_ESCAPE)) app.showFileBrowser = false;
|
|
if (IsKeyPressed(KEY_UP) && app.browserSelected > 0 && app.browserFileCount > 0) {
|
|
app.browserSelected--;
|
|
if (app.browserSelected < app.browserScroll) app.browserScroll = app.browserSelected;
|
|
}
|
|
if (IsKeyPressed(KEY_DOWN) && app.browserSelected < app.browserFileCount - 1 && app.browserFileCount > 0) {
|
|
app.browserSelected++;
|
|
if (app.browserSelected >= app.browserScroll + visibleItems) app.browserScroll = app.browserSelected - visibleItems + 1;
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// UI and Rendering
|
|
// ============================================================================
|
|
|
|
static void DrawSpectrogramGrid(Rectangle bounds, int numCellsX, int numCellsY, Color color)
|
|
{
|
|
float cellWidth = bounds.width / numCellsX, cellHeight = bounds.height / numCellsY;
|
|
for (int i = 0; i <= numCellsX; i++) {
|
|
float x = bounds.x + i * cellWidth;
|
|
DrawLineV((Vector2){ x, bounds.y }, (Vector2){ x, bounds.y + bounds.height }, color);
|
|
}
|
|
for (int i = 0; i <= numCellsY; i++) {
|
|
float y = bounds.y + bounds.height - i * cellHeight;
|
|
DrawLineV((Vector2){ bounds.x, y }, (Vector2){ bounds.x + bounds.width, y }, color);
|
|
}
|
|
}
|
|
|
|
static void DrawLabels(Rectangle bounds)
|
|
{
|
|
int fontSize = 10;
|
|
Color textColor = LIGHTGRAY;
|
|
|
|
// Time labels
|
|
for (int i = 0; i <= 10; i++) {
|
|
float t = (float)i / 10;
|
|
float timeSec = (app.viewStart + t * (app.viewEnd - app.viewStart)) * app.signal.duration;
|
|
float x = bounds.x + t * bounds.width;
|
|
char label[32];
|
|
if (timeSec >= 60) sprintf(label, "%d:%02d", (int)(timeSec / 60), (int)(timeSec) % 60);
|
|
else sprintf(label, "%.1fs", timeSec);
|
|
Vector2 textSize = MeasureTextEx(GetFontDefault(), label, fontSize, 0);
|
|
DrawText(label, x - textSize.x / 2, bounds.y + bounds.height + 5, fontSize, textColor);
|
|
}
|
|
|
|
// Frequency labels at 1kHz intervals with 200Hz ticks
|
|
float maxFreq = (float)app.signal.sampleRate / 2.0f;
|
|
int maxKhz = (int)(maxFreq / 1000.0f);
|
|
|
|
for (int hz = 0; hz <= maxFreq; hz += 200) {
|
|
float t = hz / maxFreq;
|
|
float y = bounds.y + bounds.height - t * bounds.height;
|
|
Color tickColor = (hz % 1000 == 0) ? GRAY : Fade(GRAY, 0.4f);
|
|
DrawLineV((Vector2){ bounds.x - 5, y }, (Vector2){ bounds.x, y }, tickColor);
|
|
}
|
|
|
|
for (int khz = 0; khz <= maxKhz; khz++) {
|
|
float freq = khz * 1000.0f;
|
|
if (freq > maxFreq) break;
|
|
float t = freq / maxFreq;
|
|
float y = bounds.y + bounds.height - t * bounds.height;
|
|
char label[32];
|
|
if (khz == 0) sprintf(label, "0");
|
|
else if (khz < 10) sprintf(label, "%dk", khz);
|
|
else sprintf(label, "%d", khz);
|
|
Vector2 textSize = MeasureTextEx(GetFontDefault(), label, fontSize, 0);
|
|
DrawText(label, bounds.x - textSize.x - 15, y - textSize.y / 2, fontSize, textColor);
|
|
}
|
|
|
|
// Axis titles removed - just the tick labels are enough
|
|
}
|
|
|
|
static void DrawSlider(Rectangle bounds, float value);
|
|
static bool UpdateSlider(Rectangle bounds, float* value);
|
|
static void DrawSidebar(void);
|
|
|
|
static void DrawSelection(Rectangle bounds)
|
|
{
|
|
Color overlayColor = Fade(BLACK, 0.5f);
|
|
float selStartX = bounds.x + app.timeSelectionStart * bounds.width;
|
|
float selEndX = bounds.x + app.timeSelectionEnd * bounds.width;
|
|
|
|
if (selStartX > bounds.x) DrawRectangle(bounds.x, bounds.y, selStartX - bounds.x, bounds.height, overlayColor);
|
|
if (selEndX < bounds.x + bounds.width) DrawRectangle(selEndX, bounds.y, bounds.x + bounds.width - selEndX, bounds.height, overlayColor);
|
|
|
|
float selStartY = bounds.y + bounds.height - app.freqSelectionEnd * bounds.height;
|
|
float selEndY = bounds.y + bounds.height - app.freqSelectionStart * bounds.height;
|
|
|
|
if (selStartY > bounds.y) DrawRectangle(selStartX, bounds.y, selEndX - selStartX, selStartY - bounds.y, overlayColor);
|
|
if (selEndY < bounds.y + bounds.height) DrawRectangle(selStartX, selEndY, selEndX - selStartX, bounds.y + bounds.height - selEndY, overlayColor);
|
|
|
|
DrawLineV((Vector2){ selStartX, bounds.y }, (Vector2){ selStartX, bounds.y + bounds.height }, YELLOW);
|
|
DrawLineV((Vector2){ selEndX, bounds.y }, (Vector2){ selEndX, bounds.y + bounds.height }, YELLOW);
|
|
|
|
if (app.freqSelectionStart > 0.0f || app.freqSelectionEnd < 1.0f) {
|
|
DrawLineV((Vector2){ selStartX, selStartY }, (Vector2){ selEndX, selStartY }, CYAN);
|
|
DrawLineV((Vector2){ selStartX, selEndY }, (Vector2){ selEndX, selEndY }, CYAN);
|
|
}
|
|
}
|
|
|
|
static void DrawSidebar(void)
|
|
{
|
|
float sidebarWidth = 300;
|
|
float x = 10;
|
|
float y = 10;
|
|
int fontSize = 12;
|
|
bool needsRegen = false;
|
|
|
|
// Dark sidebar background
|
|
DrawRectangle(0, 0, sidebarWidth + 20, GetScreenHeight(), (Color){ 35, 35, 40, 255 });
|
|
DrawLine(sidebarWidth + 10, 0, sidebarWidth + 10, GetScreenHeight(), GRAY);
|
|
|
|
// Title
|
|
DrawText("Spectrogram Controls", x, y, 14, WHITE); y += 25;
|
|
|
|
// FFT Size clicker
|
|
DrawText(TextFormat("FFT Size: %d (%.1f Hz/bin)", app.fftSize, (float)app.signal.sampleRate / app.fftSize), x, y, fontSize, LIGHTGRAY); y += 18;
|
|
Rectangle fftMinus = { x, y, 30, 25 };
|
|
Rectangle fftPlus = { x + sidebarWidth - 40, y, 30, 25 };
|
|
if (CheckCollisionPointRec(GetMousePosition(), fftMinus) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) {
|
|
int newFFT = app.fftSize / 2;
|
|
if (newFFT >= FFT_SIZE_MIN) { app.fftSize = newFFT; app.stftComputed = false; needsRegen = true; }
|
|
}
|
|
if (CheckCollisionPointRec(GetMousePosition(), fftPlus) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) {
|
|
int newFFT = app.fftSize * 2;
|
|
if (newFFT <= FFT_SIZE_MAX) { app.fftSize = newFFT; app.stftComputed = false; needsRegen = true; }
|
|
}
|
|
DrawRectangleRec(fftMinus, (Color){ 50, 50, 60, 255 });
|
|
DrawRectangleLinesEx(fftMinus, 1, GRAY);
|
|
DrawText("-", fftMinus.x + 12, fftMinus.y + 5, 16, WHITE);
|
|
DrawRectangleRec(fftPlus, (Color){ 50, 50, 60, 255 });
|
|
DrawRectangleLinesEx(fftPlus, 1, GRAY);
|
|
DrawText("+", fftPlus.x + 10, fftPlus.y + 5, 16, WHITE);
|
|
y += 30;
|
|
|
|
// dB Floor slider
|
|
DrawText(TextFormat("dB Floor: %.1f", app.amplitudeFloorDb), x, y, fontSize, LIGHTGRAY); y += 18;
|
|
Rectangle dbSlider = { x, y, sidebarWidth - 10, 20 };
|
|
float dbValue = (app.amplitudeFloorDb + 100.0f) / 80.0f;
|
|
DrawSlider(dbSlider, dbValue);
|
|
if (UpdateSlider(dbSlider, &dbValue)) {
|
|
app.amplitudeFloorDb = -100.0f + dbValue * 80.0f;
|
|
needsRegen = true; // Trigger immediate redraw
|
|
}
|
|
y += 25;
|
|
|
|
// Colormap dropdown
|
|
DrawText("Colormap:", x, y, fontSize, LIGHTGRAY); y += 18;
|
|
const char* colormapNames[] = { "Grays", "Inferno", "Viridis", "Plasma", "Hot", "Cool" };
|
|
Rectangle cmapButton = { x, y, sidebarWidth - 10, 25 };
|
|
if (CheckCollisionPointRec(GetMousePosition(), cmapButton) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) {
|
|
app.colormap = (ColormapType)((app.colormap + 1) % COLORMAP_COUNT);
|
|
GenerateColormapTexture();
|
|
needsRegen = true;
|
|
}
|
|
DrawRectangleRec(cmapButton, (Color){ 50, 50, 60, 255 });
|
|
DrawRectangleLinesEx(cmapButton, 1, GRAY);
|
|
DrawText(colormapNames[app.colormap], cmapButton.x + 10, cmapButton.y + 6, fontSize, WHITE);
|
|
DrawTexturePro(colormapTexture, (Rectangle){ 0, 0, 256, 1 },
|
|
(Rectangle){ cmapButton.x + cmapButton.width - 60, cmapButton.y + 5, 50, 15 },
|
|
(Vector2){ 0, 0 }, 0.0f, WHITE);
|
|
y += 30;
|
|
|
|
// Grid toggle
|
|
Rectangle gridCheck = { x, y, 18, 18 };
|
|
if (CheckCollisionPointRec(GetMousePosition(), gridCheck) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) {
|
|
app.showGrid = !app.showGrid;
|
|
}
|
|
DrawRectangleRec(gridCheck, app.showGrid ? BLUE : DARKGRAY);
|
|
DrawRectangleLinesEx(gridCheck, 1, WHITE);
|
|
DrawText("Show Grid", x + 25, y + 2, fontSize, LIGHTGRAY); y += 25;
|
|
|
|
// File loading
|
|
DrawText("File:", x, y, fontSize, LIGHTGRAY); y += 18;
|
|
Rectangle fileButton = { x, y, sidebarWidth - 10, 25 };
|
|
if (CheckCollisionPointRec(GetMousePosition(), fileButton) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) {
|
|
app.showFileBrowser = true;
|
|
ScanDirectory(GetWorkingDirectory());
|
|
}
|
|
DrawRectangleRec(fileButton, (Color){ 50, 50, 60, 255 });
|
|
DrawRectangleLinesEx(fileButton, 1, GRAY);
|
|
DrawText("Open File Browser (O)", fileButton.x + 10, fileButton.y + 6, fontSize, WHITE);
|
|
y += 35;
|
|
|
|
// Playback
|
|
Rectangle playButton = { x, y, sidebarWidth - 10, 35 };
|
|
if (CheckCollisionPointRec(GetMousePosition(), playButton) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) {
|
|
if (app.isPlaying && AudioPlaybackSound.frameCount > 0) {
|
|
StopSound(AudioPlaybackSound);
|
|
app.isPlaying = false;
|
|
} else {
|
|
PlaySelectedRegion();
|
|
app.isPlaying = true;
|
|
}
|
|
}
|
|
const char* playText = app.isPlaying ? "STOP (SPACE)" : "PLAY (SPACE)";
|
|
DrawRectangleRec(playButton, app.isPlaying ? (Color){ 120, 40, 40, 255 } : (Color){ 40, 100, 40, 255 });
|
|
DrawRectangleLinesEx(playButton, 1, app.isPlaying ? RED : GREEN);
|
|
DrawText(playText, playButton.x + 10, playButton.y + 12, fontSize, WHITE);
|
|
y += 45;
|
|
|
|
// Reset/Clear buttons
|
|
Rectangle resetButton = { x, y, (sidebarWidth - 15) / 2, 25 };
|
|
if (CheckCollisionPointRec(GetMousePosition(), resetButton) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) {
|
|
app.timeSelectionStart = app.viewStart;
|
|
app.timeSelectionEnd = app.viewEnd;
|
|
app.freqSelectionStart = 0.0f;
|
|
app.freqSelectionEnd = 1.0f;
|
|
}
|
|
DrawRectangleRec(resetButton, (Color){ 80, 50, 50, 255 });
|
|
DrawRectangleLinesEx(resetButton, 1, RED);
|
|
DrawText("Reset Sel (R)", resetButton.x + 10, resetButton.y + 6, fontSize, WHITE);
|
|
|
|
Rectangle clearButton = { x + resetButton.width + 5, y, (sidebarWidth - 15) / 2, 25 };
|
|
if (CheckCollisionPointRec(GetMousePosition(), clearButton) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) {
|
|
app.timeSelectionStart = 0.0f;
|
|
app.timeSelectionEnd = 1.0f;
|
|
app.freqSelectionStart = 0.0f;
|
|
app.freqSelectionEnd = 1.0f;
|
|
}
|
|
DrawRectangleRec(clearButton, (Color){ 80, 50, 50, 255 });
|
|
DrawRectangleLinesEx(clearButton, 1, RED);
|
|
DrawText("Clear (ESC)", clearButton.x + 10, clearButton.y + 6, fontSize, WHITE);
|
|
y += 35;
|
|
|
|
// Signal info
|
|
DrawText("Signal Info:", x, y, fontSize, LIGHTGRAY); y += 18;
|
|
if (app.loaded) {
|
|
DrawText(TextFormat("Sample Rate: %d Hz", app.signal.sampleRate), x, y, fontSize, GRAY); y += 16;
|
|
DrawText(TextFormat("Duration: %.2f sec", app.signal.duration), x, y, fontSize, GRAY); y += 16;
|
|
DrawText(TextFormat("Max Freq: %.1f kHz", (float)app.signal.sampleRate / 2000.0f), x, y, fontSize, GRAY); y += 16;
|
|
} else {
|
|
DrawText("No file loaded", x, y, fontSize, GRAY); y += 16;
|
|
}
|
|
|
|
if (needsRegen && app.stftComputed) {
|
|
GenerateSpectrogramTexture(&app.stft, &app.spectrogramImage, &app.spectrogramTexture);
|
|
app.visibleTextureValid = false; // Force cache invalidation
|
|
}
|
|
}
|
|
|
|
static void DrawSlider(Rectangle bounds, float value)
|
|
{
|
|
// Background
|
|
DrawRectangleRec(bounds, DARKGRAY);
|
|
DrawRectangleLinesEx(bounds, 1, GRAY);
|
|
|
|
// Fill
|
|
float fillWidth = (bounds.width - 4) * value;
|
|
DrawRectangle(bounds.x + 2, bounds.y + 2, fillWidth, bounds.height - 4, BLUE);
|
|
|
|
// Handle
|
|
float handleX = bounds.x + 2 + fillWidth;
|
|
DrawRectangle(handleX - 3, bounds.y + 1, 6, bounds.height - 2, WHITE);
|
|
}
|
|
|
|
static bool UpdateSlider(Rectangle bounds, float* value)
|
|
{
|
|
bool changed = false;
|
|
if (CheckCollisionPointRec(GetMousePosition(), bounds) && IsMouseButtonDown(MOUSE_LEFT_BUTTON)) {
|
|
float newValue = (GetMousePosition().x - bounds.x - 2) / (bounds.width - 4);
|
|
newValue = Clamp(newValue, 0.0f, 1.0f);
|
|
if (fabsf(newValue - *value) > 0.001f) {
|
|
*value = newValue;
|
|
changed = true;
|
|
}
|
|
}
|
|
return changed;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Main Application
|
|
// ============================================================================
|
|
|
|
int main(int argc, char* argv[])
|
|
{
|
|
SetConfigFlags(FLAG_VSYNC_HINT | FLAG_WINDOW_HIGHDPI);
|
|
InitWindow(1280, 800, "Spectrogram Viewer");
|
|
SetTargetFPS(60);
|
|
SetTraceLogLevel(LOG_WARNING); // Suppress INFO texture logs
|
|
InitAudioDevice();
|
|
SearchAndSetResourceDir("resources");
|
|
|
|
app.timeSelectionStart = 0.0f; app.timeSelectionEnd = 1.0f;
|
|
app.freqSelectionStart = 0.0f; app.freqSelectionEnd = 1.0f;
|
|
app.viewStart = 0.0f; app.viewEnd = 1.0f;
|
|
app.freqViewStart = 0.0f; app.freqViewEnd = 1.0f;
|
|
app.showGrid = true;
|
|
app.colormap = COLORMAP_INFERNO;
|
|
app.amplitudeFloorDb = -60.0f;
|
|
app.amplitudeCeilingDb = 0.0f;
|
|
app.showFileBrowser = false;
|
|
app.isBrowsing = false;
|
|
app.visibleTexture = (Texture2D){ 0 };
|
|
app.cachedVisibleStart = -1;
|
|
app.cachedVisibleEnd = -1;
|
|
app.cachedVisibleStartY = -1;
|
|
app.cachedVisibleEndY = -1;
|
|
app.visibleTextureValid = false;
|
|
app.fftSize = FFT_SIZE_DEFAULT;
|
|
app.isPlaying = false;
|
|
app.playbackFinished = false;
|
|
|
|
GenerateColormapTexture();
|
|
ScanDirectory(GetWorkingDirectory());
|
|
|
|
TraceLog(LOG_INFO, "Spectrogram Viewer initialized");
|
|
|
|
bool fileLoaded = false;
|
|
if (argc > 1) {
|
|
TraceLog(LOG_INFO, "Loading file from command line: %s", argv[1]);
|
|
if (FileExists(argv[1]) && LoadWavFile(argv[1], &app.signal)) {
|
|
fileLoaded = true;
|
|
app.loaded = true;
|
|
app.stftComputed = false;
|
|
TraceLog(LOG_INFO, "File loaded successfully");
|
|
}
|
|
}
|
|
|
|
if (!fileLoaded) TraceLog(LOG_INFO, "Press 'O' for file browser or drag & drop WAV file");
|
|
|
|
while (!WindowShouldClose())
|
|
{
|
|
// Drag & Drop
|
|
if (IsFileDropped()) {
|
|
FilePathList dropped = LoadDroppedFiles();
|
|
if (dropped.count > 0) {
|
|
const char* ext = GetFileExtension(dropped.paths[0]);
|
|
bool isWav = ext && (strcmp(ext, ".wav") == 0 || strcmp(ext, ".WAV") == 0 || strcmp(ext, ".Wave") == 0 || strcmp(ext, ".Wav") == 0);
|
|
if (isWav && FileExists(dropped.paths[0])) {
|
|
if (LoadWavFile(dropped.paths[0], &app.signal)) {
|
|
app.loaded = true;
|
|
app.stftComputed = false;
|
|
app.viewStart = 0.0f; app.viewEnd = 1.0f;
|
|
// Invalidate visible texture cache
|
|
if (app.visibleTexture.id != 0) UnloadTexture(app.visibleTexture);
|
|
app.visibleTexture = (Texture2D){ 0 };
|
|
app.visibleTextureValid = false;
|
|
}
|
|
}
|
|
}
|
|
UnloadDroppedFiles(dropped);
|
|
}
|
|
|
|
// File browser toggle
|
|
if (IsKeyPressed(KEY_O) && !app.showFileBrowser) {
|
|
app.showFileBrowser = true;
|
|
ScanDirectory(GetWorkingDirectory());
|
|
}
|
|
|
|
// File browser update
|
|
if (app.showFileBrowser) {
|
|
// Browser handles its own input
|
|
}
|
|
|
|
// Check if playback finished naturally
|
|
if (app.isPlaying && AudioPlaybackSound.frameCount > 0) {
|
|
// Check if sound stopped playing (IsSoundPlaying returns false when done)
|
|
if (!IsSoundPlaying(AudioPlaybackSound)) {
|
|
app.isPlaying = false;
|
|
app.playbackFinished = true;
|
|
}
|
|
}
|
|
|
|
// View controls
|
|
if (app.loaded && !app.showFileBrowser) {
|
|
// Spectrogram area fills remaining window space
|
|
// Space for: spectrogram + time labels (15px below) + scrollbar (18px below that)
|
|
float sidebarWidth = 320;
|
|
float labelHeight = 15;
|
|
float scrollbarHeight = 18;
|
|
float freqLabelWidth = 65;
|
|
float vScrollbarWidth = 18;
|
|
float topMargin = 50;
|
|
float bottomMargin = 10;
|
|
|
|
Rectangle viewBounds = {
|
|
sidebarWidth + freqLabelWidth,
|
|
topMargin,
|
|
GetScreenWidth() - sidebarWidth - freqLabelWidth - vScrollbarWidth - 20,
|
|
GetScreenHeight() - topMargin - bottomMargin - labelHeight - scrollbarHeight - 10
|
|
};
|
|
|
|
// Zoom with mouse wheel (zooms both time and frequency to maintain aspect ratio)
|
|
if (GetMousePosition().x > 385 && CheckCollisionPointRec(GetMousePosition(), viewBounds)) {
|
|
int wheel = GetMouseWheelMove();
|
|
if (wheel != 0) {
|
|
float zoomFactor = (wheel > 0) ? 0.8f : 1.2f;
|
|
|
|
// --- Time axis zoom (around cursor X) ---
|
|
float mouseT = (GetMousePosition().x - viewBounds.x) / viewBounds.width;
|
|
mouseT = app.viewStart + mouseT * (app.viewEnd - app.viewStart);
|
|
float viewWidth = app.viewEnd - app.viewStart;
|
|
float newWidth = viewWidth * zoomFactor;
|
|
if (newWidth < 0.02f) newWidth = 0.02f;
|
|
if (newWidth > 1.0f) newWidth = 1.0f;
|
|
float leftOfMouse = mouseT - app.viewStart;
|
|
float rightOfMouse = app.viewEnd - mouseT;
|
|
app.viewStart = mouseT - leftOfMouse * (newWidth / viewWidth);
|
|
app.viewEnd = mouseT + rightOfMouse * (newWidth / viewWidth);
|
|
if (app.viewStart < 0) { app.viewStart = 0; app.viewEnd = newWidth; }
|
|
if (app.viewEnd > 1) { app.viewEnd = 1; app.viewStart = 1 - newWidth; }
|
|
|
|
// --- Frequency axis zoom (around cursor Y) ---
|
|
float mouseF = 1.0f - (GetMousePosition().y - viewBounds.y) / viewBounds.height;
|
|
mouseF = app.freqViewStart + mouseF * (app.freqViewEnd - app.freqViewStart);
|
|
float freqWidth = app.freqViewEnd - app.freqViewStart;
|
|
float newFreqWidth = freqWidth * zoomFactor;
|
|
if (newFreqWidth < 0.02f) newFreqWidth = 0.02f;
|
|
if (newFreqWidth > 1.0f) newFreqWidth = 1.0f;
|
|
float belowMouse = mouseF - app.freqViewStart;
|
|
float aboveMouse = app.freqViewEnd - mouseF;
|
|
app.freqViewStart = mouseF - belowMouse * (newFreqWidth / freqWidth);
|
|
app.freqViewEnd = mouseF + aboveMouse * (newFreqWidth / freqWidth);
|
|
if (app.freqViewStart < 0) { app.freqViewStart = 0; app.freqViewEnd = newFreqWidth; }
|
|
if (app.freqViewEnd > 1) { app.freqViewEnd = 1; app.freqViewStart = 1 - newFreqWidth; }
|
|
|
|
// Invalidate texture cache
|
|
app.visibleTextureValid = false;
|
|
}
|
|
}
|
|
|
|
// Pan with Alt+drag or middle mouse button (pans both axes)
|
|
bool canPan = IsKeyDown(KEY_LEFT_ALT) || IsKeyDown(KEY_RIGHT_ALT) || IsMouseButtonDown(MOUSE_BUTTON_MIDDLE);
|
|
if (canPan && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) {
|
|
app.isPanning = true;
|
|
app.panStartPos = GetMousePosition();
|
|
app.panStartViewStart = app.viewStart;
|
|
app.panStartViewEnd = app.viewEnd;
|
|
app.panStartFreqViewStart = app.freqViewStart;
|
|
app.panStartFreqViewEnd = app.freqViewEnd;
|
|
}
|
|
if (app.isPanning && IsMouseButtonDown(MOUSE_LEFT_BUTTON)) {
|
|
float dx = (GetMousePosition().x - app.panStartPos.x) / viewBounds.width;
|
|
float dy = (GetMousePosition().y - app.panStartPos.y) / viewBounds.height;
|
|
float viewWidth = app.panStartViewEnd - app.panStartViewStart;
|
|
float freqWidth = app.panStartFreqViewEnd - app.panStartFreqViewStart;
|
|
app.viewStart = app.panStartViewStart - dx * viewWidth;
|
|
app.viewEnd = app.panStartViewEnd - dx * viewWidth;
|
|
if (app.viewStart < 0) { app.viewStart = 0; app.viewEnd = viewWidth; }
|
|
if (app.viewEnd > 1) { app.viewEnd = 1; app.viewStart = 1 - viewWidth; }
|
|
app.freqViewStart = app.panStartFreqViewStart + dy * freqWidth;
|
|
app.freqViewEnd = app.panStartFreqViewEnd + dy * freqWidth;
|
|
if (app.freqViewStart < 0) { app.freqViewStart = 0; app.freqViewEnd = freqWidth; }
|
|
if (app.freqViewEnd > 1) { app.freqViewEnd = 1; app.freqViewStart = 1 - freqWidth; }
|
|
app.visibleTextureValid = false;
|
|
}
|
|
if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) app.isPanning = false;
|
|
|
|
// Home/End keys
|
|
if (IsKeyPressed(KEY_HOME)) {
|
|
app.viewStart = 0.0f; app.viewEnd = 1.0f;
|
|
app.freqViewStart = 0.0f; app.freqViewEnd = 1.0f;
|
|
app.visibleTextureValid = false;
|
|
}
|
|
if (IsKeyPressed(KEY_END)) {
|
|
float newWidth = 0.1f;
|
|
app.viewStart = 0.0f;
|
|
app.viewEnd = newWidth;
|
|
app.visibleTextureValid = false;
|
|
}
|
|
}
|
|
|
|
// Keyboard shortcuts (SPACE for play/stop toggle, ESC for clear)
|
|
if (IsKeyPressed(KEY_SPACE) && !app.showFileBrowser) {
|
|
if (app.isPlaying && AudioPlaybackSound.frameCount > 0) {
|
|
// Currently playing - stop it
|
|
StopSound(AudioPlaybackSound);
|
|
app.isPlaying = false;
|
|
app.playbackFinished = false;
|
|
} else if (app.playbackFinished) {
|
|
// Playback finished naturally - restart from beginning
|
|
PlaySelectedRegion();
|
|
app.isPlaying = true;
|
|
app.playbackFinished = false;
|
|
} else {
|
|
// Not playing and didn't just finish - start playback
|
|
PlaySelectedRegion();
|
|
app.isPlaying = true;
|
|
}
|
|
}
|
|
|
|
if (IsKeyPressed(KEY_ESCAPE)) {
|
|
if (app.showFileBrowser) {
|
|
app.showFileBrowser = false;
|
|
} else {
|
|
// Clear selections instead of exiting
|
|
app.timeSelectionStart = 0.0f;
|
|
app.timeSelectionEnd = 1.0f;
|
|
app.freqSelectionStart = 0.0f;
|
|
app.freqSelectionEnd = 1.0f;
|
|
}
|
|
}
|
|
|
|
// Selection (only when mouse is in spectrogram area, not sidebar)
|
|
float selSidebarWidth = 320;
|
|
float selLabelHeight = 15;
|
|
float selScrollbarHeight = 18;
|
|
float selFreqLabelWidth = 65;
|
|
float selVScrollbarWidth = 18;
|
|
float selTopMargin = 50;
|
|
float selBottomMargin = 10;
|
|
|
|
Rectangle selBounds = {
|
|
selSidebarWidth + selFreqLabelWidth,
|
|
selTopMargin,
|
|
GetScreenWidth() - selSidebarWidth - selFreqLabelWidth - selVScrollbarWidth - 20,
|
|
GetScreenHeight() - selTopMargin - selBottomMargin - selLabelHeight - selScrollbarHeight - 10
|
|
};
|
|
Vector2 mousePos = GetMousePosition();
|
|
|
|
if (app.loaded && !app.showFileBrowser && mousePos.x > 385 && CheckCollisionPointRec(mousePos, selBounds)) {
|
|
bool shiftHeld = IsKeyDown(KEY_LEFT_SHIFT) || IsKeyDown(KEY_RIGHT_SHIFT);
|
|
|
|
if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON) && !app.isPanning) {
|
|
if (shiftHeld) {
|
|
app.isFreqSelecting = true;
|
|
float t = 1.0f - (mousePos.y - selBounds.y) / selBounds.height;
|
|
app.freqSelectionStart = Clamp(t, 0.0f, 1.0f);
|
|
app.freqSelectionEnd = app.freqSelectionStart;
|
|
} else if (!IsKeyDown(KEY_LEFT_ALT) && !IsKeyDown(KEY_RIGHT_ALT)) {
|
|
app.isTimeSelecting = true;
|
|
app.timeSelectionStart = Clamp((mousePos.x - selBounds.x) / selBounds.width, 0.0f, 1.0f);
|
|
app.timeSelectionEnd = app.timeSelectionStart;
|
|
}
|
|
}
|
|
|
|
if (app.isTimeSelecting && IsMouseButtonDown(MOUSE_LEFT_BUTTON)) {
|
|
app.timeSelectionEnd = Clamp((mousePos.x - selBounds.x) / selBounds.width, 0.0f, 1.0f);
|
|
}
|
|
if (app.isFreqSelecting && IsMouseButtonDown(MOUSE_LEFT_BUTTON)) {
|
|
float t = 1.0f - (mousePos.y - selBounds.y) / selBounds.height;
|
|
app.freqSelectionEnd = Clamp(t, 0.0f, 1.0f);
|
|
}
|
|
|
|
if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) {
|
|
if (app.isTimeSelecting) {
|
|
app.isTimeSelecting = false;
|
|
if (app.timeSelectionEnd < app.timeSelectionStart) {
|
|
float tmp = app.timeSelectionStart;
|
|
app.timeSelectionStart = app.timeSelectionEnd;
|
|
app.timeSelectionEnd = tmp;
|
|
}
|
|
}
|
|
if (app.isFreqSelecting) {
|
|
app.isFreqSelecting = false;
|
|
if (app.freqSelectionEnd < app.freqSelectionStart) {
|
|
float tmp = app.freqSelectionStart;
|
|
app.freqSelectionStart = app.freqSelectionEnd;
|
|
app.freqSelectionEnd = tmp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Processing
|
|
if (app.loaded && !app.stftComputed) {
|
|
TraceLog(LOG_INFO, "Computing STFT...");
|
|
double startTime = GetTime();
|
|
ComputeSTFT(&app.signal, &app.stft, app.fftSize);
|
|
TraceLog(LOG_INFO, "STFT computed in %.2f sec (%d segments)", GetTime() - startTime, app.stft.numSegments);
|
|
GenerateSpectrogramTexture(&app.stft, &app.spectrogramImage, &app.spectrogramTexture);
|
|
app.stftComputed = true;
|
|
}
|
|
|
|
// Rendering
|
|
BeginDrawing();
|
|
ClearBackground((Color){ 30, 30, 30, 255 });
|
|
|
|
// Layout: sidebar on left, spectrogram on right
|
|
// Space for: spectrogram + time labels (15px below) + scrollbar (18px below that)
|
|
float sidebarWidth = 320;
|
|
float labelHeight = 15;
|
|
float scrollbarHeight = 18;
|
|
float freqLabelWidth = 65;
|
|
float vScrollbarWidth = 18;
|
|
float topMargin = 50;
|
|
float bottomMargin = 10;
|
|
|
|
// Spectrogram area (excludes labels and scrollbars)
|
|
Rectangle viewBounds = {
|
|
sidebarWidth + freqLabelWidth,
|
|
topMargin,
|
|
GetScreenWidth() - sidebarWidth - freqLabelWidth - vScrollbarWidth - 20,
|
|
GetScreenHeight() - topMargin - bottomMargin - labelHeight - scrollbarHeight - 10
|
|
};
|
|
// Time labels sit just below the spectrogram
|
|
Rectangle timeLabelArea = { viewBounds.x, viewBounds.y + viewBounds.height, viewBounds.width, labelHeight };
|
|
// Horizontal scrollbar sits below the time labels
|
|
Rectangle hScrollbar = { viewBounds.x, viewBounds.y + viewBounds.height + labelHeight + 5, viewBounds.width, scrollbarHeight };
|
|
// Vertical scrollbar sits to the right of the spectrogram
|
|
Rectangle vScrollbar = { viewBounds.x + viewBounds.width + 5, viewBounds.y, vScrollbarWidth, viewBounds.height };
|
|
|
|
// Draw sidebar first (on top left)
|
|
DrawSidebar();
|
|
|
|
// Draw spectrogram (background, in its own area)
|
|
if (app.loaded && app.stftComputed) {
|
|
int imgWidth = app.spectrogramImage.width;
|
|
int imgHeight = app.spectrogramImage.height;
|
|
|
|
// Calculate visible region (time and frequency)
|
|
int visibleStartX = (int)(app.viewStart * imgWidth);
|
|
int visibleEndX = (int)(app.viewEnd * imgWidth);
|
|
int visibleWidth = visibleEndX - visibleStartX;
|
|
|
|
// Frequency: 0 = bottom of image (bin 0), 1 = top of image (bin max)
|
|
int visibleStartY = (int)((1.0f - app.freqViewEnd) * imgHeight);
|
|
int visibleEndY = (int)((1.0f - app.freqViewStart) * imgHeight);
|
|
int visibleHeight = visibleEndY - visibleStartY;
|
|
|
|
// Invalidate cache if view changed or texture not valid
|
|
bool cacheInvalid = !app.visibleTextureValid ||
|
|
visibleStartX != app.cachedVisibleStart ||
|
|
visibleEndX != app.cachedVisibleEnd ||
|
|
visibleStartY != app.cachedVisibleStartY ||
|
|
visibleEndY != app.cachedVisibleEndY ||
|
|
visibleWidth <= 0 || visibleHeight <= 0;
|
|
|
|
if (cacheInvalid && visibleWidth > 0 && visibleStartX >= 0 && visibleHeight > 0 && visibleStartY >= 0) {
|
|
// Free old texture if exists
|
|
if (app.visibleTexture.id != 0) UnloadTexture(app.visibleTexture);
|
|
|
|
// Create a sub-image for the visible region
|
|
Image visibleImage = GenImageColor(visibleWidth, visibleHeight, BLACK);
|
|
Color* srcPixels = (Color*)app.spectrogramImage.data;
|
|
Color* dstPixels = (Color*)visibleImage.data;
|
|
|
|
for (int y = 0; y < visibleHeight; y++) {
|
|
for (int x = 0; x < visibleWidth; x++) {
|
|
dstPixels[y * visibleWidth + x] = srcPixels[(visibleStartY + y) * imgWidth + visibleStartX + x];
|
|
}
|
|
}
|
|
|
|
app.visibleTexture = LoadTextureFromImage(visibleImage);
|
|
UnloadImage(visibleImage);
|
|
|
|
app.cachedVisibleStart = visibleStartX;
|
|
app.cachedVisibleEnd = visibleEndX;
|
|
app.cachedVisibleStartY = visibleStartY;
|
|
app.cachedVisibleEndY = visibleEndY;
|
|
app.visibleTextureValid = true;
|
|
}
|
|
|
|
// Draw cached texture
|
|
if (app.visibleTextureValid && app.visibleTexture.id != 0) {
|
|
DrawTexturePro(app.visibleTexture,
|
|
(Rectangle){ 0, 0, visibleWidth, visibleHeight },
|
|
viewBounds, (Vector2){ 0, 0 }, 0.0f, WHITE);
|
|
}
|
|
|
|
// Draw scrollbars
|
|
// Horizontal scrollbar (time)
|
|
DrawRectangleRec(hScrollbar, DARKGRAY);
|
|
float hThumbWidth = (app.viewEnd - app.viewStart) * hScrollbar.width;
|
|
float hThumbX = hScrollbar.x + app.viewStart * hScrollbar.width;
|
|
if (hThumbWidth < 10) hThumbWidth = 10;
|
|
DrawRectangle(hThumbX, hScrollbar.y, hThumbWidth, hScrollbar.height, GRAY);
|
|
|
|
// Vertical scrollbar (frequency)
|
|
DrawRectangleRec(vScrollbar, DARKGRAY);
|
|
float vThumbHeight = (app.freqViewEnd - app.freqViewStart) * vScrollbar.height;
|
|
float vThumbY = vScrollbar.y + (1.0f - app.freqViewEnd) * vScrollbar.height;
|
|
if (vThumbHeight < 10) vThumbHeight = 10;
|
|
DrawRectangle(vScrollbar.x, vThumbY, vScrollbar.width, vThumbHeight, GRAY);
|
|
|
|
// Handle scrollbar dragging
|
|
static bool draggingH = false, draggingV = false;
|
|
static Vector2 dragStartPos;
|
|
static float dragStartViewStart, dragStartFreqViewStart;
|
|
|
|
if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON) && CheckCollisionPointRec(GetMousePosition(), hScrollbar)) {
|
|
draggingH = true;
|
|
dragStartPos = GetMousePosition();
|
|
dragStartViewStart = app.viewStart;
|
|
}
|
|
if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON) && CheckCollisionPointRec(GetMousePosition(), vScrollbar)) {
|
|
draggingV = true;
|
|
dragStartPos = GetMousePosition();
|
|
dragStartFreqViewStart = app.freqViewStart;
|
|
}
|
|
if (draggingH && IsMouseButtonDown(MOUSE_LEFT_BUTTON)) {
|
|
float dx = (GetMousePosition().x - dragStartPos.x) / hScrollbar.width;
|
|
float viewWidth = app.viewEnd - app.viewStart;
|
|
app.viewStart = dragStartViewStart + dx;
|
|
app.viewEnd = app.viewStart + viewWidth;
|
|
if (app.viewStart < 0) { app.viewStart = 0; app.viewEnd = viewWidth; }
|
|
if (app.viewEnd > 1) { app.viewEnd = 1; app.viewStart = 1 - viewWidth; }
|
|
app.visibleTextureValid = false;
|
|
}
|
|
if (draggingV && IsMouseButtonDown(MOUSE_LEFT_BUTTON)) {
|
|
float dy = (GetMousePosition().y - dragStartPos.y) / vScrollbar.height;
|
|
float freqWidth = app.freqViewEnd - app.freqViewStart;
|
|
app.freqViewStart = dragStartFreqViewStart - dy;
|
|
app.freqViewEnd = app.freqViewStart + freqWidth;
|
|
if (app.freqViewStart < 0) { app.freqViewStart = 0; app.freqViewEnd = freqWidth; }
|
|
if (app.freqViewEnd > 1) { app.freqViewEnd = 1; app.freqViewStart = 1 - freqWidth; }
|
|
app.visibleTextureValid = false;
|
|
}
|
|
if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) { draggingH = false; draggingV = false; }
|
|
|
|
if (app.showGrid) DrawSpectrogramGrid(viewBounds, 10, 8, Fade(GRAY, 0.3f));
|
|
DrawSelection(viewBounds);
|
|
DrawLabels(viewBounds);
|
|
float maxFreq = (float)app.signal.sampleRate / 2.0f;
|
|
float freqMin = app.freqViewStart * maxFreq;
|
|
float freqMax = app.freqViewEnd * maxFreq;
|
|
DrawText(TextFormat("Freq: %.0f-%.0f Hz", freqMin, freqMax),
|
|
viewBounds.x, viewBounds.y - 30, 20, LIGHTGRAY);
|
|
} else if (!app.showFileBrowser) {
|
|
const char* msg1 = "Press 'O' or click 'Open File Browser' to load a WAV";
|
|
const char* msg2 = "Or drag & drop a file, or use: ./rspektrum <file.wav>";
|
|
Vector2 t1 = MeasureTextEx(GetFontDefault(), msg1, 24, 0);
|
|
Vector2 t2 = MeasureTextEx(GetFontDefault(), msg2, 18, 0);
|
|
DrawText(msg1, 350 + (GetScreenWidth() - 380 - 350) / 2 - t1.x / 2, GetScreenHeight() / 2 - t1.y / 2 - 15, 24, LIGHTGRAY);
|
|
DrawText(msg2, 350 + (GetScreenWidth() - 380 - 350) / 2 - t2.x / 2, GetScreenHeight() / 2 - t2.y / 2 + 15, 18, GRAY);
|
|
}
|
|
|
|
// Draw file browser on top (if active)
|
|
if (app.showFileBrowser) DrawFileBrowser();
|
|
|
|
EndDrawing();
|
|
}
|
|
|
|
TraceLog(LOG_INFO, "Shutting down...");
|
|
if (AudioPlaybackSound.frameCount != 0) UnloadSound(AudioPlaybackSound);
|
|
if (app.stftComputed) { FreeSTFT(&app.stft); UnloadImage(app.spectrogramImage); UnloadTexture(app.spectrogramTexture); }
|
|
if (app.visibleTexture.id != 0) UnloadTexture(app.visibleTexture);
|
|
app.visibleTexture = (Texture2D){ 0 };
|
|
app.visibleTextureValid = false;
|
|
UnloadTexture(colormapTexture);
|
|
FreeBrowserFiles();
|
|
FreeSignal(&app.signal);
|
|
CloseAudioDevice();
|
|
CloseWindow();
|
|
return 0;
|
|
}
|