Reformat to something more readable for me :3

src/decomp/audio/effects.c

@@ -14,27 +14,30 @@
 f32 gTrackVolume = 1.0f;
 
 #if defined(VERSION_EU) || defined(VERSION_SH)
-void sequence_channel_process_sound(struct SequenceChannel *seqChannel, s32 recalculateVolume) {
+void sequence_channel_process_sound(struct SequenceChannel *seqChannel, s32 recalculateVolume)
+{
     f32 channelVolume;
     s32 i;
 
-    if (seqChannel->changes.as_bitfields.volume || recalculateVolume) {
+    if (seqChannel->changes.as_bitfields.volume || recalculateVolume)
+    {
         channelVolume = seqChannel->volume * seqChannel->volumeScale * seqChannel->seqPlayer->appliedFadeVolume;
-        if (seqChannel->seqPlayer->muted && (seqChannel->muteBehavior & MUTE_BEHAVIOR_SOFTEN) != 0) {
+        if (seqChannel->seqPlayer->muted && (seqChannel->muteBehavior & MUTE_BEHAVIOR_SOFTEN) != 0)
+        {
             channelVolume = seqChannel->seqPlayer->muteVolumeScale * channelVolume;
         }
 #ifdef VERSION_SH
-        seqChannel->appliedVolume = channelVolume * channelVolume;
+seqChannel->appliedVolume= channelVolume* channelVolume;
 #else
-        seqChannel->appliedVolume = channelVolume;
+seqChannel->appliedVolume= channelVolume;
 #endif
-    }
+}
 
     if (seqChannel->changes.as_bitfields.pan) {
         seqChannel->pan = seqChannel->newPan * seqChannel->panChannelWeight;
     }
 
-    for (i = 0; i < 4; ++i) {
+    for (i =0; i<4;++i) {
         struct SequenceChannelLayer *layer = seqChannel->layers[i];
         if (layer != NULL && layer->enabled && layer->note != NULL) {
             if (layer->notePropertiesNeedInit) {
@@ -55,58 +58,69 @@ void sequence_channel_process_sound(struct SequenceChannel *seqChannel, s32 reca
             }
         }
     }
-    seqChannel->changes.as_u8 = 0;
+seqChannel->changes.as_u8=0;
 }
 #else
-static void sequence_channel_process_sound(struct SequenceChannel *seqChannel) {
+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) {
+    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++) {
+    for (i = 0; i < 4; i++)
+    {
         struct SequenceChannelLayer *layer = seqChannel->layers[i];
-        if (layer != NULL && layer->enabled && layer->note != NULL) {
+        if (layer != NULL && layer->enabled && layer->note != NULL)
+        {
             layer->noteFreqScale = layer->freqScale * seqChannel->freqScale;
             layer->noteVelocity = layer->velocitySquare * (channelVolume * gTrackVolume);
-            layer->notePan = (layer->pan * panLayerWeight) + panFromChannel;
+            layer->notePan = layer->pan * panLayerWeight + panFromChannel;
         }
     }
 }
 #endif
 
-void sequence_player_process_sound(struct SequencePlayer *seqPlayer) {
+void sequence_player_process_sound(struct SequencePlayer *seqPlayer)
+{
     s32 i;
 
-    if (seqPlayer->fadeRemainingFrames != 0) {
+    if (seqPlayer->fadeRemainingFrames != 0)
+    {
         seqPlayer->fadeVolume += seqPlayer->fadeVelocity;
-#if defined(VERSION_EU) || defined(VERSION_SH)
+        #if defined(VERSION_EU) || defined(VERSION_SH)
         seqPlayer->recalculateVolume = TRUE;
-#endif
+        #endif
 
-        if (seqPlayer->fadeVolume > US_FLOAT2(1)) {
+        if (seqPlayer->fadeVolume > US_FLOAT2(1))
+        {
             seqPlayer->fadeVolume = US_FLOAT2(1);
         }
-        if (seqPlayer->fadeVolume < 0) {
+        if (seqPlayer->fadeVolume < 0)
+        {
             seqPlayer->fadeVolume = 0;
         }
 
-        if (--seqPlayer->fadeRemainingFrames == 0) {
-#if defined(VERSION_EU) || defined(VERSION_SH)
-            if (seqPlayer->state == 2) {
+        if (--seqPlayer->fadeRemainingFrames == 0)
+        {
+            #if defined(VERSION_EU) || defined(VERSION_SH)
+            if (seqPlayer->state == 2)
+            {
                 sequence_player_disable(seqPlayer);
                 return;
             }
-#else
-            switch (seqPlayer->state) {
+            #else
+            switch (seqPlayer->state)
+            {
                 case SEQUENCE_PLAYER_STATE_FADE_OUT:
                     sequence_player_disable(seqPlayer);
                     return;
@@ -119,77 +133,85 @@ void sequence_player_process_sound(struct SequencePlayer *seqPlayer) {
                 case SEQUENCE_PLAYER_STATE_4:
                     break;
             }
-#endif
+            #endif
         }
     }
 
-#if defined(VERSION_EU) || defined(VERSION_SH)
-    if (seqPlayer->recalculateVolume) {
+    #if defined(VERSION_EU) || defined(VERSION_SH)
+    if (seqPlayer->recalculateVolume)
+    {
         seqPlayer->appliedFadeVolume = seqPlayer->fadeVolume * seqPlayer->fadeVolumeScale;
     }
-#endif
+    #endif
 
     // Process channels
-    for (i = 0; i < CHANNELS_MAX; i++) {
+    for (i = 0; i < CHANNELS_MAX; i++)
+    {
         if (IS_SEQUENCE_CHANNEL_VALID(seqPlayer->channels[i]) == TRUE
-            && seqPlayer->channels[i]->enabled == TRUE) {
-#if defined(VERSION_EU) || defined(VERSION_SH)
+            && seqPlayer->channels[i]->enabled == TRUE)
+        {
+            #if defined(VERSION_EU) || defined(VERSION_SH)
             sequence_channel_process_sound(seqPlayer->channels[i], seqPlayer->recalculateVolume);
-#else
+            #else
             sequence_channel_process_sound(seqPlayer->channels[i]);
-#endif
+            #endif
         }
     }
 
-#if defined(VERSION_EU) || defined(VERSION_SH)
+    #if defined(VERSION_EU) || defined(VERSION_SH)
     seqPlayer->recalculateVolume = FALSE;
-#endif
+    #endif
 }
 
-f32 get_portamento_freq_scale(struct Portamento *p) {
+f32 get_portamento_freq_scale(struct Portamento *p)
+{
     u32 v0;
     f32 result;
-#if defined(VERSION_JP) || defined(VERSION_US)
-    if (p->mode == 0) {
+    #if defined(VERSION_JP) || defined(VERSION_US)
+    if (p->mode == 0)
+    {
         return 1.0f;
     }
-#endif
+    #endif
 
     p->cur += p->speed;
-    v0 = (u32) p->cur;
+    v0 = (u32)p->cur;
 
-#if defined(VERSION_EU) || defined(VERSION_SH)
+    #if defined(VERSION_EU) || defined(VERSION_SH)
     if (v0 > 127)
-#else
+    #else
     if (v0 >= 127)
-#endif
+    #endif
     {
         v0 = 127;
     }
 
-#if defined(VERSION_EU) || defined(VERSION_SH)
+    #if defined(VERSION_EU) || defined(VERSION_SH)
     result = US_FLOAT(1.0) + p->extent * (gPitchBendFrequencyScale[v0 + 128] - US_FLOAT(1.0));
-#else
+    #else
     result = US_FLOAT(1.0) + p->extent * (gPitchBendFrequencyScale[v0 + 127] - US_FLOAT(1.0));
-#endif
+    #endif
     return result;
 }
 
 #if defined(VERSION_EU) || defined(VERSION_SH)
-s16 get_vibrato_pitch_change(struct VibratoState *vib) {
+s16 get_vibrato_pitch_change(struct VibratoState *vib)
+{
     s32 index;
-    vib->time += (s32) vib->rate;
+    vib->time += (s32)vib->rate;
     index = (vib->time >> 10) & 0x3F;
     return vib->curve[index] >> 8;
 }
 #else
-s8 get_vibrato_pitch_change(struct VibratoState *vib) {
+s8 get_vibrato_pitch_change(struct VibratoState *vib)
+{
     s32 index;
     vib->time += vib->rate;
 
-    index = (vib->time >> 10) & 0x3F;
+    index = vib->time >> 10 & 0x3F;
 
-    switch (index & 0x30) {
+    switch (index & 0x30)
+    {
         case 0x10:
             index = 31 - index;
 
@@ -209,181 +231,226 @@ s8 get_vibrato_pitch_change(struct VibratoState *vib) {
 }
 #endif
 
-f32 get_vibrato_freq_scale(struct VibratoState *vib) {
+f32 get_vibrato_freq_scale(struct VibratoState *vib)
+{
     s32 pitchChange;
     f32 extent;
     f32 result;
 
-    if (vib->delay != 0) {
+    if (vib->delay != 0)
+    {
         vib->delay--;
         return 1;
     }
 
-    if (vib->extentChangeTimer) {
-        if (vib->extentChangeTimer == 1) {
-            vib->extent = (s32) vib->seqChannel->vibratoExtentTarget;
-        } else {
+    if (vib->extentChangeTimer)
+    {
+        if (vib->extentChangeTimer == 1)
+        {
+            vib->extent = (s32)vib->seqChannel->vibratoExtentTarget;
+        }
+        else
+        {
             vib->extent +=
-                ((s32) vib->seqChannel->vibratoExtentTarget - vib->extent) / (s32) vib->extentChangeTimer;
+                    ((s32)vib->seqChannel->vibratoExtentTarget - vib->extent) / (s32)vib->extentChangeTimer;
         }
 
         vib->extentChangeTimer--;
-    } else if (vib->seqChannel->vibratoExtentTarget != (s32) vib->extent) {
-        if ((vib->extentChangeTimer = vib->seqChannel->vibratoExtentChangeDelay) == 0) {
-            vib->extent = (s32) vib->seqChannel->vibratoExtentTarget;
+    }
+    else if (vib->seqChannel->vibratoExtentTarget != (s32)vib->extent)
+    {
+        if ((vib->extentChangeTimer = vib->seqChannel->vibratoExtentChangeDelay) == 0)
+        {
+            vib->extent = (s32)vib->seqChannel->vibratoExtentTarget;
         }
     }
 
-    if (vib->rateChangeTimer) {
-        if (vib->rateChangeTimer == 1) {
-            vib->rate = (s32) vib->seqChannel->vibratoRateTarget;
-        } else {
-            vib->rate += ((s32) vib->seqChannel->vibratoRateTarget - vib->rate) / (s32) vib->rateChangeTimer;
+    if (vib->rateChangeTimer)
+    {
+        if (vib->rateChangeTimer == 1)
+        {
+            vib->rate = (s32)vib->seqChannel->vibratoRateTarget;
+        }
+        else
+        {
+            vib->rate += ((s32)vib->seqChannel->vibratoRateTarget - vib->rate) / (s32)vib->rateChangeTimer;
         }
 
         vib->rateChangeTimer--;
-    } else if (vib->seqChannel->vibratoRateTarget != (s32) vib->rate) {
-        if ((vib->rateChangeTimer = vib->seqChannel->vibratoRateChangeDelay) == 0) {
-            vib->rate = (s32) vib->seqChannel->vibratoRateTarget;
+    }
+    else if (vib->seqChannel->vibratoRateTarget != (s32)vib->rate)
+    {
+        if ((vib->rateChangeTimer = vib->seqChannel->vibratoRateChangeDelay) == 0)
+        {
+            vib->rate = (s32)vib->seqChannel->vibratoRateTarget;
         }
     }
 
-    if (vib->extent == 0) {
+    if (vib->extent == 0)
+    {
         return 1.0f;
     }
 
     pitchChange = get_vibrato_pitch_change(vib);
-    extent = (f32) vib->extent / US_FLOAT(4096.0);
+    extent = (f32)vib->extent / US_FLOAT(4096.0);
 
-#if defined(VERSION_EU) || defined(VERSION_SH)
+    #if defined(VERSION_EU) || defined(VERSION_SH)
     result = US_FLOAT(1.0) + extent * (gPitchBendFrequencyScale[pitchChange + 128] - US_FLOAT(1.0));
-#else
+    #else
     result = US_FLOAT(1.0) + extent * (gPitchBendFrequencyScale[pitchChange + 127] - US_FLOAT(1.0));
-#endif
+    #endif
     return result;
 }
 
-void note_vibrato_update(struct Note *note) {
-#if defined(VERSION_EU) || defined(VERSION_SH)
-    if (note->portamento.mode != 0) {
+void note_vibrato_update(struct Note *note)
+{
+    #if defined(VERSION_EU) || defined(VERSION_SH)
+    if (note->portamento.mode != 0)
+    {
         note->portamentoFreqScale = get_portamento_freq_scale(&note->portamento);
     }
-    if (note->vibratoState.active && note->parentLayer != NO_LAYER) {
+    if (note->vibratoState.active && note->parentLayer != NO_LAYER)
+    {
         note->vibratoFreqScale = get_vibrato_freq_scale(&note->vibratoState);
     }
-#else
-    if (note->vibratoState.active) {
+    #else
+    if (note->vibratoState.active)
+    {
         note->portamentoFreqScale = get_portamento_freq_scale(&note->portamento);
-        if (note->parentLayer != NO_LAYER) {
+        if (note->parentLayer != NO_LAYER)
+        {
             note->vibratoFreqScale = get_vibrato_freq_scale(&note->vibratoState);
         }
     }
-#endif
+    #endif
 }
 
-void note_vibrato_init(struct Note *note) {
+void note_vibrato_init(struct Note *note)
+{
     struct VibratoState *vib;
-    UNUSED struct SequenceChannel *seqChannel;
-#if defined(VERSION_EU) || defined(VERSION_SH)
-    struct NotePlaybackState *seqPlayerState = (struct NotePlaybackState *) &note->priority;
-#endif
+    UNUSED
+    struct SequenceChannel *seqChannel;
+    #if defined(VERSION_EU) || defined(VERSION_SH)
+    struct NotePlaybackState *seqPlayerState = (struct NotePlaybackState *)&note->priority;
+    #endif
 
     note->vibratoFreqScale = 1.0f;
     note->portamentoFreqScale = 1.0f;
 
     vib = &note->vibratoState;
 
-#if defined(VERSION_JP) || defined(VERSION_US)
+    #if defined(VERSION_JP) || defined(VERSION_US)
     if (note->parentLayer->seqChannel->vibratoExtentStart == 0
         && note->parentLayer->seqChannel->vibratoExtentTarget == 0
-        && note->parentLayer->portamento.mode == 0) {
+        && note->parentLayer->portamento.mode == 0)
+    {
         vib->active = FALSE;
         return;
     }
-#endif
+    #endif
 
     vib->active = TRUE;
     vib->time = 0;
 
-#if defined(VERSION_EU) || defined(VERSION_SH)
+    #if defined(VERSION_EU) || defined(VERSION_SH)
     vib->curve = gWaveSamples[2];
     vib->seqChannel = note->parentLayer->seqChannel;
-    if ((vib->extentChangeTimer = vib->seqChannel->vibratoExtentChangeDelay) == 0) {
+    if ((vib->extentChangeTimer = vib->seqChannel->vibratoExtentChangeDelay) == 0)
+    {
         vib->extent = FLOAT_CAST(vib->seqChannel->vibratoExtentTarget);
-    } else {
+    }
+    else
+    {
         vib->extent = FLOAT_CAST(vib->seqChannel->vibratoExtentStart);
     }
 
-    if ((vib->rateChangeTimer = vib->seqChannel->vibratoRateChangeDelay) == 0) {
+    if ((vib->rateChangeTimer = vib->seqChannel->vibratoRateChangeDelay) == 0)
+    {
         vib->rate = FLOAT_CAST(vib->seqChannel->vibratoRateTarget);
-    } else {
+    }
+    else
+    {
         vib->rate = FLOAT_CAST(vib->seqChannel->vibratoRateStart);
     }
     vib->delay = vib->seqChannel->vibratoDelay;
 
     seqPlayerState->portamento = seqPlayerState->parentLayer->portamento;
-#else
+    #else
     vib->curve = gVibratoCurve;
     vib->seqChannel = note->parentLayer->seqChannel;
     seqChannel = vib->seqChannel;
 
-    if ((vib->extentChangeTimer = seqChannel->vibratoExtentChangeDelay) == 0) {
+    if ((vib->extentChangeTimer = seqChannel->vibratoExtentChangeDelay) == 0)
+    {
         vib->extent = seqChannel->vibratoExtentTarget;
-    } else {
+    }
+    else
+    {
         vib->extent = seqChannel->vibratoExtentStart;
     }
 
-    if ((vib->rateChangeTimer = seqChannel->vibratoRateChangeDelay) == 0) {
+    if ((vib->rateChangeTimer = seqChannel->vibratoRateChangeDelay) == 0)
+    {
         vib->rate = seqChannel->vibratoRateTarget;
-    } else {
+    }
+    else
+    {
         vib->rate = seqChannel->vibratoRateStart;
     }
     vib->delay = seqChannel->vibratoDelay;
 
     note->portamento = note->parentLayer->portamento;
-#endif
+    #endif
 }
 
-void adsr_init(struct AdsrState *adsr, struct AdsrEnvelope *envelope, UNUSED s16 *volOut) {
+void adsr_init(struct AdsrState *adsr, struct AdsrEnvelope *envelope, UNUSED s16 *volOut)
+{
     adsr->action = 0;
     adsr->state = ADSR_STATE_DISABLED;
-#if defined(VERSION_EU) || defined(VERSION_SH)
+    #if defined(VERSION_EU) || defined(VERSION_SH)
     adsr->delay = 0;
     adsr->envelope = envelope;
-#ifdef VERSION_SH
+    #ifdef VERSION_SH
     adsr->sustain = 0.0f;
-#endif
+    #endif
     adsr->current = 0.0f;
-#else
+    #else
     adsr->initial = 0;
     adsr->delay = 0;
     adsr->velocity = 0;
     adsr->envelope = envelope;
     adsr->volOut = volOut;
-#endif
+    #endif
 }
 
 #if defined(VERSION_EU) || defined(VERSION_SH)
-f32 adsr_update(struct AdsrState *adsr) {
+f32 adsr_update(struct AdsrState *adsr)
+{
+
+
 #else
-s32 adsr_update(struct AdsrState *adsr) {
-#endif
+s32 adsr_update(struct AdsrState *adsr)
+{
+    #endif
     u8 action = adsr->action;
-#if defined(VERSION_EU) || defined(VERSION_SH)
+    #if defined(VERSION_EU) || defined(VERSION_SH)
     u8 state = adsr->state;
     switch (state) {
-#else
-    switch (adsr->state) {
-#endif
+    #else
+    switch (adsr->state)
+    {
+            #endif
         case ADSR_STATE_DISABLED:
             return 0;
 
-        case ADSR_STATE_INITIAL: {
-#if defined(VERSION_JP) || defined(VERSION_US)
+        case ADSR_STATE_INITIAL:
+        {
+            #if defined(VERSION_JP) || defined(VERSION_US)
             adsr->current = adsr->initial;
             adsr->target = adsr->initial;
-#endif
-            if (action & ADSR_ACTION_HANG) {
+            #endif
+            if (action & ADSR_ACTION_HANG)
+            {
                 adsr->state = ADSR_STATE_HANG;
                 break;
             }
@@ -392,18 +459,19 @@ s32 adsr_update(struct AdsrState *adsr) {
 
         case ADSR_STATE_START_LOOP:
             adsr->envIndex = 0;
-#if defined(VERSION_JP) || defined(VERSION_US)
+            #if defined(VERSION_JP) || defined(VERSION_US)
             adsr->currentHiRes = adsr->current << 0x10;
-#endif
+            #endif
             adsr->state = ADSR_STATE_LOOP;
             // fallthrough
 
-#ifdef VERSION_SH
-            restart:
-#endif
+            #ifdef VERSION_SH
+        restart:
+            #endif
         case ADSR_STATE_LOOP:
             adsr->delay = BSWAP16(adsr->envelope[adsr->envIndex].delay);
-            switch (adsr->delay) {
+            switch (adsr->delay)
+            {
                 case ADSR_DISABLE:
                     adsr->state = ADSR_STATE_DISABLED;
                     break;
@@ -412,134 +480,149 @@ s32 adsr_update(struct AdsrState *adsr) {
                     break;
                 case ADSR_GOTO:
                     adsr->envIndex = BSWAP16(adsr->envelope[adsr->envIndex].arg);
-#ifdef VERSION_SH
+                    #ifdef VERSION_SH
                     goto restart;
-#else
+                    #else
                     break;
-#endif
+                    #endif
                 case ADSR_RESTART:
                     adsr->state = ADSR_STATE_INITIAL;
                     break;
 
                 default:
-#if defined(VERSION_EU) || defined(VERSION_SH)
-                    if (adsr->delay >= 4) {
+                    #if defined(VERSION_EU) || defined(VERSION_SH)
+                    if (adsr->delay >= 4)
+                    {
                         adsr->delay = adsr->delay * gAudioBufferParameters.updatesPerFrame
-#ifdef VERSION_SH
+                    #ifdef VERSION_SH
                         / gAudioBufferParameters.presetUnk4
-#endif
+                    #endif
                         / 4;
                     }
-#if defined(VERSION_SH)
-                    if (adsr->delay == 0) {
+                    #if defined(VERSION_SH)
+                    if (adsr->delay == 0)
+                    {
                         adsr->delay = 1;
                     }
-                    adsr->target = (f32) BSWAP16(adsr->envelope[adsr->envIndex].arg) / 32767.0f;
-#elif defined(VERSION_EU)
-                    adsr->target = (f32) BSWAP16(adsr->envelope[adsr->envIndex].arg) / 32767.0;
-#endif
+                    adsr->target = (f32)BSWAP16(adsr->envelope[adsr->envIndex].arg) / 32767.0f;
+                    #elif defined(VERSION_EU)
+                    adsr->target = (f32)BSWAP16(adsr->envelope[adsr->envIndex].arg) / 32767.0;
+                    #endif
                     adsr->target = adsr->target * adsr->target;
                     adsr->velocity = (adsr->target - adsr->current) / adsr->delay;
-#else
+                    #else
                     adsr->target = BSWAP16(adsr->envelope[adsr->envIndex].arg);
                     adsr->velocity = ((adsr->target - adsr->current) << 0x10) / adsr->delay;
-#endif
+                    #endif
                     adsr->state = ADSR_STATE_FADE;
                     adsr->envIndex++;
                     break;
             }
-            if (adsr->state != ADSR_STATE_FADE) {
+            if (adsr->state != ADSR_STATE_FADE)
+            {
                 break;
             }
-            // fallthrough
+        // fallthrough
 
         case ADSR_STATE_FADE:
-#if defined(VERSION_EU) || defined(VERSION_SH)
+            #if defined(VERSION_EU) || defined(VERSION_SH)
             adsr->current += adsr->velocity;
-#else
+            #else
             adsr->currentHiRes += adsr->velocity;
             adsr->current = adsr->currentHiRes >> 0x10;
-#endif
-            if (--adsr->delay <= 0) {
+            #endif
+            if (--adsr->delay <= 0)
+            {
                 adsr->state = ADSR_STATE_LOOP;
             }
-            // fallthrough
+        // fallthrough
 
         case ADSR_STATE_HANG:
             break;
 
         case ADSR_STATE_DECAY:
-        case ADSR_STATE_RELEASE: {
+        case ADSR_STATE_RELEASE:
+        {
             adsr->current -= adsr->fadeOutVel;
-#if defined(VERSION_EU) || defined(VERSION_SH)
+            #if defined(VERSION_EU) || defined(VERSION_SH)
             if (adsr->sustain != 0.0f && state == ADSR_STATE_DECAY) {
-#else
-            if (adsr->sustain != 0 && adsr->state == ADSR_STATE_DECAY) {
-#endif
-                if (adsr->current < adsr->sustain) {
+            #else
+            if (adsr->sustain != 0 && adsr->state == ADSR_STATE_DECAY)
+            {
+                #endif
+                if (adsr->current < adsr->sustain)
+                {
                     adsr->current = adsr->sustain;
-#if defined(VERSION_EU) || defined(VERSION_SH)
+                    #if defined(VERSION_EU) || defined(VERSION_SH)
                     adsr->delay = 128;
-#else
+                    #else
                     adsr->delay = adsr->sustain / 16;
-#endif
+                    #endif
                     adsr->state = ADSR_STATE_SUSTAIN;
                 }
                 break;
             }
 
-#if defined(VERSION_SH)
-            if (adsr->current < 0.00001f) {
+            #if defined(VERSION_SH)
+            if (adsr->current < 0.00001f)
+            {
                 adsr->current = 0.0f;
                 adsr->state = ADSR_STATE_DISABLED;
             }
-#elif defined(VERSION_EU)
-            if (adsr->current < 0) {
+            #elif defined(VERSION_EU)
+            if (adsr->current < 0)
+            {
                 adsr->current = 0.0f;
                 adsr->state = ADSR_STATE_DISABLED;
             }
-#else
-            if (adsr->current < 100) {
+            #else
+            if (adsr->current < 100)
+            {
                 adsr->current = 0;
                 adsr->state = ADSR_STATE_DISABLED;
             }
-#endif
+            #endif
             break;
         }
 
         case ADSR_STATE_SUSTAIN:
             adsr->delay -= 1;
-            if (adsr->delay == 0) {
+            if (adsr->delay == 0)
+            {
                 adsr->state = ADSR_STATE_RELEASE;
             }
             break;
     }
 
-    if ((action & ADSR_ACTION_DECAY)) {
+    if (action & ADSR_ACTION_DECAY)
+    {
         adsr->state = ADSR_STATE_DECAY;
         adsr->action = action & ~ADSR_ACTION_DECAY;
     }
 
-    if ((action & ADSR_ACTION_RELEASE)) {
+    if (action & ADSR_ACTION_RELEASE)
+    {
         adsr->state = ADSR_STATE_RELEASE;
-#if defined(VERSION_EU) || defined(VERSION_SH)
+        #if defined(VERSION_EU) || defined(VERSION_SH)
         adsr->action = action & ~ADSR_ACTION_RELEASE;
-#else
+        #else
         adsr->action = action & ~(ADSR_ACTION_RELEASE | ADSR_ACTION_DECAY);
-#endif
+        #endif
     }
 
-#if defined(VERSION_EU) || defined(VERSION_SH)
-    if (adsr->current < 0.0f) {
+    #if defined(VERSION_EU) || defined(VERSION_SH)
+    if (adsr->current < 0.0f)
+    {
         return 0.0f;
     }
-    if (adsr->current > 1.0f) {
+    if (adsr->current > 1.0f)
+    {
         eu_stubbed_printf_1("Audio:Envp: overflow  %f\n", adsr->current);
         return 1.0f;
     }
     return adsr->current;
-#else
+    #else
     *adsr->volOut = adsr->current;
     return 0;
-#endif
+    #endif
 }