arm7: run clang-format on SND_*

1 files changed, 600 insertions, 446 deletions

diff --git a/arm7/lib/src/SND_seq.c b/arm7/lib/src/SND_seq.c
index 76664fdd..e16ca9be 100644
--- a/arm7/lib/src/SND_seq.c
+++ b/arm7/lib/src/SND_seq.c
@@ -1,11 +1,11 @@
 #include "SND_seq.h"
 
+#include "SND_bank.h"
+#include "SND_exChannel.h"
+#include "SND_lfo.h"
 #include "SND_main.h"
-#include "SND_work.h"
 #include "SND_util.h"
-#include "SND_lfo.h"
-#include "SND_exChannel.h"
-#include "SND_bank.h"
+#include "SND_work.h"
 
 #define SND_TIMER_RATE 240
 
@@ -14,23 +14,27 @@
 #define SND_TRACK_MUTE_MODE_MUTE_RELEASE 2
 #define SND_TRACK_MUTE_MODE_MUTE_STOP 3
 
-enum SNDSeqProc {
+enum SNDSeqProc
+{
     SND_PROC_SKIP_NOTES = 0,
     SND_PROC_PLAY_NOTES = 1,
 };
 
-enum SNDSeqVal {
-    SND_SEQ_VAL_U8  = 0,
+enum SNDSeqVal
+{
+    SND_SEQ_VAL_U8 = 0,
     SND_SEQ_VAL_U16 = 1,
     SND_SEQ_VAL_VLV = 2,
     SND_SEQ_VAL_RAN = 3,
     SND_SEQ_VAL_VAR = 4,
 };
 
-static struct {
+static struct
+{
     const u8 *begin;
     const u8 *end;
-    union {
+    union
+    {
         u8 buf[16];
         u32 buf32[4];
     };
@@ -55,33 +59,39 @@ static void TrackMute(struct SNDTrack *track, struct SNDPlayer *player, int mute
 static s16 *PlayerGetVariablePointer(const struct SNDPlayer *player, int var);
 static void TrackUpdateChannel(struct SNDTrack *track, struct SNDPlayer *player, int release);
 
-void SND_SeqInit(void) {
-    for (int i = 0; i < SND_PLAYER_COUNT; i++) {
+void SND_SeqInit(void)
+{
+    for (int i = 0; i < SND_PLAYER_COUNT; i++)
+    {
         struct SNDPlayer *ply = &SNDi_Work.players[i];
 
         ply->flags.active = FALSE;
         ply->playerId = (u8)i;
     }
 
-    for (int i = 0; i < SND_TRACK_COUNT; i++) {
+    for (int i = 0; i < SND_TRACK_COUNT; i++)
+    {
         struct SNDTrack *trk = &SNDi_Work.tracks[i];
 
         trk->flags.active = FALSE;
     }
 }
 
-void SND_SeqMain(BOOL step) {
+void SND_SeqMain(BOOL step)
+{
     struct SNDPlayer *ply;
     int i;
     u32 playerStatus = 0;
 
-    for (i = 0; i < SND_PLAYER_COUNT; i++) {
+    for (i = 0; i < SND_PLAYER_COUNT; i++)
+    {
         ply = &SNDi_Work.players[i];
 
         if (!ply->flags.active)
             continue;
-        
-        if (ply->flags.prepared) {
+
+        if (ply->flags.prepared)
+        {
             if (step && !ply->flags.paused)
                 PlayerSeqMain(ply);
             PlayerUpdateChannel(ply);
@@ -95,19 +105,20 @@ void SND_SeqMain(BOOL step) {
         SNDi_SharedWork->playerStatus = playerStatus;
 }
 
-void SND_PrepareSeq(int player, const void *seq, u32 offset, struct SNDBankData *bankData) {
+void SND_PrepareSeq(int player, const void *seq, u32 offset, struct SNDBankData *bankData)
+{
     struct SNDPlayer *ply = &SNDi_Work.players[player];
 
     if (ply->flags.active)
         PlayerStop(ply);
-    
+
     PlayerInit(ply, bankData);
 
     int allocTrkIdx = AllocateTrack();
 
     if (allocTrkIdx < 0)
         return;
-    
+
     struct SNDTrack *trk = &SNDi_Work.tracks[allocTrkIdx];
     TrackInit(trk);
     TrackStart(trk, seq, offset);
@@ -118,14 +129,20 @@ void SND_PrepareSeq(int player, const void *seq, u32 offset, struct SNDBankData
 
     trk->cur++;
 
-    if (cmd != 0xFE) {
+    if (cmd != 0xFE)
+    {
         trk->cur--;
-    } else {
+    }
+    else
+    {
         int track;
         u16 trackMask;
 
-        for (trackMask = (u16)(TrackReadU16(trk) >> 1), track = 1; trackMask != 0; track++, trackMask >>= 1) {
-            if (trackMask & 1) {
+        for (trackMask = (u16)(TrackReadU16(trk) >> 1), track = 1; trackMask != 0;
+             track++, trackMask >>= 1)
+        {
+            if (trackMask & 1)
+            {
                 allocTrkIdx = AllocateTrack();
                 if (allocTrkIdx < 0)
                     break;
@@ -138,42 +155,52 @@ void SND_PrepareSeq(int player, const void *seq, u32 offset, struct SNDBankData
     ply->flags.active = TRUE;
     ply->flags.prepared = FALSE;
 
-    if (SNDi_SharedWork) {
+    if (SNDi_SharedWork)
+    {
         SNDi_SharedWork->playerStatus |= 1 << player;
     }
 }
 
-void SND_StartPreparedSeq(int player) {
+void SND_StartPreparedSeq(int player)
+{
     SNDi_Work.players[player].flags.prepared = TRUE;
 }
 
-void SND_StartSeq(int player, const void *seq, u32 offset, struct SNDBankData *bankData) {
+void SND_StartSeq(int player, const void *seq, u32 offset, struct SNDBankData *bankData)
+{
     SND_PrepareSeq(player, seq, offset, bankData);
     SND_StartPreparedSeq(player);
 }
 
-void SND_StopSeq(int player) {
+void SND_StopSeq(int player)
+{
     struct SNDPlayer *ply = &SNDi_Work.players[player];
 
-    if (ply->flags.active) {
+    if (ply->flags.active)
+    {
         PlayerStop(ply);
 
-        if (SNDi_SharedWork) {
+        if (SNDi_SharedWork)
+        {
             SNDi_SharedWork->playerStatus &= ~(1 << player);
         }
     }
 }
 
-void SND_PauseSeq(int player, BOOL flag) {
+void SND_PauseSeq(int player, BOOL flag)
+{
     struct SNDPlayer *ply = &SNDi_Work.players[player];
 
     ply->flags.paused = flag;
 
-    if (flag) {
-        for (int i = 0; i < SND_TRACK_COUNT_PER_PLAYER; i++) {
+    if (flag)
+    {
+        for (int i = 0; i < SND_TRACK_COUNT_PER_PLAYER; i++)
+        {
             struct SNDTrack *trk = PlayerGetTrack(ply, i);
 
-            if (trk) {
+            if (trk)
+            {
                 TrackReleaseChannels(trk, ply, 127);
                 TrackFreeChannels(trk);
             }
@@ -181,13 +208,16 @@ void SND_PauseSeq(int player, BOOL flag) {
     }
 }
 
-void SND_SkipSeq(int player, u32 ticks) {
+void SND_SkipSeq(int player, u32 ticks)
+{
     struct SNDPlayer *ply = &SNDi_Work.players[player];
 
-    for (int i = 0; i < SND_TRACK_COUNT_PER_PLAYER; i++) {
+    for (int i = 0; i < SND_TRACK_COUNT_PER_PLAYER; i++)
+    {
         struct SNDTrack *trk = PlayerGetTrack(ply, i);
 
-        if (trk) {
+        if (trk)
+        {
             TrackReleaseChannels(trk, ply, 127);
             TrackFreeChannels(trk);
         }
@@ -196,8 +226,10 @@ void SND_SkipSeq(int player, u32 ticks) {
     SND_StopIntervalTimer();
 
     u32 i;
-    for (i = 0; i < ticks; i++) {
-        if (PlayerStepTicks(ply, 0)) {
+    for (i = 0; i < ticks; i++)
+    {
+        if (PlayerStepTicks(ply, 0))
+        {
             PlayerStop(ply);
             break;
         }
@@ -205,33 +237,42 @@ void SND_SkipSeq(int player, u32 ticks) {
 
     SND_StartIntervalTimer();
 
-    if (SNDi_SharedWork) {
+    if (SNDi_SharedWork)
+    {
         SNDi_SharedWork->players[ply->playerId].tickCounter += i;
     }
 }
 
-void SND_SetTrackMute(int player, u32 trackMask, int muteMode) {
+void SND_SetTrackMute(int player, u32 trackMask, int muteMode)
+{
     struct SNDPlayer *ply = &SNDi_Work.players[player];
 
-    for (int i = 0; i < SND_TRACK_COUNT_PER_PLAYER && trackMask != 0; i++, trackMask >>= 1) {
-        if (trackMask & 1) {
+    for (int i = 0; i < SND_TRACK_COUNT_PER_PLAYER && trackMask != 0; i++, trackMask >>= 1)
+    {
+        if (trackMask & 1)
+        {
             struct SNDTrack *trk = PlayerGetTrack(ply, i);
-            
-            if (trk) {
+
+            if (trk)
+            {
                 TrackMute(trk, ply, muteMode);
             }
         }
     }
 }
 
-void SND_SetTrackAllocatableChannel(int player, u32 trackMask, u32 channelMask) {
+void SND_SetTrackAllocatableChannel(int player, u32 trackMask, u32 channelMask)
+{
     struct SNDPlayer *ply = &SNDi_Work.players[player];
 
-    for (int i = 0; i < SND_TRACK_COUNT_PER_PLAYER && trackMask != 0; i++, trackMask >>= 1) {
-        if (trackMask & 1) {
+    for (int i = 0; i < SND_TRACK_COUNT_PER_PLAYER && trackMask != 0; i++, trackMask >>= 1)
+    {
+        if (trackMask & 1)
+        {
             struct SNDTrack *trk = PlayerGetTrack(ply, i);
 
-            if (trk) {
+            if (trk)
+            {
                 trk->channelMask = (u16)channelMask;
                 trk->flags.channelMask = TRUE;
             }
@@ -239,25 +280,29 @@ void SND_SetTrackAllocatableChannel(int player, u32 trackMask, u32 channelMask)
     }
 }
 
-void SND_InvalidateSeq(const void *start, const void *end) {
+void SND_InvalidateSeq(const void *start, const void *end)
+{
     struct SNDPlayer *ply;
     struct SNDTrack *trk;
     int i;
     int j;
 
-    for (i = 0; i < SND_PLAYER_COUNT; i++) {
+    for (i = 0; i < SND_PLAYER_COUNT; i++)
+    {
         ply = &SNDi_Work.players[i];
 
         if (!ply->flags.active)
             continue;
-        
-        for (j = 0; j < SND_TRACK_COUNT_PER_PLAYER; j++) {
+
+        for (j = 0; j < SND_TRACK_COUNT_PER_PLAYER; j++)
+        {
             trk = PlayerGetTrack(ply, j);
 
             if (!trk)
                 continue;
-            
-            if (start <= trk->cur && trk->cur <= end) {
+
+            if (start <= trk->cur && trk->cur <= end)
+            {
                 PlayerStop(ply);
                 break;
             }
@@ -265,8 +310,10 @@ void SND_InvalidateSeq(const void *start, const void *end) {
     }
 }
 
-void SND_InvalidateBank(const void *start, const void *end) {
-    for (int i = 0; i < SND_PLAYER_COUNT; i++) {
+void SND_InvalidateBank(const void *start, const void *end)
+{
+    for (int i = 0; i < SND_PLAYER_COUNT; i++)
+    {
         struct SNDPlayer *ply = &SNDi_Work.players[i];
 
         if (ply->flags.active && start <= ply->bank && ply->bank <= end)
@@ -274,49 +321,55 @@ void SND_InvalidateBank(const void *start, const void *end) {
     }
 }
 
-void SNDi_SetPlayerParam(int player, u32 offset, u32 data, int size) {
+void SNDi_SetPlayerParam(int player, u32 offset, u32 data, int size)
+{
     struct SNDPlayer *ply = &SNDi_Work.players[player];
 
-    switch (size) {
-    case 1:
-        *(u8 *)((u8 *)ply + offset) = (u8)data;
-        break;
-    case 2:
-        *(u16 *)((u8 *)ply + offset) = (u16)data;
-        break;
-    case 4:
-        *(u32 *)((u8 *)ply + offset) = (u32)data;
-        break;
+    switch (size)
+    {
+        case 1:
+            *(u8 *)((u8 *)ply + offset) = (u8)data;
+            break;
+        case 2:
+            *(u16 *)((u8 *)ply + offset) = (u16)data;
+            break;
+        case 4:
+            *(u32 *)((u8 *)ply + offset) = (u32)data;
+            break;
     }
 }
 
-void SNDi_SetTrackParam(int player, u32 trackMask, u32 offset, u32 data, int size) {
+void SNDi_SetTrackParam(int player, u32 trackMask, u32 offset, u32 data, int size)
+{
     struct SNDPlayer *ply = &SNDi_Work.players[player];
 
-    for (int i = 0; i < SND_TRACK_COUNT_PER_PLAYER && trackMask != 0; i++, trackMask >>= 1) {
+    for (int i = 0; i < SND_TRACK_COUNT_PER_PLAYER && trackMask != 0; i++, trackMask >>= 1)
+    {
         if (!(trackMask & 1))
             continue;
-        
+
         struct SNDTrack *trk = PlayerGetTrack(ply, i);
 
         if (!trk)
             continue;
 
-        switch (size) {
-        case 1:
-            *(u8 *)((u8 *)trk + offset) = (u8)data;
-            break;
-        case 2:
-            *(u16 *)((u8 *)trk + offset) = (u16)data;
-            break;
-        case 4:
-            *(u32 *)((u8 *)trk + offset) = (u32)data;
-            break;
+        switch (size)
+        {
+            case 1:
+                *(u8 *)((u8 *)trk + offset) = (u8)data;
+                break;
+            case 2:
+                *(u16 *)((u8 *)trk + offset) = (u16)data;
+                break;
+            case 4:
+                *(u32 *)((u8 *)trk + offset) = (u32)data;
+                break;
         }
     }
 }
 
-static void SeqCacheFetch(const u8 *addr) {
+static void SeqCacheFetch(const u8 *addr)
+{
     addr = (const u8 *)((u32)addr & ~3);
     sSeqCache.begin = addr;
     sSeqCache.end = sSeqCache.begin + 16;
@@ -329,20 +382,23 @@ static void SeqCacheFetch(const u8 *addr) {
     sSeqCache.buf32[3] = src[3];
 }
 
-static u8 SeqReadByte(const u8 *addr) {
+static u8 SeqReadByte(const u8 *addr)
+{
     if (addr < sSeqCache.begin || addr >= sSeqCache.end)
         SeqCacheFetch(addr);
-    
+
     return sSeqCache.buf[(u32)addr - (u32)sSeqCache.begin];
 }
 
-static inline u8 TrackReadU8(struct SNDTrack *track) {
+static inline u8 TrackReadU8(struct SNDTrack *track)
+{
     u8 retval = SeqReadByte(track->cur);
     track->cur++;
     return retval;
 }
 
-static u16 TrackReadU16(struct SNDTrack *track) {
+static u16 TrackReadU16(struct SNDTrack *track)
+{
     int retval;
 
     retval = TrackReadU8(track);
@@ -351,7 +407,8 @@ static u16 TrackReadU16(struct SNDTrack *track) {
     return (u16)retval;
 }
 
-static u32 TrackReadU24(struct SNDTrack *track) {
+static u32 TrackReadU24(struct SNDTrack *track)
+{
     u32 retval;
 
     retval = TrackReadU8(track);
@@ -361,19 +418,22 @@ static u32 TrackReadU24(struct SNDTrack *track) {
     return retval;
 }
 
-static int TrackReadVLV(struct SNDTrack *track) {
+static int TrackReadVLV(struct SNDTrack *track)
+{
     int retval = 0;
     int b;
 
-    do {
+    do
+    {
         b = TrackReadU8(track);
         retval = (retval << 7) | (b & 0x7F);
-    } while(b & 0x80);
+    } while (b & 0x80);
 
     return retval;
 }
 
-static int TrackParseValue(struct SNDTrack *track, struct SNDPlayer *player, int valueType) {
+static int TrackParseValue(struct SNDTrack *track, struct SNDPlayer *player, int valueType)
+{
     int retval;
     int hi;
     int lo;
@@ -382,36 +442,38 @@ static int TrackParseValue(struct SNDTrack *track, struct SNDPlayer *player, int
 
     // BUG: undefined behavior if invalid valueType is passed (uninitialized return value)
 
-    switch (valueType) {
-    case SND_SEQ_VAL_U8:
-        retval = TrackReadU8(track);
-        break;
-    case SND_SEQ_VAL_U16:
-        retval = TrackReadU16(track);
-        break;
-    case SND_SEQ_VAL_VLV:
-        retval = TrackReadVLV(track);
-        break;
-    case SND_SEQ_VAL_VAR:
-        var = PlayerGetVariablePointer(player, TrackReadU8(track));
-        if (var)
-            retval = *var;
-        break;
-    case SND_SEQ_VAL_RAN:
-        lo = TrackReadU16(track) << 16;
-        hi = (s16)TrackReadU16(track);
-        ran = SND_CalcRandom();
-        retval = hi - (lo >> 16);
-        retval += 1;
-        retval = (ran * retval) >> 16;
-        retval += lo >> 16;
-        break;
+    switch (valueType)
+    {
+        case SND_SEQ_VAL_U8:
+            retval = TrackReadU8(track);
+            break;
+        case SND_SEQ_VAL_U16:
+            retval = TrackReadU16(track);
+            break;
+        case SND_SEQ_VAL_VLV:
+            retval = TrackReadVLV(track);
+            break;
+        case SND_SEQ_VAL_VAR:
+            var = PlayerGetVariablePointer(player, TrackReadU8(track));
+            if (var)
+                retval = *var;
+            break;
+        case SND_SEQ_VAL_RAN:
+            lo = TrackReadU16(track) << 16;
+            hi = (s16)TrackReadU16(track);
+            ran = SND_CalcRandom();
+            retval = hi - (lo >> 16);
+            retval += 1;
+            retval = (ran * retval) >> 16;
+            retval += lo >> 16;
+            break;
     }
-    
+
     return retval;
 }
 
-static void TrackInit(struct SNDTrack *track) {
+static void TrackInit(struct SNDTrack *track)
+{
     track->base = NULL;
     track->cur = NULL;
 
@@ -449,12 +511,14 @@ static void TrackInit(struct SNDTrack *track) {
     track->channelLLHead = NULL;
 }
 
-static void TrackStart(struct SNDTrack *track, const void *seq, u32 offset) {
+static void TrackStart(struct SNDTrack *track, const void *seq, u32 offset)
+{
     track->base = (const u8 *)seq;
     track->cur = &track->base[offset];
 }
 
-static void PlayerInit(struct SNDPlayer *player, struct SNDBankData *bank) {
+static void PlayerInit(struct SNDPlayer *player, struct SNDBankData *bank)
+{
     player->flags.paused = FALSE;
     player->bank = bank;
     player->tempo = 120;
@@ -464,24 +528,30 @@ static void PlayerInit(struct SNDPlayer *player, struct SNDBankData *bank) {
     player->extFader = 0;
     player->prio = 64;
 
-    for (int i = 0; i < SND_TRACK_COUNT_PER_PLAYER; i++) {
+    for (int i = 0; i < SND_TRACK_COUNT_PER_PLAYER; i++)
+    {
         player->tracks[i] = 0xFF;
     }
 
-    if (SNDi_SharedWork) {
+    if (SNDi_SharedWork)
+    {
         SNDi_SharedWork->players[player->playerId].tickCounter = 0;
 
-        for (int i = 0; i < SND_TRACK_COUNT_PER_PLAYER; i++) {
+        for (int i = 0; i < SND_TRACK_COUNT_PER_PLAYER; i++)
+        {
             SNDi_SharedWork->players[player->playerId].localVars[i] = -1;
         }
     }
 }
 
-static void TrackReleaseChannels(struct SNDTrack *track, struct SNDPlayer *player, int release) {
+static void TrackReleaseChannels(struct SNDTrack *track, struct SNDPlayer *player, int release)
+{
     TrackUpdateChannel(track, player, 0);
 
-    for (struct SNDExChannel *chn = track->channelLLHead; chn; chn = chn->channelLLNext) {
-        if (SND_IsExChannelActive(chn)) {
+    for (struct SNDExChannel *chn = track->channelLLHead; chn; chn = chn->channelLLNext)
+    {
+        if (SND_IsExChannelActive(chn))
+        {
             if (release >= 0)
                 SND_SetExChannelRelease(chn, release & 0xFF);
             chn->priority = 1;
@@ -490,32 +560,39 @@ static void TrackReleaseChannels(struct SNDTrack *track, struct SNDPlayer *playe
     }
 }
 
-static void TrackFreeChannels(struct SNDTrack *track) {
-    for (struct SNDExChannel *chn = track->channelLLHead; chn; chn = chn->channelLLNext) {
+static void TrackFreeChannels(struct SNDTrack *track)
+{
+    for (struct SNDExChannel *chn = track->channelLLHead; chn; chn = chn->channelLLNext)
+    {
         SND_FreeExChannel(chn);
     }
 
     track->channelLLHead = NULL;
 }
 
-static void PlayerSeqMain(struct SNDPlayer *player) {
+static void PlayerSeqMain(struct SNDPlayer *player)
+{
     int ticks = 0;
     int tempoInc;
     int i;
 
-    while (player->tempoCounter >= SND_TIMER_RATE) {
+    while (player->tempoCounter >= SND_TIMER_RATE)
+    {
         player->tempoCounter -= SND_TIMER_RATE;
         ticks++;
     }
 
-    for (i = 0; i < ticks; i++) {
-        if (PlayerStepTicks(player, SND_PROC_PLAY_NOTES)) {
+    for (i = 0; i < ticks; i++)
+    {
+        if (PlayerStepTicks(player, SND_PROC_PLAY_NOTES))
+        {
             PlayerStop(player);
             break;
         }
     }
 
-    if (SNDi_SharedWork) {
+    if (SNDi_SharedWork)
+    {
         SNDi_SharedWork->players[player->playerId].tickCounter += i;
     }
 
@@ -526,57 +603,69 @@ static void PlayerSeqMain(struct SNDPlayer *player) {
     player->tempoCounter += tempoInc;
 }
 
-static struct SNDTrack *PlayerGetTrack(struct SNDPlayer *player, int track) {
+static struct SNDTrack *PlayerGetTrack(struct SNDPlayer *player, int track)
+{
     if (track > (SND_TRACK_COUNT_PER_PLAYER - 1))
         return NULL;
-    
+
     if (player->tracks[track] == 0xFF)
         return NULL;
-    
+
     return &SNDi_Work.tracks[player->tracks[track]];
 }
 
-static void TrackStop(struct SNDTrack *track, struct SNDPlayer *player) {
+static void TrackStop(struct SNDTrack *track, struct SNDPlayer *player)
+{
     TrackReleaseChannels(track, player, -1);
     TrackFreeChannels(track);
 }
 
-static void PlayerStopTrack(struct SNDPlayer *player, int trackIdx) {
+static void PlayerStopTrack(struct SNDPlayer *player, int trackIdx)
+{
     struct SNDTrack *track = PlayerGetTrack(player, trackIdx);
 
     if (track == NULL)
         return;
-    
+
     TrackStop(track, player);
     SNDi_Work.tracks[player->tracks[trackIdx]].flags.active = FALSE;
     player->tracks[trackIdx] = 0xFF;
 }
 
-static void PlayerStop(struct SNDPlayer *player) {
-    for (int i = 0; i < SND_TRACK_COUNT_PER_PLAYER; i++) {
+static void PlayerStop(struct SNDPlayer *player)
+{
+    for (int i = 0; i < SND_TRACK_COUNT_PER_PLAYER; i++)
+    {
         PlayerStopTrack(player, i);
     }
     player->flags.active = FALSE;
 }
 
-static void ChannelCallback(struct SNDExChannel *chn, int status, void *track_) {
+static void ChannelCallback(struct SNDExChannel *chn, int status, void *track_)
+{
     struct SNDExChannel *cur;
     struct SNDTrack *track;
-    
+
     track = (struct SNDTrack *)track_;
 
-    if (status == 1) {
+    if (status == 1)
+    {
         chn->priority = 0;
         SND_FreeExChannel(chn);
     }
 
-    if (track->channelLLHead == chn) {
+    if (track->channelLLHead == chn)
+    {
         track->channelLLHead = chn->channelLLNext;
-    } else {
+    }
+    else
+    {
         cur = track->channelLLHead;
 
-        while (cur->channelLLNext) {
-            if (cur->channelLLNext == chn) {
+        while (cur->channelLLNext)
+        {
+            if (cur->channelLLNext == chn)
+            {
                 cur->channelLLNext = chn->channelLLNext;
                 return;
             }
@@ -585,15 +674,15 @@ static void ChannelCallback(struct SNDExChannel *chn, int status, void *track_)
     }
 }
 
-static void TrackUpdateChannel(struct SNDTrack *track, struct SNDPlayer *player, int release) {
+static void TrackUpdateChannel(struct SNDTrack *track, struct SNDPlayer *player, int release)
+{
     int vol;
     int fader;
     int pan;
     int pitch;
 
-    vol = SNDi_DecibelSquareTable[track->volume] +
-        SNDi_DecibelSquareTable[track->expression] +
-        SNDi_DecibelSquareTable[player->volume];
+    vol = SNDi_DecibelSquareTable[track->volume] + SNDi_DecibelSquareTable[track->expression] +
+          SNDi_DecibelSquareTable[player->volume];
 
     fader = track->extFader + player->extFader;
 
@@ -606,21 +695,22 @@ static void TrackUpdateChannel(struct SNDTrack *track, struct SNDPlayer *player,
 
     if (track->panRange != 127)
         pan = (pan * track->panRange + 0x40) >> 7;
-    
+
     pan += track->extPan;
 
     if (vol < -0x8000)
         vol = -0x8000;
-    
+
     if (fader < -0x8000)
         fader = -0x8000;
-    
+
     if (pan < -128)
         pan = -128;
     else if (pan > 127)
         pan = 127;
-    
-    for (struct SNDExChannel *chn = track->channelLLHead; chn != NULL; chn = chn->channelLLNext) {
+
+    for (struct SNDExChannel *chn = track->channelLLHead; chn != NULL; chn = chn->channelLLNext)
+    {
         chn->userDecay2 = (short)fader;
 
         if (chn->envStatus == 3)
@@ -632,65 +722,81 @@ static void TrackUpdateChannel(struct SNDTrack *track, struct SNDPlayer *player,
         chn->panRange = track->panRange;
         chn->lfo.param = track->mod;
 
-        if (chn->length == 0 && release != 0) {
+        if (chn->length == 0 && release != 0)
+        {
             chn->priority = 1;
             SND_ReleaseExChannel(chn);
         }
     }
 }
 
-static void PlayerUpdateChannel(struct SNDPlayer *player) {
-    for (int i = 0; i < SND_TRACK_COUNT_PER_PLAYER; i++) {
+static void PlayerUpdateChannel(struct SNDPlayer *player)
+{
+    for (int i = 0; i < SND_TRACK_COUNT_PER_PLAYER; i++)
+    {
         struct SNDTrack *trk = PlayerGetTrack(player, i);
-        if (trk) {
+        if (trk)
+        {
             TrackUpdateChannel(trk, player, 1);
         }
     }
 }
 
-static void TrackPlayNote(struct SNDTrack *track, struct SNDPlayer *player, int midiKey, int velocity, int length) {
+static void TrackPlayNote(
+    struct SNDTrack *track, struct SNDPlayer *player, int midiKey, int velocity, int length)
+{
     struct SNDExChannel *chn = NULL;
 
-    if (track->flags.tie) {
+    if (track->flags.tie)
+    {
         chn = track->channelLLHead;
-        if (chn) {
+        if (chn)
+        {
             chn->midiKey = (u8)midiKey;
             chn->velocity = (u8)velocity;
         }
     }
 
-    if (chn == NULL) {
+    if (chn == NULL)
+    {
         struct SNDInstData inst;
         if (!SND_ReadInstData(player->bank, track->program, midiKey, &inst))
             return;
 
         u32 allowedChannels;
 
-        switch (inst.type) {
-        case SND_INST_PCM:
-        case SND_INST_DIRECTPCM:
-            // all channels support PCM
-            allowedChannels = 0xFFFF;
-            break;
-        case SND_INST_PSG:
-            // only channels 8, 9, 10, 11, 12, 13 support PSG
-            allowedChannels = 0x3F00;
-            break;
-        case SND_INST_NOISE:
-            // only channels 14 and 15 support noise
-            allowedChannels = 0xC000;
-            break;
-        default:
-            return;
+        switch (inst.type)
+        {
+            case SND_INST_PCM:
+            case SND_INST_DIRECTPCM:
+                // all channels support PCM
+                allowedChannels = 0xFFFF;
+                break;
+            case SND_INST_PSG:
+                // only channels 8, 9, 10, 11, 12, 13 support PSG
+                allowedChannels = 0x3F00;
+                break;
+            case SND_INST_NOISE:
+                // only channels 14 and 15 support noise
+                allowedChannels = 0xC000;
+                break;
+            default:
+                return;
         }
 
         allowedChannels &= track->channelMask;
 
-        chn = SND_AllocExChannel(allowedChannels, player->prio + track->priority, track->flags.channelMask, ChannelCallback, track);
+        chn = SND_AllocExChannel(allowedChannels,
+            player->prio + track->priority,
+            track->flags.channelMask,
+            ChannelCallback,
+            track);
         if (chn == NULL)
             return;
-        
-        if (!SND_NoteOn(chn, midiKey, velocity, track->flags.tie ? -1 : length, player->bank, &inst)) {
+
+        if (!SND_NoteOn(
+                chn, midiKey, velocity, track->flags.tie ? -1 : length, player->bank, &inst))
+        {
             chn->priority = 0;
             SND_FreeExChannel(chn);
             return;
@@ -702,7 +808,7 @@ static void TrackPlayNote(struct SNDTrack *track, struct SNDPlayer *player, int
 
     if (track->envAttack != 0xFF)
         SND_SetExChannelAttack(chn, track->envAttack);
-    
+
     if (track->envDecay != 0xFF)
         SND_SetExChannelDecay(chn, track->envDecay);
 
@@ -711,15 +817,18 @@ static void TrackPlayNote(struct SNDTrack *track, struct SNDPlayer *player, int
 
     if (track->envRelease != 0xFF)
         SND_SetExChannelRelease(chn, track->envRelease);
-    
+
     chn->sweepPitch = track->sweepPitch;
     if (track->flags.portamento)
         chn->sweepPitch += (short)((track->portamentoKey - midiKey) << 6);
-    
-    if (track->portamentoTime == 0) {
+
+    if (track->portamentoTime == 0)
+    {
         chn->sweepLength = length;
         chn->flags.autoSweep = FALSE;
-    } else {
+    }
+    else
+    {
         int swp = track->portamentoTime * track->portamentoTime;
         swp *= chn->sweepPitch < 0 ? -chn->sweepPitch : chn->sweepPitch;
         swp >>= 11;
@@ -729,7 +838,9 @@ static void TrackPlayNote(struct SNDTrack *track, struct SNDPlayer *player, int
     chn->sweepCounter = 0;
 }
 
-static int TrackStepTicks(struct SNDTrack *track, struct SNDPlayer *player, int trackIdx, u32 playNotes) {
+static int TrackStepTicks(
+    struct SNDTrack *track, struct SNDPlayer *player, int trackIdx, u32 playNotes)
+{
     (void)trackIdx;
 
     struct SNDExChannel *chn;
@@ -742,22 +853,24 @@ static int TrackStepTicks(struct SNDTrack *track, struct SNDPlayer *player, int
 
     s32 par;
 
-
-    for (chn = track->channelLLHead; chn; chn = chn->channelLLNext) {
+    for (chn = track->channelLLHead; chn; chn = chn->channelLLNext)
+    {
         if (chn->length > 0)
             chn->length--;
-        
+
         if (!chn->flags.autoSweep && chn->sweepCounter < chn->sweepLength)
             chn->sweepCounter++;
     }
 
-    if (track->flags.noteFinishWait) {
+    if (track->flags.noteFinishWait)
+    {
         if (track->channelLLHead)
             return 0;
         track->flags.noteFinishWait = FALSE;
     }
 
-    if (track->wait > 0) {
+    if (track->wait > 0)
+    {
         track->wait--;
         if (track->wait > 0)
             return 0;
@@ -765,30 +878,35 @@ static int TrackStepTicks(struct SNDTrack *track, struct SNDPlayer *player, int
 
     SeqCacheFetch(track->cur);
 
-    while (track->wait == 0 && !track->flags.noteFinishWait) {
+    while (track->wait == 0 && !track->flags.noteFinishWait)
+    {
         specialValueType = FALSE;
         runCmd = TRUE;
 
         cmd = TrackReadU8(track);
 
-        if (cmd == 0xA2) {
+        if (cmd == 0xA2)
+        {
             cmd = TrackReadU8(track);
             runCmd = track->flags.cmp;
         }
 
-        if (cmd == 0xA0) {
+        if (cmd == 0xA0)
+        {
             cmd = TrackReadU8(track);
             valueType = SND_SEQ_VAL_RAN;
             specialValueType = TRUE;
         }
 
-        if (cmd == 0xA1) {
+        if (cmd == 0xA1)
+        {
             cmd = TrackReadU8(track);
             valueType = SND_SEQ_VAL_VAR;
             specialValueType = TRUE;
         }
 
-        if ((cmd & 0x80) == 0) {
+        if ((cmd & 0x80) == 0)
+        {
             par = TrackReadU8(track);
 
             length = TrackParseValue(track, player, specialValueType ? valueType : SND_SEQ_VAL_VLV);
@@ -796,22 +914,26 @@ static int TrackStepTicks(struct SNDTrack *track, struct SNDPlayer *player, int
 
             if (!runCmd)
                 continue;
-            
+
             if (midiKey < 0)
                 midiKey = 0;
-            else if (midiKey > 127) {
+            else if (midiKey > 127)
+            {
                 midiKey = 127;
             }
 
-            if (!track->flags.muted && playNotes != 0) {
+            if (!track->flags.muted && playNotes != 0)
+            {
                 TrackPlayNote(track, player, midiKey, par, (length > 0) ? length : -1);
             }
-            
+
             track->portamentoKey = (u8)midiKey;
 
-            if (track->flags.noteWait) {
+            if (track->flags.noteWait)
+            {
                 track->wait = length;
-                if (length == 0) {
+                if (length == 0)
+                {
                     track->flags.noteFinishWait = TRUE;
                 }
             }
@@ -819,157 +941,168 @@ static int TrackStepTicks(struct SNDTrack *track, struct SNDPlayer *player, int
             continue;
         }
 
-        switch (cmd & 0xF0) {
-        case 0x80:
-            par = TrackParseValue(track, player, specialValueType ? valueType : SND_SEQ_VAL_VLV);
-            if (!runCmd)
-                break;
-            
-            switch (cmd) {
+        switch (cmd & 0xF0)
+        {
             case 0x80:
-                track->wait = par;
-                break;
-            case 0x81:
-                if (par < 0x10000)
-                    track->program = (u16)par;
-                break;
-            }
-            break;
-        case 0x90:
-            switch (cmd) {
-            case 0x93:
-                {
-                    u32 off;
-                    struct SNDTrack *newTrack;
-
-                    par = TrackReadU8(track);
-                    off = TrackReadU24(track);
-                    if (!runCmd)
-                        break;
+                par =
+                    TrackParseValue(track, player, specialValueType ? valueType : SND_SEQ_VAL_VLV);
+                if (!runCmd)
+                    break;
 
-                    newTrack = PlayerGetTrack(player, par);
-                    if (newTrack && newTrack != track) {
-                        TrackStop(newTrack, player);
-                        TrackStart(newTrack, track->base, off);
-                    }
-                }
-                break;
-            case 0x94:
+                switch (cmd)
                 {
-                    u32 off = TrackReadU24(track);
-                    if (!runCmd)
+                    case 0x80:
+                        track->wait = par;
+                        break;
+                    case 0x81:
+                        if (par < 0x10000)
+                            track->program = (u16)par;
                         break;
-                    track->cur = &track->base[off];
                 }
                 break;
-            case 0x95:
+            case 0x90:
+                switch (cmd)
                 {
-                    u32 off = TrackReadU24(track);
-                    if (!runCmd)
-                        break;
+                    case 0x93:
+                    {
+                        u32 off;
+                        struct SNDTrack *newTrack;
 
-                    if (track->callStackDepth < SND_TRACK_MAX_CALL) {
-                        track->posCallStack[track->callStackDepth] = track->cur;
-                        track->callStackDepth++;
+                        par = TrackReadU8(track);
+                        off = TrackReadU24(track);
+                        if (!runCmd)
+                            break;
+
+                        newTrack = PlayerGetTrack(player, par);
+                        if (newTrack && newTrack != track)
+                        {
+                            TrackStop(newTrack, player);
+                            TrackStart(newTrack, track->base, off);
+                        }
+                    }
+                    break;
+                    case 0x94:
+                    {
+                        u32 off = TrackReadU24(track);
+                        if (!runCmd)
+                            break;
                         track->cur = &track->base[off];
                     }
                     break;
+                    case 0x95:
+                    {
+                        u32 off = TrackReadU24(track);
+                        if (!runCmd)
+                            break;
+
+                        if (track->callStackDepth < SND_TRACK_MAX_CALL)
+                        {
+                            track->posCallStack[track->callStackDepth] = track->cur;
+                            track->callStackDepth++;
+                            track->cur = &track->base[off];
+                        }
+                        break;
+                    }
                 }
-            }
-            break;
-        case 0xC0:
-        case 0xD0:
+                break;
+            case 0xC0:
+            case 0xD0:
             {
-                union {
+                union
+                {
                     u8 _u8;
                     s8 _s8;
                 } par;
-                par._u8 = (u8)TrackParseValue(track, player, specialValueType ? valueType : SND_SEQ_VAL_U8);
+                par._u8 = (u8)TrackParseValue(
+                    track, player, specialValueType ? valueType : SND_SEQ_VAL_U8);
                 if (!runCmd)
                     break;
 
-                switch (cmd) {
-                case 0xC1:
-                    track->volume = par._u8;
-                    break;
-                case 0xD5:
-                    track->expression = par._u8;
-                    break;
-                case 0xC2:
-                    player->volume = par._u8;
-                    break;
-                case 0xC5:
-                    track->bendRange = par._u8;
-                    break;
-                case 0xC6:
-                    track->priority = par._u8;
-                    break;
-                case 0xC7:
-                    track->flags.noteWait = par._u8;
-                    break;
-                case 0xCF:
-                    track->portamentoTime = par._u8;
-                    break;
-                case 0xCA:
-                    track->mod.depth = par._u8;
-                    break;
-                case 0xCB:
-                    track->mod.speed = par._u8;
-                    break;
-                case 0xCC:
-                    track->mod.target = par._u8;
-                    break;
-                case 0xCD:
-                    track->mod.range = par._u8;
-                    break;
-                case 0xD0:
-                    track->envAttack = par._u8;
-                    break;
-                case 0xD1:
-                    track->envDecay = par._u8;
-                    break;
-                case 0xD2:
-                    track->envSustain = par._u8;
-                    break;
-                case 0xD3:
-                    track->envRelease = par._u8;
-                    break;
-                case 0xD4:
-                    if (track->callStackDepth < SND_TRACK_MAX_CALL) {
-                        track->posCallStack[track->callStackDepth] = track->cur;
-                        track->loopCount[track->callStackDepth] = par._u8;
-                        track->callStackDepth++;
-                    }
-                    break;
-                case 0xC8:
-                    track->flags.tie = par._u8;
-                    TrackReleaseChannels(track, player, -1);
-                    TrackFreeChannels(track);
-                    break;
-                case 0xD7:
-                    TrackMute(track, player, par._u8);
-                    break;
-                case 0xC9:
-                    track->portamentoKey = (u8)(par._u8 + track->transpose);
-                    track->flags.portamento = TRUE;
-                    break;
-                case 0xCE:
-                    track->flags.portamento = par._u8;
-                    break;
-                case 0xC3:
-                    track->transpose = par._s8;
-                    break;
-                case 0xC4:
-                    track->pitchBend = par._s8;
-                    break;
-                case 0xC0:
-                    track->pan = (s8)(par._u8 - 0x40);
-                    break;
-                case 0xD6:
+                switch (cmd)
+                {
+                    case 0xC1:
+                        track->volume = par._u8;
+                        break;
+                    case 0xD5:
+                        track->expression = par._u8;
+                        break;
+                    case 0xC2:
+                        player->volume = par._u8;
+                        break;
+                    case 0xC5:
+                        track->bendRange = par._u8;
+                        break;
+                    case 0xC6:
+                        track->priority = par._u8;
+                        break;
+                    case 0xC7:
+                        track->flags.noteWait = par._u8;
+                        break;
+                    case 0xCF:
+                        track->portamentoTime = par._u8;
+                        break;
+                    case 0xCA:
+                        track->mod.depth = par._u8;
+                        break;
+                    case 0xCB:
+                        track->mod.speed = par._u8;
+                        break;
+                    case 0xCC:
+                        track->mod.target = par._u8;
+                        break;
+                    case 0xCD:
+                        track->mod.range = par._u8;
+                        break;
+                    case 0xD0:
+                        track->envAttack = par._u8;
+                        break;
+                    case 0xD1:
+                        track->envDecay = par._u8;
+                        break;
+                    case 0xD2:
+                        track->envSustain = par._u8;
+                        break;
+                    case 0xD3:
+                        track->envRelease = par._u8;
+                        break;
+                    case 0xD4:
+                        if (track->callStackDepth < SND_TRACK_MAX_CALL)
+                        {
+                            track->posCallStack[track->callStackDepth] = track->cur;
+                            track->loopCount[track->callStackDepth] = par._u8;
+                            track->callStackDepth++;
+                        }
+                        break;
+                    case 0xC8:
+                        track->flags.tie = par._u8;
+                        TrackReleaseChannels(track, player, -1);
+                        TrackFreeChannels(track);
+                        break;
+                    case 0xD7:
+                        TrackMute(track, player, par._u8);
+                        break;
+                    case 0xC9:
+                        track->portamentoKey = (u8)(par._u8 + track->transpose);
+                        track->flags.portamento = TRUE;
+                        break;
+                    case 0xCE:
+                        track->flags.portamento = par._u8;
+                        break;
+                    case 0xC3:
+                        track->transpose = par._s8;
+                        break;
+                    case 0xC4:
+                        track->pitchBend = par._s8;
+                        break;
+                    case 0xC0:
+                        track->pan = (s8)(par._u8 - 0x40);
+                        break;
+                    case 0xD6:
                     {
                         s16 *varPtr;
 
-                        if (sPrintEnabled) {
+                        if (sPrintEnabled)
+                        {
                             varPtr = PlayerGetVariablePointer(player, par._u8);
                         }
                     }
@@ -977,30 +1110,33 @@ static int TrackStepTicks(struct SNDTrack *track, struct SNDPlayer *player, int
                 }
             }
             break;
-        case 0xE0:
+            case 0xE0:
             {
-                s16 par = (s16)TrackParseValue(track, player, specialValueType ? valueType : SND_SEQ_VAL_U16);
+                s16 par = (s16)TrackParseValue(
+                    track, player, specialValueType ? valueType : SND_SEQ_VAL_U16);
                 if (!runCmd)
                     break;
 
-                switch (cmd) {
-                case 0xE3:
-                    track->sweepPitch = par;
-                    break;
-                case 0xE1:
-                    player->tempo = (u16)par;
-                    break;
-                case 0xE0:
-                    track->mod.delay = (u16)par;
-                    break;
+                switch (cmd)
+                {
+                    case 0xE3:
+                        track->sweepPitch = par;
+                        break;
+                    case 0xE1:
+                        player->tempo = (u16)par;
+                        break;
+                    case 0xE0:
+                        track->mod.delay = (u16)par;
+                        break;
                 }
             }
             break;
-        case 0xB0:
+            case 0xB0:
             {
                 int varNum = TrackReadU8(track);
 
-                s16 par = (s16)TrackParseValue(track, player, specialValueType ? valueType : SND_SEQ_VAL_U16);
+                s16 par = (s16)TrackParseValue(
+                    track, player, specialValueType ? valueType : SND_SEQ_VAL_U16);
                 s16 *varPtr = PlayerGetVariablePointer(player, varNum);
 
                 if (!runCmd)
@@ -1009,33 +1145,35 @@ static int TrackStepTicks(struct SNDTrack *track, struct SNDPlayer *player, int
                 if (varPtr == NULL)
                     break;
 
-                switch (cmd) {
-                case 0xB0:
-                    *varPtr = par;
-                    break;
-                case 0xB1:
-                    *varPtr += par;
-                    break;
-                case 0xB2:
-                    *varPtr -= par;
-                    break;
-                case 0xB3:
-                    *varPtr *= par;
-                    break;
-                case 0xB4:
-                    if (par != 0)
-                        *varPtr /= par;
-                    break;
-                case 0xB5:
-                    if (par >= 0)
-                        *varPtr <<= par;
-                    else
-                        *varPtr >>= -par;
-                    break;
-                case 0xB6:
+                switch (cmd)
+                {
+                    case 0xB0:
+                        *varPtr = par;
+                        break;
+                    case 0xB1:
+                        *varPtr += par;
+                        break;
+                    case 0xB2:
+                        *varPtr -= par;
+                        break;
+                    case 0xB3:
+                        *varPtr *= par;
+                        break;
+                    case 0xB4:
+                        if (par != 0)
+                            *varPtr /= par;
+                        break;
+                    case 0xB5:
+                        if (par >= 0)
+                            *varPtr <<= par;
+                        else
+                            *varPtr >>= -par;
+                        break;
+                    case 0xB6:
                     {
                         BOOL neg = FALSE;
-                        if (par < 0) {
+                        if (par < 0)
+                        {
                             neg = TRUE;
                             par = (s16)(-par);
                         }
@@ -1046,77 +1184,84 @@ static int TrackStepTicks(struct SNDTrack *track, struct SNDPlayer *player, int
                         *varPtr = (s16)random;
                     }
                     break;
-                case 0xB7:
-                    break;
-                case 0xB8:
-                    track->flags.cmp = *varPtr == par;
-                    break;
-                case 0xB9:
-                    track->flags.cmp = *varPtr >= par;
-                    break;
-                case 0xBA:
-                    track->flags.cmp = *varPtr > par;
-                    break;
-                case 0xBB:
-                    track->flags.cmp = *varPtr <= par;
-                    break;
-                case 0xBC:
-                    track->flags.cmp = *varPtr < par;
-                    break;
-                case 0xBD:
-                    track->flags.cmp = *varPtr != par;
-                    break;
+                    case 0xB7:
+                        break;
+                    case 0xB8:
+                        track->flags.cmp = *varPtr == par;
+                        break;
+                    case 0xB9:
+                        track->flags.cmp = *varPtr >= par;
+                        break;
+                    case 0xBA:
+                        track->flags.cmp = *varPtr > par;
+                        break;
+                    case 0xBB:
+                        track->flags.cmp = *varPtr <= par;
+                        break;
+                    case 0xBC:
+                        track->flags.cmp = *varPtr < par;
+                        break;
+                    case 0xBD:
+                        track->flags.cmp = *varPtr != par;
+                        break;
                 }
             }
             break;
-        case 0xF0:
-            if (!runCmd)
-                break;
-            
-            switch (cmd) {
-            case 0xFD:
-                if (track->callStackDepth != 0) {
-                    track->callStackDepth--;
-                    track->cur = track->posCallStack[track->callStackDepth];
-                }
-                break;
-            case 0xFC:
-                {
-                    if (track->callStackDepth == 0)
-                        break;
+            case 0xF0:
+                if (!runCmd)
+                    break;
 
-                    // gosh, this was nasty to figure out
-                    u8 loopCount = track->loopCount[track->callStackDepth - 1];
-                    if (loopCount != 0) {
-                        loopCount--;
-                        if (loopCount == 0) {
+                switch (cmd)
+                {
+                    case 0xFD:
+                        if (track->callStackDepth != 0)
+                        {
                             track->callStackDepth--;
+                            track->cur = track->posCallStack[track->callStackDepth];
+                        }
+                        break;
+                    case 0xFC:
+                    {
+                        if (track->callStackDepth == 0)
                             break;
+
+                        // gosh, this was nasty to figure out
+                        u8 loopCount = track->loopCount[track->callStackDepth - 1];
+                        if (loopCount != 0)
+                        {
+                            loopCount--;
+                            if (loopCount == 0)
+                            {
+                                track->callStackDepth--;
+                                break;
+                            }
                         }
+                        track->loopCount[track->callStackDepth - 1] = loopCount;
+                        track->cur = track->posCallStack[track->callStackDepth - 1];
                     }
-                    track->loopCount[track->callStackDepth - 1] = loopCount;
-                    track->cur = track->posCallStack[track->callStackDepth - 1];
+                    break;
+                    case 0xFE:
+                        break;
+                    case 0xFF:
+                        return -1;
                 }
                 break;
-            case 0xFE:
-                break;
-            case 0xFF:
-                return -1;
-            }
-            break;
         }
     }
 
     return 0;
 }
 
-static BOOL PlayerStepTicks(struct SNDPlayer *player, u32 ticks) {
+static BOOL PlayerStepTicks(struct SNDPlayer *player, u32 ticks)
+{
     BOOL isPlaying = FALSE;
 
-    for (int i = 0; i < SND_TRACK_COUNT_PER_PLAYER; i++) {
+    for (int i = 0; i < SND_TRACK_COUNT_PER_PLAYER; i++)
+    {
         struct SNDTrack *trk = PlayerGetTrack(player, i);
 
-        if (trk && trk->cur) {
+        if (trk && trk->cur)
+        {
             if (TrackStepTicks(trk, player, i, ticks))
                 PlayerStopTrack(player, i);
             else
@@ -1127,19 +1272,26 @@ static BOOL PlayerStepTicks(struct SNDPlayer *player, u32 ticks) {
     return !isPlaying;
 }
 
-static s16 *PlayerGetVariablePointer(const struct SNDPlayer *player, int var) {
+static s16 *PlayerGetVariablePointer(const struct SNDPlayer *player, int var)
+{
     if (SNDi_SharedWork == NULL)
         return NULL;
-    else if (var < 16) {
+    else if (var < 16)
+    {
         return &SNDi_SharedWork->players[player->playerId].localVars[var];
-    } else {
+    }
+    else
+    {
         return &SNDi_SharedWork->globalVars[var - 16];
     }
 }
 
-static int AllocateTrack(void) {
-    for (int i = 0; i < SND_TRACK_COUNT; i++) {
-        if (!SNDi_Work.tracks[i].flags.active) {
+static int AllocateTrack(void)
+{
+    for (int i = 0; i < SND_TRACK_COUNT; i++)
+    {
+        if (!SNDi_Work.tracks[i].flags.active)
+        {
             SNDi_Work.tracks[i].flags.active = TRUE;
             return i;
         }
@@ -1148,22 +1300,24 @@ static int AllocateTrack(void) {
     return -1;
 }
 
-static void TrackMute(struct SNDTrack *track, struct SNDPlayer *player, int muteMode) {
-    switch (muteMode) {
-    case SND_TRACK_MUTE_MODE_UNMUTE:
-        track->flags.muted = FALSE;
-        break;
-    case SND_TRACK_MUTE_MODE_MUTE:
-        track->flags.muted = TRUE;
-        break;
-    case SND_TRACK_MUTE_MODE_MUTE_RELEASE:
-        track->flags.muted = TRUE;
-        TrackReleaseChannels(track, player, -1);
-        break;
-    case SND_TRACK_MUTE_MODE_MUTE_STOP:
-        track->flags.muted = TRUE;
-        TrackReleaseChannels(track, player, 127);
-        TrackFreeChannels(track);
-        break;
+static void TrackMute(struct SNDTrack *track, struct SNDPlayer *player, int muteMode)
+{
+    switch (muteMode)
+    {
+        case SND_TRACK_MUTE_MODE_UNMUTE:
+            track->flags.muted = FALSE;
+            break;
+        case SND_TRACK_MUTE_MODE_MUTE:
+            track->flags.muted = TRUE;
+            break;
+        case SND_TRACK_MUTE_MODE_MUTE_RELEASE:
+            track->flags.muted = TRUE;
+            TrackReleaseChannels(track, player, -1);
+            break;
+        case SND_TRACK_MUTE_MODE_MUTE_STOP:
+            track->flags.muted = TRUE;
+            TrackReleaseChannels(track, player, 127);
+            TrackFreeChannels(track);
+            break;
     }
 }