562 lines
20 KiB
C
562 lines
20 KiB
C
/*
|
||
// Created by bruno on 16.2.2025.
|
||
*/
|
||
|
||
#include "audio.h"
|
||
|
||
AudioData audioData;
|
||
|
||
MidiEvent midiEvents[MIDI_TRACK_MAX][MAX_MIDI_EVENTS];
|
||
int midiEventCount[MIDI_TRACK_MAX];
|
||
int nextMidiEvent[MIDI_TRACK_MAX];
|
||
|
||
uint16_t getAvailableChannel() {
|
||
for (uint16_t i = 0; i < NUM_SYNTH_VOICES - MIDI_VOICES; i++) {
|
||
if (audioData.synthVoices[i].volume == 0) {
|
||
return i;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
// Helper: compute left/right gains from a pan value in [–1..+1]
|
||
// pan = –1.0 → full left (L=1, R=0)
|
||
// pan = +1.0 → full right (L=0, R=1)
|
||
// pan = 0.0 → center (L=R=1/sqrt(2) or just 0.707 to avoid clipping)
|
||
static void compute_stereo_gains(float pan, float *outL, float *outR) {
|
||
// Simple linear panning (no constant‐power law).
|
||
// If you prefer constant‐power, you could do:
|
||
// float angle = (pan + 1.0f) * (M_PI / 4.0f);
|
||
// *outL = cosf(angle);
|
||
// *outR = sinf(angle);
|
||
//
|
||
// Here we’ll just do linear:
|
||
pan = fmaxf(-1.0f, fminf(+1.0f, pan));
|
||
if (pan <= 0.0f) {
|
||
*outL = 1.0f;
|
||
*outR = 1.0f + pan; // pan is negative, so R < 1
|
||
} else {
|
||
*outL = 1.0f - pan; // pan is positive, so L < 1
|
||
*outR = 1.0f;
|
||
}
|
||
// Optionally, scale down both so we never exceed 1.0f / sqrt(2)
|
||
// e.g. *outL *= 0.7071f; *outR *= 0.7071f;
|
||
}
|
||
|
||
// Improved audio ; with anti-clipping and smooth fade-out
|
||
void audio_callback(void *userdata, Uint8 *stream, int len) {
|
||
AudioData *audio = (AudioData *) userdata;
|
||
|
||
int frames = len / (2 * sizeof(float)); // Stereo frame count
|
||
|
||
float elapsedSec = ((float) audio->totalSamples) / SAMPLE_RATE;
|
||
audio->totalSamples += frames;
|
||
|
||
for (uint8_t midiChannel = 0; midiChannel < MIDI_TRACK_MAX; midiChannel++) {
|
||
while (nextMidiEvent[midiChannel] < midiEventCount[midiChannel] &&
|
||
midiEvents[midiChannel][nextMidiEvent[midiChannel]].timeSec <= elapsedSec) {
|
||
|
||
MidiEvent *ev = &midiEvents[midiChannel][nextMidiEvent[midiChannel]];
|
||
|
||
// printf("Event at %f, %s, note: %d, velocity: %d\n", ev->timeSec, ev->type == MIDI_NOTE_ON ? "ON" : "OFF",
|
||
// ev->note, ev->velocity);
|
||
|
||
uint16_t freq = (uint16_t)(440.0f * powf(2.0f, (ev->note - 69) / 12.0f));
|
||
uint8_t midiVoiceIndex = NUM_SYNTH_VOICES - midiChannel - 1;
|
||
SynthVoice *v = &audio->synthVoices[midiVoiceIndex];
|
||
if (ev->type == MIDI_NOTE_ON && ev->velocity > 0) {
|
||
// Note On
|
||
v->frequency = freq;
|
||
v->volume = ev->velocity * 2;
|
||
v->smoothedAmp = 0;
|
||
// printf("Playing voice %d at freq %d hz, volume %d\n", midiVoiceIndex, v->frequency,
|
||
// v->volume);
|
||
} else if (ev->type == MIDI_NOTE_OFF || ev->velocity == 0) {
|
||
// Note Off
|
||
v->volume = 0;
|
||
// printf("Stopping voice %d at freq %d hz, volume %d\n", midiVoiceIndex, v->frequency, v->volume);
|
||
} else if ((ev->type & 0xF0) == MIDI_PROGRAM_CHANGE) {
|
||
if (ev->note == 0) {
|
||
v->waveform = resolvePatch(ev->note);
|
||
}
|
||
}
|
||
|
||
nextMidiEvent[midiChannel]++;
|
||
}
|
||
}
|
||
|
||
float *outBuf = (float *) stream;
|
||
for (int i = 0; i < 2 * frames; ++i) {
|
||
outBuf[i] = 0.0f;
|
||
}
|
||
|
||
float listenerCx = audio->playerRect->x + audio->playerRect->w * 0.5f;
|
||
|
||
int *voiceCounts = calloc(frames, sizeof(int));
|
||
|
||
for (int v = 0; v < NUM_SYNTH_VOICES; v++) {
|
||
SynthVoice *voice = &audio->synthVoices[v];
|
||
|
||
if ((voice->volume == 0 && voice->smoothedAmp < 0.001f) || voice->frequency == 0)
|
||
continue;
|
||
|
||
float sourceCx = voice->sourceRect.x + TILE_SIZE * 0.5f;
|
||
float dx = sourceCx - listenerCx;
|
||
float pan = fmaxf(-1.0f, fminf(+1.0f, dx / audio->maxPanDistance));
|
||
|
||
float gainL = 1;
|
||
float gainR = 1;
|
||
float targetAmp = (voice->volume / 255.0f) / 2;
|
||
if (v < NUM_SYNTH_VOICES - MIDI_VOICES) {
|
||
float distanceAtten = 1.0f - fminf(fabsf(dx) / audio->maxPanDistance, 1.0f);
|
||
targetAmp *= distanceAtten;
|
||
compute_stereo_gains(pan, &gainL, &gainR);
|
||
gainL *= 0.7071f;
|
||
gainR *= 0.7071f;
|
||
|
||
}
|
||
|
||
double phaseInc = ((double) voice->frequency * 256.0) / (double) SAMPLE_RATE;
|
||
|
||
for (int i = 0; i < frames; i++) {
|
||
voice->smoothedAmp += (targetAmp - voice->smoothedAmp) * SMOOTHING_FACTOR;
|
||
float amp = voice->smoothedAmp;
|
||
|
||
double norm = voice->phase / 256.0;
|
||
double t = norm * 2.0 - 1.0;
|
||
float sample;
|
||
|
||
switch (voice->waveform) {
|
||
case WAVE_SINE:
|
||
sample = (float) sin(norm * 2.0 * M_PI);
|
||
break;
|
||
case WAVE_SQUARE:
|
||
sample = (t >= 0.0) ? 1.0f : -1.0f;
|
||
break;
|
||
case WAVE_SAWTOOTH:
|
||
sample = (float) t;
|
||
break;
|
||
case WAVE_TRIANGLE:
|
||
sample = (float) (1.0 - 4.0 * fabs(t - floor(t + 0.5)));
|
||
break;
|
||
case WAVE_NOISE:
|
||
sample = ((float) rand() / (float) RAND_MAX) * 2.0f - 1.0f;
|
||
break;
|
||
case WAVE_HALF_SINE: // one cycle of sine clipped to [0, 1]
|
||
sample = (float) (0.5 * sin(norm * 2.0 * M_PI) + 0.5);
|
||
break;
|
||
case WAVE_PULSE25:
|
||
sample = (norm < 0.25) ? 1.0f : -1.0f;
|
||
break;
|
||
case WAVE_PULSE10:
|
||
sample = (norm < 0.10) ? 1.0f : -1.0f;
|
||
break;
|
||
case WAVE_CLIPPED_SINE:
|
||
sample = fmaxf(-0.7f, fminf(0.7f, (float) sin(norm * 2.0 * M_PI)));
|
||
break;
|
||
case WAVE_EXP:
|
||
sample = copysignf(powf(fabsf(t), 0.5f), t); // softer exponential curve
|
||
break;
|
||
case WAVE_RAMP:
|
||
sample = 2.0f * fmodf(norm, 1.0f) - 1.0f; // ascending ramp (like saw)
|
||
break;
|
||
case WAVE_REVERSE_SAW:
|
||
sample = 1.0f - 2.0f * fmodf(norm, 1.0f); // descending ramp
|
||
break;
|
||
case WAVE_STAIRCASE:
|
||
sample = floorf(norm * 8.0f) / 4.0f - 1.0f; // stepped waveform
|
||
break;
|
||
default:
|
||
sample = (float) sin(norm * 2.0 * M_PI); // fallback to sine
|
||
break;
|
||
}
|
||
|
||
voice->phase += phaseInc;
|
||
if (voice->phase >= 256.0) voice->phase -= 256.0;
|
||
else if (voice->phase < 0.0) voice->phase += 256.0;
|
||
|
||
int idxL = 2 * i;
|
||
int idxR = 2 * i + 1;
|
||
|
||
outBuf[idxL] += sample * amp * gainL;
|
||
outBuf[idxR] += sample * amp * gainR;
|
||
voiceCounts[i]++;
|
||
}
|
||
}
|
||
for (int i = 0; i < frames; ++i) {
|
||
int count = voiceCounts[i];
|
||
if (count > 0) {
|
||
outBuf[2 * i + 0] /= count;
|
||
outBuf[2 * i + 1] /= count;
|
||
}
|
||
}
|
||
free(voiceCounts);
|
||
}
|
||
|
||
|
||
static uint32_t read_be_uint32(const uint8_t *data) {
|
||
return (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3];
|
||
}
|
||
|
||
static uint16_t read_be_uint16(const uint8_t *data) {
|
||
return (data[0] << 8) | data[1];
|
||
}
|
||
|
||
static uint32_t read_vlq(const uint8_t **ptr) {
|
||
uint32_t value = 0;
|
||
const uint8_t *p = *ptr;
|
||
while (*p & 0x80) {
|
||
value = (value << 7) | (*p++ & 0x7F);
|
||
}
|
||
value = (value << 7) | (*p++ & 0x7F);
|
||
*ptr = p;
|
||
return value;
|
||
}
|
||
|
||
void load_midi_file(const char *path) {
|
||
FILE *f = fopen(path, "rb");
|
||
if (!f) return;
|
||
fseek(f, 0, SEEK_END);
|
||
long size = ftell(f);
|
||
rewind(f);
|
||
|
||
uint8_t *data = malloc(size);
|
||
fread(data, 1, size, f);
|
||
fclose(f);
|
||
|
||
const uint8_t *ptr = data;
|
||
if (memcmp(ptr, "MThd", 4) != 0) return;
|
||
ptr += 8; // skip header length
|
||
uint16_t format = read_be_uint16(ptr);
|
||
ptr += 2;
|
||
uint16_t nTracks = read_be_uint16(ptr);
|
||
ptr += 2;
|
||
uint16_t ppqn = read_be_uint16(ptr);
|
||
ptr += 2;
|
||
|
||
if (format > 1) {
|
||
printf("ERROR: Only MIDI format 0 or 1 supported (found %d)\n", format);
|
||
free(data);
|
||
return;
|
||
}
|
||
if (nTracks == 0 || nTracks > MIDI_TRACK_MAX) {
|
||
printf("ERROR: Number of tracks %d out of range\n", nTracks);
|
||
free(data);
|
||
return;
|
||
}
|
||
|
||
|
||
for (int trackIndex = 0; trackIndex < nTracks; trackIndex++) {
|
||
if (memcmp(ptr, "MTrk", 4) != 0) return;
|
||
uint32_t trackLen = read_be_uint32(ptr + 4);
|
||
ptr += 8;
|
||
const uint8_t *trackEnd = ptr + trackLen;
|
||
|
||
float curTime = 0.0f;
|
||
uint32_t tempo = 500000; // default: 120 BPM
|
||
uint8_t lastStatus = 0;
|
||
|
||
while (ptr < trackEnd && midiEventCount[trackIndex] < MAX_MIDI_EVENTS) {
|
||
uint32_t delta = read_vlq(&ptr);
|
||
curTime += (delta * (tempo / 1000000.0f)) / ppqn;
|
||
|
||
uint8_t status = *ptr;
|
||
if (status < 0x80) status = lastStatus;
|
||
else ptr++;
|
||
|
||
lastStatus = status;
|
||
|
||
if (status == 0xFF) {
|
||
uint8_t metaType = *ptr++;
|
||
uint32_t len = read_vlq(&ptr);
|
||
if (metaType == 0x03) {
|
||
// This is a track name — skip it
|
||
ptr += len;
|
||
continue;
|
||
}
|
||
if (metaType == 0x51 && len == 3) {
|
||
tempo = (ptr[0] << 16 | ptr[1] << 8 | ptr[2]);
|
||
}
|
||
ptr += len;
|
||
} else if ((status & 0xF0) == 0x90 || (status & 0xF0) == 0x80) {
|
||
uint8_t note = *ptr++;
|
||
uint8_t vel = *ptr++;
|
||
midiEvents[trackIndex][midiEventCount[trackIndex]++] = (MidiEvent) {
|
||
.timeSec = curTime,
|
||
.type = status,
|
||
.note = note,
|
||
.velocity = vel
|
||
};
|
||
} else {
|
||
ptr += 2; // skip unknown
|
||
}
|
||
}
|
||
}
|
||
|
||
free(data);
|
||
}
|
||
|
||
|
||
Waveform resolvePatch(uint8_t patchNum) {
|
||
switch (patchNum) {
|
||
case 0:
|
||
return WAVE_CLIPPED_SINE; // Acoustic Grand Piano (harmonic, percussive)
|
||
case 1:
|
||
return WAVE_CLIPPED_SINE; // Bright Acoustic Piano
|
||
case 2:
|
||
return WAVE_CLIPPED_SINE; // Electric Grand Piano
|
||
case 3:
|
||
return WAVE_CLIPPED_SINE; // Honky-Tonk Piano
|
||
case 4:
|
||
return WAVE_SINE; // Electric Piano 1 (Rhodes) - smooth bell-like
|
||
case 5:
|
||
return WAVE_SINE; // Electric Piano 2 (Wurlitzer)
|
||
case 6:
|
||
return WAVE_CLIPPED_SINE; // Harpsichord (plucked, bright)
|
||
case 7:
|
||
return WAVE_SQUARE; // Clavinet (sharp, funky)
|
||
case 8:
|
||
return WAVE_SINE; // Celesta (bell-like, soft)
|
||
case 9:
|
||
return WAVE_SINE; // Glockenspiel (bright bell)
|
||
case 10:
|
||
return WAVE_SINE; // Music Box (delicate bell)
|
||
case 11:
|
||
return WAVE_SINE; // Vibraphone (vibrato sine-like)
|
||
case 12:
|
||
return WAVE_SINE; // Marimba (warm sine)
|
||
case 13:
|
||
return WAVE_SINE; // Xylophone (sharp sine)
|
||
case 14:
|
||
return WAVE_SINE; // Tubular Bells (bell)
|
||
case 15:
|
||
return WAVE_SINE; // Dulcimer (plucked sine)
|
||
case 16:
|
||
return WAVE_SAWTOOTH; // Drawbar Organ (rich harmonic)
|
||
case 17:
|
||
return WAVE_SAWTOOTH; // Percussive Organ
|
||
case 18:
|
||
return WAVE_SAWTOOTH; // Rock Organ
|
||
case 19:
|
||
return WAVE_SAWTOOTH; // Church Organ
|
||
case 20:
|
||
return WAVE_SAWTOOTH; // Reed Organ
|
||
case 21:
|
||
return WAVE_SQUARE; // Accordion (reedy square)
|
||
case 22:
|
||
return WAVE_SQUARE; // Harmonica (square-ish)
|
||
case 23:
|
||
return WAVE_SQUARE; // Tango Accordion
|
||
case 24:
|
||
return WAVE_PULSE25; // Nylon Guitar (plucked, soft pulse)
|
||
case 25:
|
||
return WAVE_PULSE25; // Steel Guitar
|
||
case 26:
|
||
return WAVE_PULSE25; // Jazz Guitar
|
||
case 27:
|
||
return WAVE_PULSE25; // Clean Electric Guitar
|
||
case 28:
|
||
return WAVE_PULSE25; // Muted Electric Guitar
|
||
case 29:
|
||
return WAVE_PULSE10; // Overdriven Guitar (more distorted)
|
||
case 30:
|
||
return WAVE_PULSE10; // Distortion Guitar
|
||
case 31:
|
||
return WAVE_PULSE25; // Guitar Harmonics (plucked)
|
||
case 32:
|
||
return WAVE_SINE; // Acoustic Bass
|
||
case 33:
|
||
return WAVE_SINE; // Electric Bass (finger)
|
||
case 34:
|
||
return WAVE_SINE; // Electric Bass (pick)
|
||
case 35:
|
||
return WAVE_SINE; // Fretless Bass
|
||
case 36:
|
||
return WAVE_TRIANGLE; // Slap Bass 1 (percussive triangle)
|
||
case 37:
|
||
return WAVE_TRIANGLE; // Slap Bass 2
|
||
case 38:
|
||
return WAVE_SAWTOOTH; // Synth Bass 1
|
||
case 39:
|
||
return WAVE_SAWTOOTH; // Synth Bass 2
|
||
case 40:
|
||
return WAVE_SINE; // Violin
|
||
case 41:
|
||
return WAVE_SINE; // Viola
|
||
case 42:
|
||
return WAVE_SINE; // Cello
|
||
case 43:
|
||
return WAVE_SINE; // Contrabass
|
||
case 44:
|
||
return WAVE_SAWTOOTH; // Tremolo Strings (rich)
|
||
case 45:
|
||
return WAVE_SINE; // Pizzicato Strings (plucked)
|
||
case 46:
|
||
return WAVE_SINE; // Orchestral Harp (plucked sine)
|
||
case 47:
|
||
return WAVE_CLIPPED_SINE; // Timpani (percussive sine)
|
||
case 48:
|
||
return WAVE_SAWTOOTH; // String Ensemble 1 (Slow Strings)
|
||
case 49:
|
||
return WAVE_SAWTOOTH; // String Ensemble 2 (Fast Strings)
|
||
case 50:
|
||
return WAVE_SAWTOOTH; // SynthStrings 1
|
||
case 51:
|
||
return WAVE_SAWTOOTH; // SynthStrings 2
|
||
case 52:
|
||
return WAVE_SINE; // Choir Aahs
|
||
case 53:
|
||
return WAVE_SINE; // Voice Oohs
|
||
case 54:
|
||
return WAVE_SQUARE; // Synth Voice
|
||
case 55:
|
||
return WAVE_SAWTOOTH; // Orchestra Hit (harsh)
|
||
case 56:
|
||
return WAVE_SQUARE; // Trumpet
|
||
case 57:
|
||
return WAVE_SQUARE; // Trombone
|
||
case 58:
|
||
return WAVE_SQUARE; // Tuba
|
||
case 59:
|
||
return WAVE_PULSE25; // Muted Trumpet
|
||
case 60:
|
||
return WAVE_SQUARE; // French Horn
|
||
case 61:
|
||
return WAVE_SAWTOOTH; // Brass Section
|
||
case 62:
|
||
return WAVE_SAWTOOTH; // SynthBrass 1
|
||
case 63:
|
||
return WAVE_SAWTOOTH; // SynthBrass 2
|
||
case 64:
|
||
return WAVE_SQUARE; // Soprano Sax
|
||
case 65:
|
||
return WAVE_SQUARE; // Alto Sax
|
||
case 66:
|
||
return WAVE_SQUARE; // Tenor Sax
|
||
case 67:
|
||
return WAVE_SQUARE; // Baritone Sax
|
||
case 68:
|
||
return WAVE_SINE; // Oboe
|
||
case 69:
|
||
return WAVE_SINE; // English Horn
|
||
case 70:
|
||
return WAVE_SINE; // Bassoon
|
||
case 71:
|
||
return WAVE_SINE; // Clarinet
|
||
case 72:
|
||
return WAVE_SINE; // Piccolo
|
||
case 73:
|
||
return WAVE_SINE; // Flute
|
||
case 74:
|
||
return WAVE_SINE; // Recorder
|
||
case 75:
|
||
return WAVE_SINE; // Pan Flute
|
||
case 76:
|
||
return WAVE_SINE; // Blown Bottle
|
||
case 77:
|
||
return WAVE_SINE; // Shakuhachi
|
||
case 78:
|
||
return WAVE_SINE; // Whistle
|
||
case 79:
|
||
return WAVE_SINE; // Ocarina
|
||
case 80:
|
||
return WAVE_SQUARE; // Lead 1 (Square)
|
||
case 81:
|
||
return WAVE_SAWTOOTH; // Lead 2 (Sawtooth)
|
||
case 82:
|
||
return WAVE_SAWTOOTH; // Lead 3 (Calliope)
|
||
case 83:
|
||
return WAVE_SINE; // Lead 4 (Chiff)
|
||
case 84:
|
||
return WAVE_SQUARE; // Lead 5 (Charang)
|
||
case 85:
|
||
return WAVE_SQUARE; // Lead 6 (Voice)
|
||
case 86:
|
||
return WAVE_SAWTOOTH; // Lead 7 (Fifths)
|
||
case 87:
|
||
return WAVE_SQUARE; // Lead 8 (Bass + Lead)
|
||
case 88:
|
||
return WAVE_SAWTOOTH; // Pad 1 (New Age)
|
||
case 89:
|
||
return WAVE_SAWTOOTH; // Pad 2 (Warm)
|
||
case 90:
|
||
return WAVE_SAWTOOTH; // Pad 3 (Polysynth)
|
||
case 91:
|
||
return WAVE_SINE; // Pad 4 (Choir)
|
||
case 92:
|
||
return WAVE_SINE; // Pad 5 (Bowed)
|
||
case 93:
|
||
return WAVE_SAWTOOTH; // Pad 6 (Metallic)
|
||
case 94:
|
||
return WAVE_SINE; // Pad 7 (Halo)
|
||
case 95:
|
||
return WAVE_SINE; // Pad 8 (Sweep)
|
||
case 96:
|
||
return WAVE_NOISE; // FX 1 (Rain)
|
||
case 97:
|
||
return WAVE_NOISE; // FX 2 (Soundtrack)
|
||
case 98:
|
||
return WAVE_NOISE; // FX 3 (Crystal)
|
||
case 99:
|
||
return WAVE_NOISE; // FX 4 (Atmosphere)
|
||
case 100:
|
||
return WAVE_NOISE; // FX 5 (Brightness)
|
||
case 101:
|
||
return WAVE_NOISE; // FX 6 (Goblins)
|
||
case 102:
|
||
return WAVE_NOISE; // FX 7 (Echoes)
|
||
case 103:
|
||
return WAVE_NOISE; // FX 8 (Sci-Fi)
|
||
case 104:
|
||
return WAVE_SAWTOOTH; // Sitar
|
||
case 105:
|
||
return WAVE_SQUARE; // Banjo
|
||
case 106:
|
||
return WAVE_PULSE25; // Shamisen
|
||
case 107:
|
||
return WAVE_SINE; // Koto
|
||
case 108:
|
||
return WAVE_SINE; // Kalimba
|
||
case 109:
|
||
return WAVE_SINE; // Bagpipe
|
||
case 110:
|
||
return WAVE_SINE; // Fiddle
|
||
case 111:
|
||
return WAVE_SINE; // Shanai
|
||
case 112:
|
||
return WAVE_SAWTOOTH; // Tinkle Bell
|
||
case 113:
|
||
return WAVE_NOISE; // Agogo
|
||
case 114:
|
||
return WAVE_NOISE; // Steel Drums
|
||
case 115:
|
||
return WAVE_NOISE; // Woodblock
|
||
case 116:
|
||
return WAVE_NOISE; // Taiko Drum
|
||
case 117:
|
||
return WAVE_NOISE; // Melodic Tom
|
||
case 118:
|
||
return WAVE_NOISE; // Synth Drum
|
||
case 119:
|
||
return WAVE_NOISE; // Reverse Cymbal
|
||
case 120:
|
||
return WAVE_NOISE; // Guitar Fret Noise
|
||
case 121:
|
||
return WAVE_NOISE; // Breath Noise
|
||
case 122:
|
||
return WAVE_NOISE; // Seashore
|
||
case 123:
|
||
return WAVE_NOISE; // Bird Tweet
|
||
case 124:
|
||
return WAVE_NOISE; // Telephone Ring
|
||
case 125:
|
||
return WAVE_NOISE; // Helicopter
|
||
case 126:
|
||
return WAVE_NOISE; // Applause
|
||
case 127:
|
||
return WAVE_NOISE; // Gunshot
|
||
default:
|
||
return WAVE_SINE; // Default fallback
|
||
}
|
||
|
||
} |