2019-08-25 04:46:40 +00:00
|
|
|
#include <ultra64.h>
|
|
|
|
#include <macros.h>
|
|
|
|
|
|
|
|
#include "effects.h"
|
|
|
|
#include "load.h"
|
|
|
|
#include "data.h"
|
|
|
|
#include "seqplayer.h"
|
|
|
|
|
|
|
|
#ifdef VERSION_JP
|
|
|
|
#define US_FLOAT2(x) x##.0
|
|
|
|
#else
|
|
|
|
#define US_FLOAT2(x) x
|
|
|
|
#endif
|
|
|
|
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifdef VERSION_EU
|
2020-03-02 03:42:52 +00:00
|
|
|
static void sequence_channel_process_sound(struct SequenceChannel *seqChannel, s32 recalculateVolume) {
|
|
|
|
f32 channelVolume;
|
2020-02-03 05:51:26 +00:00
|
|
|
s32 i;
|
|
|
|
|
2020-03-02 03:42:52 +00:00
|
|
|
if (seqChannel->changes.as_bitfields.volume || recalculateVolume) {
|
|
|
|
channelVolume = seqChannel->volume * seqChannel->volumeScale * seqChannel->seqPlayer->appliedFadeVolume;
|
2020-02-03 05:51:26 +00:00
|
|
|
if (seqChannel->seqPlayer->muted && (seqChannel->muteBehavior & MUTE_BEHAVIOR_SOFTEN) != 0) {
|
2020-03-02 03:42:52 +00:00
|
|
|
channelVolume = seqChannel->seqPlayer->muteVolumeScale * channelVolume;
|
2020-02-03 05:51:26 +00:00
|
|
|
}
|
2020-03-02 03:42:52 +00:00
|
|
|
seqChannel->appliedVolume = channelVolume;
|
2020-02-03 05:51:26 +00:00
|
|
|
}
|
|
|
|
|
2020-03-02 03:42:52 +00:00
|
|
|
if (seqChannel->changes.as_bitfields.pan) {
|
|
|
|
seqChannel->pan = seqChannel->newPan * seqChannel->panChannelWeight;
|
2020-02-03 05:51:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < 4; ++i) {
|
|
|
|
struct SequenceChannelLayer *layer = seqChannel->layers[i];
|
2020-03-02 03:42:52 +00:00
|
|
|
if (layer != NULL && layer->enabled && layer->note != NULL) {
|
|
|
|
if (layer->notePropertiesNeedInit) {
|
2020-02-03 05:51:26 +00:00
|
|
|
layer->noteFreqScale = layer->freqScale * seqChannel->freqScale;
|
2020-03-02 03:42:52 +00:00
|
|
|
layer->noteVelocity = layer->velocitySquare * seqChannel->appliedVolume;
|
|
|
|
layer->notePan = (seqChannel->pan + layer->pan * (0x80 - seqChannel->panChannelWeight)) >> 7;
|
|
|
|
layer->notePropertiesNeedInit = FALSE;
|
2020-02-03 05:51:26 +00:00
|
|
|
} else {
|
2020-03-02 03:42:52 +00:00
|
|
|
if (seqChannel->changes.as_bitfields.freqScale) {
|
2020-02-03 05:51:26 +00:00
|
|
|
layer->noteFreqScale = layer->freqScale * seqChannel->freqScale;
|
|
|
|
}
|
2020-03-02 03:42:52 +00:00
|
|
|
if (seqChannel->changes.as_bitfields.volume || recalculateVolume) {
|
|
|
|
layer->noteVelocity = layer->velocitySquare * seqChannel->appliedVolume;
|
2020-02-03 05:51:26 +00:00
|
|
|
}
|
2020-03-02 03:42:52 +00:00
|
|
|
if (seqChannel->changes.as_bitfields.pan) {
|
|
|
|
layer->notePan = (seqChannel->pan + layer->pan * (0x80 - seqChannel->panChannelWeight)) >> 7;
|
2020-02-03 05:51:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-03-02 03:42:52 +00:00
|
|
|
seqChannel->changes.as_u8 = 0;
|
2020-02-03 05:51:26 +00:00
|
|
|
}
|
|
|
|
#else
|
2020-03-02 03:42:52 +00:00
|
|
|
static void sequence_channel_process_sound(struct SequenceChannel *seqChannel) {
|
|
|
|
f32 channelVolume;
|
|
|
|
f32 panLayerWeight;
|
|
|
|
f32 panFromChannel;
|
|
|
|
s32 i;
|
|
|
|
|
|
|
|
channelVolume = seqChannel->volume * seqChannel->volumeScale * seqChannel->seqPlayer->fadeVolume;
|
|
|
|
if (seqChannel->seqPlayer->muted && (seqChannel->muteBehavior & MUTE_BEHAVIOR_SOFTEN) != 0) {
|
|
|
|
channelVolume *= seqChannel->seqPlayer->muteVolumeScale;
|
|
|
|
}
|
|
|
|
|
|
|
|
panFromChannel = seqChannel->pan * seqChannel->panChannelWeight;
|
|
|
|
panLayerWeight = US_FLOAT(1.0) - seqChannel->panChannelWeight;
|
|
|
|
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
struct SequenceChannelLayer *layer = seqChannel->layers[i];
|
|
|
|
if (layer != NULL && layer->enabled && layer->note != NULL) {
|
|
|
|
layer->noteFreqScale = layer->freqScale * seqChannel->freqScale;
|
|
|
|
layer->noteVelocity = layer->velocitySquare * channelVolume;
|
|
|
|
layer->notePan = (layer->pan * panLayerWeight) + panFromChannel;
|
|
|
|
}
|
|
|
|
}
|
2019-08-25 04:46:40 +00:00
|
|
|
}
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
|
|
|
|
void sequence_player_process_sound(struct SequencePlayer *seqPlayer) {
|
|
|
|
s32 i;
|
|
|
|
|
|
|
|
if (seqPlayer->fadeTimer != 0) {
|
|
|
|
seqPlayer->fadeVolume += seqPlayer->fadeVelocity;
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifdef VERSION_EU
|
2020-03-02 03:42:52 +00:00
|
|
|
seqPlayer->recalculateVolume = TRUE;
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
|
2019-09-01 19:50:50 +00:00
|
|
|
if (seqPlayer->fadeVolume > US_FLOAT2(1)) {
|
2019-08-25 04:46:40 +00:00
|
|
|
seqPlayer->fadeVolume = US_FLOAT2(1);
|
2019-09-01 19:50:50 +00:00
|
|
|
}
|
|
|
|
if (seqPlayer->fadeVolume < 0) {
|
2019-08-25 04:46:40 +00:00
|
|
|
seqPlayer->fadeVolume = 0;
|
2019-09-01 19:50:50 +00:00
|
|
|
}
|
2019-08-25 04:46:40 +00:00
|
|
|
|
|
|
|
if (--seqPlayer->fadeTimer == 0) {
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifdef VERSION_EU
|
|
|
|
if (seqPlayer->state == 2) {
|
|
|
|
sequence_player_disable(seqPlayer);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#else
|
2019-08-25 04:46:40 +00:00
|
|
|
switch (seqPlayer->state) {
|
|
|
|
case SEQUENCE_PLAYER_STATE_FADE_OUT:
|
|
|
|
sequence_player_disable(seqPlayer);
|
|
|
|
return;
|
|
|
|
|
|
|
|
case SEQUENCE_PLAYER_STATE_2:
|
|
|
|
case SEQUENCE_PLAYER_STATE_3:
|
|
|
|
seqPlayer->state = SEQUENCE_PLAYER_STATE_0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SEQUENCE_PLAYER_STATE_4:
|
|
|
|
break;
|
|
|
|
}
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifdef VERSION_EU
|
2020-03-02 03:42:52 +00:00
|
|
|
if (seqPlayer->recalculateVolume) {
|
|
|
|
seqPlayer->appliedFadeVolume = seqPlayer->fadeVolume * seqPlayer->fadeVolumeScale;
|
2020-02-03 05:51:26 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2019-08-25 04:46:40 +00:00
|
|
|
// Process channels
|
|
|
|
for (i = 0; i < CHANNELS_MAX; i++) {
|
|
|
|
if (IS_SEQUENCE_CHANNEL_VALID(seqPlayer->channels[i]) == TRUE
|
|
|
|
&& seqPlayer->channels[i]->enabled == TRUE) {
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifdef VERSION_EU
|
2020-03-02 03:42:52 +00:00
|
|
|
sequence_channel_process_sound(seqPlayer->channels[i], seqPlayer->recalculateVolume);
|
2020-02-03 05:51:26 +00:00
|
|
|
#else
|
2020-03-02 03:42:52 +00:00
|
|
|
sequence_channel_process_sound(seqPlayer->channels[i]);
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
}
|
|
|
|
}
|
2020-02-03 05:51:26 +00:00
|
|
|
|
|
|
|
#ifdef VERSION_EU
|
2020-03-02 03:42:52 +00:00
|
|
|
seqPlayer->recalculateVolume = FALSE;
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
f32 get_portamento_freq_scale(struct Portamento *p) {
|
|
|
|
u32 v0;
|
|
|
|
f32 result;
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifndef VERSION_EU
|
2019-09-01 19:50:50 +00:00
|
|
|
if (p->mode == 0) {
|
2019-08-25 04:46:40 +00:00
|
|
|
return 1.0f;
|
2019-09-01 19:50:50 +00:00
|
|
|
}
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
|
|
|
|
p->cur += p->speed;
|
|
|
|
v0 = (u32) p->cur;
|
|
|
|
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifdef VERSION_EU
|
|
|
|
if (v0 > 127)
|
|
|
|
#else
|
|
|
|
if (v0 >= 127)
|
|
|
|
#endif
|
|
|
|
{
|
2019-08-25 04:46:40 +00:00
|
|
|
v0 = 127;
|
2019-09-01 19:50:50 +00:00
|
|
|
}
|
2019-08-25 04:46:40 +00:00
|
|
|
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifdef VERSION_EU
|
|
|
|
result = US_FLOAT(1.0) + p->extent * (gPitchBendFrequencyScale[v0 + 128] - US_FLOAT(1.0));
|
|
|
|
#else
|
2019-08-25 04:46:40 +00:00
|
|
|
result = US_FLOAT(1.0) + p->extent * (gPitchBendFrequencyScale[v0 + 127] - US_FLOAT(1.0));
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifdef VERSION_EU
|
|
|
|
s16 get_vibrato_pitch_change(struct VibratoState *vib) {
|
|
|
|
s32 index;
|
|
|
|
vib->time += (s32) vib->rate;
|
|
|
|
index = (vib->time >> 10) & 0x3F;
|
|
|
|
return vib->curve[index] >> 8;
|
|
|
|
}
|
|
|
|
#else
|
2019-08-25 04:46:40 +00:00
|
|
|
s8 get_vibrato_pitch_change(struct VibratoState *vib) {
|
|
|
|
s32 index;
|
|
|
|
vib->time += vib->rate;
|
|
|
|
|
|
|
|
index = (vib->time >> 10) & 0x3F;
|
|
|
|
|
|
|
|
switch (index & 0x30) {
|
|
|
|
case 0x10:
|
|
|
|
index = 31 - index;
|
|
|
|
|
|
|
|
case 0x00:
|
|
|
|
return vib->curve[index];
|
|
|
|
|
|
|
|
case 0x20:
|
|
|
|
index -= 0x20;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x30:
|
|
|
|
index = 63 - index;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -vib->curve[index];
|
|
|
|
}
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
|
|
|
|
f32 get_vibrato_freq_scale(struct VibratoState *vib) {
|
2020-02-03 05:51:26 +00:00
|
|
|
s32 pitchChange;
|
2019-08-25 04:46:40 +00:00
|
|
|
f32 extent;
|
|
|
|
f32 result;
|
|
|
|
|
|
|
|
if (vib->delay != 0) {
|
|
|
|
vib->delay--;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (vib->extentChangeTimer) {
|
|
|
|
if (vib->extentChangeTimer == 1) {
|
2020-02-03 05:51:26 +00:00
|
|
|
vib->extent = (s32) vib->seqChannel->vibratoExtentTarget;
|
2019-08-25 04:46:40 +00:00
|
|
|
} else {
|
|
|
|
vib->extent +=
|
2020-02-03 05:51:26 +00:00
|
|
|
((s32) vib->seqChannel->vibratoExtentTarget - vib->extent) / (s32) vib->extentChangeTimer;
|
2019-08-25 04:46:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
vib->extentChangeTimer--;
|
2020-03-02 03:42:52 +00:00
|
|
|
} else if (vib->seqChannel->vibratoExtentTarget != (s32) vib->extent) {
|
2020-02-03 05:51:26 +00:00
|
|
|
if ((vib->extentChangeTimer = vib->seqChannel->vibratoExtentChangeDelay) == 0) {
|
|
|
|
vib->extent = (s32) vib->seqChannel->vibratoExtentTarget;
|
|
|
|
}
|
2019-08-25 04:46:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (vib->rateChangeTimer) {
|
|
|
|
if (vib->rateChangeTimer == 1) {
|
2020-02-03 05:51:26 +00:00
|
|
|
vib->rate = (s32) vib->seqChannel->vibratoRateTarget;
|
2019-08-25 04:46:40 +00:00
|
|
|
} else {
|
2020-02-03 05:51:26 +00:00
|
|
|
vib->rate += ((s32) vib->seqChannel->vibratoRateTarget - vib->rate) / (s32) vib->rateChangeTimer;
|
2019-08-25 04:46:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
vib->rateChangeTimer--;
|
2020-03-02 03:42:52 +00:00
|
|
|
} else if (vib->seqChannel->vibratoRateTarget != (s32) vib->rate) {
|
2020-02-03 05:51:26 +00:00
|
|
|
if ((vib->rateChangeTimer = vib->seqChannel->vibratoRateChangeDelay) == 0) {
|
|
|
|
vib->rate = (s32) vib->seqChannel->vibratoRateTarget;
|
2019-08-25 04:46:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (vib->extent == 0) {
|
|
|
|
return 1.0f;
|
|
|
|
}
|
|
|
|
|
|
|
|
pitchChange = get_vibrato_pitch_change(vib);
|
|
|
|
extent = (f32) vib->extent / US_FLOAT(4096.0);
|
|
|
|
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifdef VERSION_EU
|
|
|
|
result = US_FLOAT(1.0) + extent * (gPitchBendFrequencyScale[pitchChange + 128] - US_FLOAT(1.0));
|
|
|
|
#else
|
2019-08-25 04:46:40 +00:00
|
|
|
result = US_FLOAT(1.0) + extent * (gPitchBendFrequencyScale[pitchChange + 127] - US_FLOAT(1.0));
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
void note_vibrato_update(struct Note *note) {
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifdef VERSION_EU
|
|
|
|
if (note->portamento.mode != 0) {
|
|
|
|
note->portamentoFreqScale = get_portamento_freq_scale(¬e->portamento);
|
|
|
|
}
|
|
|
|
if (note->vibratoState.active && note->parentLayer != NO_LAYER) {
|
|
|
|
note->vibratoFreqScale = get_vibrato_freq_scale(¬e->vibratoState);
|
|
|
|
}
|
|
|
|
#else
|
2019-08-25 04:46:40 +00:00
|
|
|
if (note->vibratoState.active) {
|
|
|
|
note->portamentoFreqScale = get_portamento_freq_scale(¬e->portamento);
|
|
|
|
if (note->parentLayer != NO_LAYER) {
|
|
|
|
note->vibratoFreqScale = get_vibrato_freq_scale(¬e->vibratoState);
|
|
|
|
}
|
|
|
|
}
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void note_vibrato_init(struct Note *note) {
|
|
|
|
struct VibratoState *vib;
|
2020-02-03 05:51:26 +00:00
|
|
|
UNUSED struct SequenceChannel *seqChannel;
|
|
|
|
#ifdef VERSION_EU
|
|
|
|
struct NotePlaybackState *seqPlayerState = (struct NotePlaybackState *) ¬e->priority;
|
|
|
|
#endif
|
|
|
|
|
2019-08-25 04:46:40 +00:00
|
|
|
note->vibratoFreqScale = 1.0f;
|
|
|
|
note->portamentoFreqScale = 1.0f;
|
|
|
|
|
|
|
|
vib = ¬e->vibratoState;
|
|
|
|
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifndef VERSION_EU
|
2019-08-25 04:46:40 +00:00
|
|
|
if (note->parentLayer->seqChannel->vibratoExtentStart == 0
|
|
|
|
&& note->parentLayer->seqChannel->vibratoExtentTarget == 0
|
|
|
|
&& note->parentLayer->portamento.mode == 0) {
|
|
|
|
vib->active = FALSE;
|
|
|
|
return;
|
|
|
|
}
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
|
|
|
|
vib->active = TRUE;
|
|
|
|
vib->time = 0;
|
2020-02-03 05:51:26 +00:00
|
|
|
|
|
|
|
#ifdef VERSION_EU
|
|
|
|
vib->curve = gWaveSamples[2];
|
2019-08-25 04:46:40 +00:00
|
|
|
vib->seqChannel = note->parentLayer->seqChannel;
|
2020-02-03 05:51:26 +00:00
|
|
|
if ((vib->extentChangeTimer = vib->seqChannel->vibratoExtentChangeDelay) == 0) {
|
|
|
|
vib->extent = FLOAT_CAST(vib->seqChannel->vibratoExtentTarget);
|
|
|
|
} else {
|
|
|
|
vib->extent = FLOAT_CAST(vib->seqChannel->vibratoExtentStart);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((vib->rateChangeTimer = vib->seqChannel->vibratoRateChangeDelay) == 0) {
|
|
|
|
vib->rate = FLOAT_CAST(vib->seqChannel->vibratoRateTarget);
|
|
|
|
} else {
|
|
|
|
vib->rate = FLOAT_CAST(vib->seqChannel->vibratoRateStart);
|
|
|
|
}
|
|
|
|
vib->delay = vib->seqChannel->vibratoDelay;
|
2019-08-25 04:46:40 +00:00
|
|
|
|
2020-02-03 05:51:26 +00:00
|
|
|
seqPlayerState->portamento = seqPlayerState->parentLayer->portamento;
|
|
|
|
#else
|
|
|
|
vib->curve = gVibratoCurve;
|
|
|
|
vib->seqChannel = note->parentLayer->seqChannel;
|
2019-08-25 04:46:40 +00:00
|
|
|
seqChannel = vib->seqChannel;
|
|
|
|
|
2020-03-02 03:42:52 +00:00
|
|
|
if ((vib->extentChangeTimer = seqChannel->vibratoExtentChangeDelay) == 0) {
|
2019-08-25 04:46:40 +00:00
|
|
|
vib->extent = seqChannel->vibratoExtentTarget;
|
|
|
|
} else {
|
|
|
|
vib->extent = seqChannel->vibratoExtentStart;
|
|
|
|
}
|
|
|
|
|
2020-03-02 03:42:52 +00:00
|
|
|
if ((vib->rateChangeTimer = seqChannel->vibratoRateChangeDelay) == 0) {
|
2019-08-25 04:46:40 +00:00
|
|
|
vib->rate = seqChannel->vibratoRateTarget;
|
|
|
|
} else {
|
|
|
|
vib->rate = seqChannel->vibratoRateStart;
|
|
|
|
}
|
|
|
|
vib->delay = seqChannel->vibratoDelay;
|
2020-02-03 05:51:26 +00:00
|
|
|
|
2019-08-25 04:46:40 +00:00
|
|
|
note->portamento = note->parentLayer->portamento;
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
}
|
|
|
|
|
2020-02-03 05:51:26 +00:00
|
|
|
void adsr_init(struct AdsrState *adsr, struct AdsrEnvelope *envelope, UNUSED s16 *volOut) {
|
2019-08-25 04:46:40 +00:00
|
|
|
adsr->action = 0;
|
|
|
|
adsr->state = ADSR_STATE_DISABLED;
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifdef VERSION_EU
|
|
|
|
adsr->delay = 0;
|
|
|
|
adsr->envelope = envelope;
|
|
|
|
adsr->current = 0.0f;
|
|
|
|
#else
|
2019-08-25 04:46:40 +00:00
|
|
|
adsr->initial = 0;
|
|
|
|
adsr->delay = 0;
|
|
|
|
adsr->velocity = 0;
|
|
|
|
adsr->envelope = envelope;
|
|
|
|
adsr->volOut = volOut;
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
}
|
|
|
|
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifdef VERSION_EU
|
|
|
|
f32 adsr_update(struct AdsrState *adsr) {
|
|
|
|
#else
|
2019-08-25 04:46:40 +00:00
|
|
|
s32 adsr_update(struct AdsrState *adsr) {
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
u8 action = adsr->action;
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifdef VERSION_EU
|
|
|
|
u8 state = adsr->state;
|
|
|
|
switch (state) {
|
|
|
|
#else
|
2019-08-25 04:46:40 +00:00
|
|
|
switch (adsr->state) {
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
case ADSR_STATE_DISABLED:
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case ADSR_STATE_INITIAL: {
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifndef VERSION_EU
|
2019-08-25 04:46:40 +00:00
|
|
|
adsr->current = adsr->initial;
|
|
|
|
adsr->target = adsr->initial;
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
if (action & ADSR_ACTION_HANG) {
|
|
|
|
adsr->state = ADSR_STATE_HANG;
|
2020-02-03 05:51:26 +00:00
|
|
|
break;
|
2019-08-25 04:46:40 +00:00
|
|
|
}
|
|
|
|
// fallthrough
|
|
|
|
}
|
|
|
|
|
|
|
|
case ADSR_STATE_START_LOOP:
|
|
|
|
adsr->envIndex = 0;
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifndef VERSION_EU
|
2019-08-25 04:46:40 +00:00
|
|
|
adsr->currentHiRes = adsr->current << 0x10;
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
adsr->state = ADSR_STATE_LOOP;
|
|
|
|
// fallthrough
|
|
|
|
|
|
|
|
case ADSR_STATE_LOOP:
|
2019-12-02 02:52:53 +00:00
|
|
|
adsr->delay = BSWAP16(adsr->envelope[adsr->envIndex].delay);
|
2019-08-25 04:46:40 +00:00
|
|
|
switch (adsr->delay) {
|
|
|
|
case ADSR_DISABLE:
|
|
|
|
adsr->state = ADSR_STATE_DISABLED;
|
|
|
|
break;
|
|
|
|
case ADSR_HANG:
|
|
|
|
adsr->state = ADSR_STATE_HANG;
|
|
|
|
break;
|
|
|
|
case ADSR_GOTO:
|
2019-12-02 02:52:53 +00:00
|
|
|
adsr->envIndex = BSWAP16(adsr->envelope[adsr->envIndex].arg);
|
2019-08-25 04:46:40 +00:00
|
|
|
break;
|
|
|
|
case ADSR_RESTART:
|
|
|
|
adsr->state = ADSR_STATE_INITIAL;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifdef VERSION_EU
|
|
|
|
if (adsr->delay >= 4) {
|
|
|
|
adsr->delay = adsr->delay * gAudioBufferParameters.updatesPerFrame / 4;
|
|
|
|
}
|
|
|
|
adsr->target = (f32) BSWAP16(adsr->envelope[adsr->envIndex].arg) / 32767.0;
|
|
|
|
adsr->target = adsr->target * adsr->target;
|
|
|
|
adsr->velocity = (adsr->target - adsr->current) / adsr->delay;
|
|
|
|
#else
|
2019-12-02 02:52:53 +00:00
|
|
|
adsr->target = BSWAP16(adsr->envelope[adsr->envIndex].arg);
|
2019-08-25 04:46:40 +00:00
|
|
|
adsr->velocity = ((adsr->target - adsr->current) << 0x10) / adsr->delay;
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
adsr->state = ADSR_STATE_FADE;
|
|
|
|
adsr->envIndex++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (adsr->state != ADSR_STATE_FADE) {
|
2020-02-03 05:51:26 +00:00
|
|
|
break;
|
2019-08-25 04:46:40 +00:00
|
|
|
}
|
|
|
|
// fallthrough
|
|
|
|
|
|
|
|
case ADSR_STATE_FADE:
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifdef VERSION_EU
|
|
|
|
adsr->current += adsr->velocity;
|
|
|
|
#else
|
2019-08-25 04:46:40 +00:00
|
|
|
adsr->currentHiRes += adsr->velocity;
|
|
|
|
adsr->current = adsr->currentHiRes >> 0x10;
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
if (--adsr->delay <= 0) {
|
|
|
|
adsr->state = ADSR_STATE_LOOP;
|
|
|
|
}
|
|
|
|
// fallthrough
|
|
|
|
|
|
|
|
case ADSR_STATE_HANG:
|
2020-02-03 05:51:26 +00:00
|
|
|
break;
|
2019-08-25 04:46:40 +00:00
|
|
|
|
|
|
|
case ADSR_STATE_DECAY:
|
|
|
|
case ADSR_STATE_RELEASE: {
|
|
|
|
adsr->current -= adsr->fadeOutVel;
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifdef VERSION_EU
|
|
|
|
if (adsr->sustain != 0.0f && state == ADSR_STATE_DECAY) {
|
|
|
|
#else
|
2019-08-25 04:46:40 +00:00
|
|
|
if (adsr->sustain != 0 && adsr->state == ADSR_STATE_DECAY) {
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
if (adsr->current < adsr->sustain) {
|
|
|
|
adsr->current = adsr->sustain;
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifdef VERSION_EU
|
|
|
|
adsr->delay = 128;
|
|
|
|
#else
|
2019-08-25 04:46:40 +00:00
|
|
|
adsr->delay = adsr->sustain / 16;
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
adsr->state = ADSR_STATE_SUSTAIN;
|
|
|
|
}
|
2020-02-03 05:51:26 +00:00
|
|
|
break;
|
2019-08-25 04:46:40 +00:00
|
|
|
}
|
|
|
|
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifdef VERSION_EU
|
|
|
|
if (adsr->current < 0) {
|
|
|
|
adsr->current = 0.0f;
|
|
|
|
adsr->state = ADSR_STATE_DISABLED;
|
|
|
|
}
|
|
|
|
#else
|
2019-08-25 04:46:40 +00:00
|
|
|
if (adsr->current < 100) {
|
|
|
|
adsr->current = 0;
|
|
|
|
adsr->state = ADSR_STATE_DISABLED;
|
|
|
|
}
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
|
|
|
break;
|
2019-08-25 04:46:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
case ADSR_STATE_SUSTAIN:
|
|
|
|
adsr->delay -= 1;
|
|
|
|
if (adsr->delay == 0) {
|
|
|
|
adsr->state = ADSR_STATE_RELEASE;
|
|
|
|
}
|
2020-02-03 05:51:26 +00:00
|
|
|
break;
|
2019-08-25 04:46:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((action & ADSR_ACTION_DECAY)) {
|
|
|
|
adsr->state = ADSR_STATE_DECAY;
|
|
|
|
adsr->action = action & ~ADSR_ACTION_DECAY;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((action & ADSR_ACTION_RELEASE)) {
|
|
|
|
adsr->state = ADSR_STATE_RELEASE;
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifdef VERSION_EU
|
|
|
|
adsr->action = action & ~ADSR_ACTION_RELEASE;
|
|
|
|
#else
|
2019-08-25 04:46:40 +00:00
|
|
|
adsr->action = action & ~(ADSR_ACTION_RELEASE | ADSR_ACTION_DECAY);
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
}
|
|
|
|
|
2020-02-03 05:51:26 +00:00
|
|
|
#ifdef VERSION_EU
|
|
|
|
if (adsr->current < 0.0f) {
|
|
|
|
return 0.0f;
|
|
|
|
}
|
|
|
|
if (adsr->current > 1.0f) {
|
|
|
|
return 1.0f;
|
|
|
|
}
|
|
|
|
return adsr->current;
|
|
|
|
#else
|
2019-08-25 04:46:40 +00:00
|
|
|
*adsr->volOut = adsr->current;
|
|
|
|
return 0;
|
2020-02-03 05:51:26 +00:00
|
|
|
#endif
|
2019-08-25 04:46:40 +00:00
|
|
|
}
|