arm7: run clang-format on SND_*

11 files changed, 1396 insertions, 968 deletions

diff --git a/arm7/lib/src/SND_alarm.c b/arm7/lib/src/SND_alarm.c
index 8eef3e19..9b71d8f3 100644
--- a/arm7/lib/src/SND_alarm.c
+++ b/arm7/lib/src/SND_alarm.c
@@ -1,23 +1,27 @@
 #include "SND_alarm.h"
 
-#include "SND_work.h"
 #include "OS_alarm.h"
 #include "OS_tick.h"
 #include "PXI_fifo.h"
+#include "SND_work.h"
 
 static void AlarmHandler(void *msg);
 
-void SND_AlarmInit(void) {
-    for (s32 i = 0; i < SND_ALARM_COUNT; i++) {
+void SND_AlarmInit(void)
+{
+    for (s32 i = 0; i < SND_ALARM_COUNT; i++)
+    {
         SNDi_Work.alarms[i].enable = 0;
         SNDi_Work.alarms[i].id = 0;
     }
 }
 
-void SND_SetupAlarm(s32 idx, OSTick tick, OSTick period, u32 id) {
+void SND_SetupAlarm(s32 idx, OSTick tick, OSTick period, u32 id)
+{
     struct SNDAlarm *alarm = &SNDi_Work.alarms[idx];
 
-    if (alarm->enable) {
+    if (alarm->enable)
+    {
         OS_CancelAlarm(&alarm->alarm);
         alarm->enable = 0;
     }
@@ -27,13 +31,15 @@ void SND_SetupAlarm(s32 idx, OSTick tick, OSTick period, u32 id) {
     alarm->id = (u8)id;
 }
 
-void SND_StartAlarm(s32 idx) {
+void SND_StartAlarm(s32 idx)
+{
     OSTick tick;
     OSTick period;
-    
+
     struct SNDAlarm *alarm = &SNDi_Work.alarms[idx];
 
-    if (alarm->enable != 0) {
+    if (alarm->enable != 0)
+    {
         OS_CancelAlarm(&alarm->alarm);
         alarm->enable = 0;
     }
@@ -44,27 +50,34 @@ void SND_StartAlarm(s32 idx) {
 
     OS_CreateAlarm(&alarm->alarm);
 
-    if (period == 0) {
+    if (period == 0)
+    {
         OS_SetAlarm(&alarm->alarm, tick, AlarmHandler, (void *)arg);
-    } else {
+    }
+    else
+    {
         OS_SetPeriodicAlarm(&alarm->alarm, tick + OS_GetTick(), period, AlarmHandler, (void *)arg);
     }
 
     alarm->enable = 1;
 }
 
-void SND_StopAlarm(s32 idx) {
+void SND_StopAlarm(s32 idx)
+{
     struct SNDAlarm *alarm = &SNDi_Work.alarms[idx];
 
-    if (alarm->enable != 0) {
+    if (alarm->enable != 0)
+    {
         OS_CancelAlarm(&alarm->alarm);
         alarm->id++;
         alarm->enable = 0;
     }
 }
 
-static void AlarmHandler(void *msg) {
-    while (PXI_SendWordByFifo(7, (u32)msg, 0) < 0) {
+static void AlarmHandler(void *msg)
+{
+    while (PXI_SendWordByFifo(7, (u32)msg, 0) < 0)
+    {
         // nothing
     }
 }
diff --git a/arm7/lib/src/SND_bank.c b/arm7/lib/src/SND_bank.c
index 5c9fb3dd..3437e021 100644
--- a/arm7/lib/src/SND_bank.c
+++ b/arm7/lib/src/SND_bank.c
@@ -1,13 +1,16 @@
 #include "SND_bank.h"
 
-#include "SND_main.h"
 #include "SND_exChannel.h"
+#include "SND_main.h"
 
 #include "mmap.h"
 
-static const struct SNDWaveData *GetWaveData(const struct SNDBankData *bankData, s32 waveArc, s32 wave);
+static const struct SNDWaveData *GetWaveData(
+    const struct SNDBankData *bankData, s32 waveArc, s32 wave);
 
-BOOL SND_ReadInstData(const struct SNDBankData *bankData, s32 program, s32 midiKey, struct SNDInstData *instData) {
+BOOL SND_ReadInstData(
+    const struct SNDBankData *bankData, s32 program, s32 midiKey, struct SNDInstData *instData)
+{
     s32 i;
     struct SNDDrumSet *drumSet;
     struct SNDKeySplit *keySplit;
@@ -16,10 +19,11 @@ BOOL SND_ReadInstData(const struct SNDBankData *bankData, s32 program, s32 midiK
 
     if (program < 0)
         return FALSE;
-    
+
     SNDi_LockMutex();
 
-    if (program >= bankData->instCount) {
+    if (program >= bankData->instCount)
+    {
         SNDi_UnlockMutex();
         return FALSE;
     }
@@ -27,60 +31,69 @@ BOOL SND_ReadInstData(const struct SNDBankData *bankData, s32 program, s32 midiK
     off = bankData->instOffsets[program];
     instData->type = SND_INST_OFFSET_TYPE(off);
 
-    switch (instData->type) {
-    case SND_INST_PCM:
-    case SND_INST_PSG:
-    case SND_INST_NOISE:
-    case SND_INST_DIRECTPCM:
-    case SND_INST_DUMMY:
-        instData->param = *SND_INST_OFFSET_NORMAL(bankData, off);
-        break;
-    case SND_INST_DRUM_TABLE:
-        drumSet = SND_INST_OFFSET_DRUMS(bankData, off);
-
-        // seperate variables needed for matching
-        maxKey = drumSet->maxKey;
-        minKey = drumSet->minKey;
-
-        if (midiKey < minKey || midiKey > maxKey) {
-            SNDi_UnlockMutex();
-            return FALSE;
-        }
-
-        *instData = drumSet->instruments[midiKey - drumSet->minKey];
-        break;
-    case SND_INST_KEY_SPLIT:
-        i = 0;
-        keySplit = SND_INST_OFFSET_KEYSPL(bankData, off);
-
-        while (midiKey > keySplit->key[i]) {
-            i++;
-            if (i >= SND_INST_MAX_KEYSPLIT) {
+    switch (instData->type)
+    {
+        case SND_INST_PCM:
+        case SND_INST_PSG:
+        case SND_INST_NOISE:
+        case SND_INST_DIRECTPCM:
+        case SND_INST_DUMMY:
+            instData->param = *SND_INST_OFFSET_NORMAL(bankData, off);
+            break;
+        case SND_INST_DRUM_TABLE:
+            drumSet = SND_INST_OFFSET_DRUMS(bankData, off);
+
+            // seperate variables needed for matching
+            maxKey = drumSet->maxKey;
+            minKey = drumSet->minKey;
+
+            if (midiKey < minKey || midiKey > maxKey)
+            {
                 SNDi_UnlockMutex();
                 return FALSE;
             }
-        }
-        *instData = keySplit->instruments[i];
-        break;
-    case SND_INST_ILLEGAL:
-    default:
-        SNDi_UnlockMutex();
-        return FALSE;
+
+            *instData = drumSet->instruments[midiKey - drumSet->minKey];
+            break;
+        case SND_INST_KEY_SPLIT:
+            i = 0;
+            keySplit = SND_INST_OFFSET_KEYSPL(bankData, off);
+
+            while (midiKey > keySplit->key[i])
+            {
+                i++;
+                if (i >= SND_INST_MAX_KEYSPLIT)
+                {
+                    SNDi_UnlockMutex();
+                    return FALSE;
+                }
+            }
+            *instData = keySplit->instruments[i];
+            break;
+        case SND_INST_ILLEGAL:
+        default:
+            SNDi_UnlockMutex();
+            return FALSE;
     }
-    
+
     SNDi_UnlockMutex();
     return TRUE;
 }
 
-const struct SNDWaveData *SND_GetWaveDataAddress(const struct SNDWaveArc *waveArc, s32 wave) {
+const struct SNDWaveData *SND_GetWaveDataAddress(const struct SNDWaveArc *waveArc, s32 wave)
+{
     SNDi_LockMutex();
 
     const struct SNDWaveData *retval = (const struct SNDWaveData *)waveArc->waveOffsets[wave];
-    if (retval != NULL) {
-        if ((u32)retval < HW_MAIN_MEM) {
+    if (retval != NULL)
+    {
+        if ((u32)retval < HW_MAIN_MEM)
+        {
             retval = (const struct SNDWaveData *)((u32)waveArc + (u32)retval);
         }
-    } else {
+    }
+    else
+    {
         retval = NULL;
     }
 
@@ -89,47 +102,66 @@ const struct SNDWaveData *SND_GetWaveDataAddress(const struct SNDWaveArc *waveAr
     return retval;
 }
 
-BOOL SND_NoteOn(struct SNDExChannel *chn, s32 midiKey, s32 velocity, s32 length, const struct SNDBankData *bankData, const struct SNDInstData *instData) {
+BOOL SND_NoteOn(struct SNDExChannel *chn,
+    s32 midiKey,
+    s32 velocity,
+    s32 length,
+    const struct SNDBankData *bankData,
+    const struct SNDInstData *instData)
+{
     const struct SNDWaveData *waveData;
     u8 release;
     BOOL success;
-    
+
     release = instData->param.envRelease;
 
-    if (release == 0xFF) {
+    if (release == 0xFF)
+    {
         length = -1;
         release = 0;
     }
 
-    switch (instData->type) {
-    case SND_INST_PCM:
-    case SND_INST_DIRECTPCM:
-        if (instData->type == SND_INST_PCM) {
-            waveData = GetWaveData(bankData, instData->param.wave[1], instData->param.wave[0]);
-        } else {
-            waveData = (const struct SNDWaveData *)((instData->param.wave[1] << 16) | instData->param.wave[0]);
-        }
+    switch (instData->type)
+    {
+        case SND_INST_PCM:
+        case SND_INST_DIRECTPCM:
+            if (instData->type == SND_INST_PCM)
+            {
+                waveData = GetWaveData(bankData, instData->param.wave[1], instData->param.wave[0]);
+            }
+            else
+            {
+                waveData = (const struct SNDWaveData *)((instData->param.wave[1] << 16) |
+                                                        instData->param.wave[0]);
+            }
 
-        if (waveData == NULL) {
+            if (waveData == NULL)
+            {
+                success = FALSE;
+            }
+            else
+            {
+                success =
+                    SND_StartExChannelPcm(chn, &waveData->param, waveData->sampleData, length);
+            }
+            break;
+        case SND_INST_PSG:
+            success = SND_StartExChannelPsg(chn, instData->param.wave[0], length);
+            break;
+        case SND_INST_NOISE:
+            success = SND_StartExChannelNoise(chn, length);
+            break;
+        default:
             success = FALSE;
-        } else {
-            success = SND_StartExChannelPcm(chn, &waveData->param, waveData->sampleData, length);
-        }
-        break;
-    case SND_INST_PSG:
-        success = SND_StartExChannelPsg(chn, instData->param.wave[0], length);
-        break;
-    case SND_INST_NOISE:
-        success = SND_StartExChannelNoise(chn, length);
-        break;
-    default:
-        success = FALSE;
-        break;
+            break;
     }
-    
-    if (success == FALSE) {
+
+    if (success == FALSE)
+    {
         return FALSE;
-    } else {
+    }
+    else
+    {
         chn->midiKey = (u8)midiKey;
         chn->rootMidiKey = instData->param.rootKey;
         chn->velocity = (u8)velocity;
@@ -142,14 +174,21 @@ BOOL SND_NoteOn(struct SNDExChannel *chn, s32 midiKey, s32 velocity, s32 length,
     }
 }
 
-static const struct SNDWaveData *GetWaveData(const struct SNDBankData *bankData, s32 waveArc, s32 wave) {
+static const struct SNDWaveData *GetWaveData(
+    const struct SNDBankData *bankData, s32 waveArc, s32 wave)
+{
     const struct SNDWaveArc *arcPtr = bankData->waveArcLinks[waveArc].waveArc;
 
-    if (arcPtr == NULL) {
+    if (arcPtr == NULL)
+    {
         return NULL;
-    } else if (wave < arcPtr->waveCount) {
+    }
+    else if (wave < arcPtr->waveCount)
+    {
         return SND_GetWaveDataAddress(arcPtr, wave);
-    } else {
+    }
+    else
+    {
         return NULL;
     }
 }
diff --git a/arm7/lib/src/SND_capture.c b/arm7/lib/src/SND_capture.c
index 8b604d10..57494b72 100644
--- a/arm7/lib/src/SND_capture.c
+++ b/arm7/lib/src/SND_capture.c
@@ -2,18 +2,24 @@
 
 #include "registers.h"
 
-enum SNDLoop {
-    SND_CAP_LOOP = 0, SND_CAP_ONESHOT = 1
+enum SNDLoop
+{
+    SND_CAP_LOOP = 0,
+    SND_CAP_ONESHOT = 1
 };
 
-void SND_SetupCapture(int idx, int format, void *captureData, int size, BOOL loop, int capCtrlSrc, int capCtrlDst) {
+void SND_SetupCapture(
+    int idx, int format, void *captureData, int size, BOOL loop, int capCtrlSrc, int capCtrlDst)
+{
     int off = idx * 8;
 
-    reg_SNDCAPxCNT(idx) = (u8)((format << 3) | ((loop ? SND_CAP_LOOP : SND_CAP_ONESHOT) << 2) | (capCtrlSrc << 1) | capCtrlDst);
+    reg_SNDCAPxCNT(idx) = (u8)((format << 3) | ((loop ? SND_CAP_LOOP : SND_CAP_ONESHOT) << 2) |
+                               (capCtrlSrc << 1) | capCtrlDst);
     *(vu32 *)(0x4000510 + off) = (u32)captureData;
     *(vu16 *)(0x4000514 + off) = (u16)size;
 }
 
-BOOL SND_IsCaptureActive(int idx) {
+BOOL SND_IsCaptureActive(int idx)
+{
     return (reg_SNDCAPxCNT(idx) & 0x80) != 0;
 }
diff --git a/arm7/lib/src/SND_channel.c b/arm7/lib/src/SND_channel.c
index 99b80a7c..be0bba3a 100644
--- a/arm7/lib/src/SND_channel.c
+++ b/arm7/lib/src/SND_channel.c
@@ -1,7 +1,7 @@
 #include "SND_channel.h"
 
-#include "registers.h"
 #include "SND_work.h"
+#include "registers.h"
 
 static int sMasterPan = -1;
 
@@ -11,50 +11,67 @@ static int sSurroundDecay;
 
 static int CalcSurroundDecay(int vol, int pan);
 
-void SND_SetupChannelPcm(int chnIdx, const void *data, int format, int loop, int loopStart, int loopLength, int volume, int volumeDiv, int timer, int pan) {
+void SND_SetupChannelPcm(int chnIdx,
+    const void *data,
+    int format,
+    int loop,
+    int loopStart,
+    int loopLength,
+    int volume,
+    int volumeDiv,
+    int timer,
+    int pan)
+{
     int off = chnIdx * 0x10;
 
     sOrgPan[chnIdx] = (u8)pan;
     if (sMasterPan >= 0)
         pan = sMasterPan;
-    
+
     sOrgVolume[chnIdx] = (u8)volume;
-    if (sSurroundDecay > 0 && (1 << chnIdx) & 0xFFF5) {
+    if (sSurroundDecay > 0 && (1 << chnIdx) & 0xFFF5)
+    {
         volume = CalcSurroundDecay(volume, pan);
     }
 
-    reg_SOUNDoffCNT(off) = (u32)((format << 29) | (loop << 27) | (pan << 16) | (volumeDiv << 8) | (volume));
+    reg_SOUNDoffCNT(off) =
+        (u32)((format << 29) | (loop << 27) | (pan << 16) | (volumeDiv << 8) | (volume));
     reg_SOUNDoffTMR(off) = (u16)(0x10000 - timer);
     reg_SOUNDoffPNT(off) = (u16)loopStart;
     reg_SOUNDoffLEN(off) = (u32)loopLength;
     reg_SOUNDoffSAD(off) = (u32)data;
 }
 
-void SND_SetupChannelPsg(int chnIdx, int duty, int volume, int volumeDiv, int timer, int pan) {
+void SND_SetupChannelPsg(int chnIdx, int duty, int volume, int volumeDiv, int timer, int pan)
+{
     int off = chnIdx * 0x10;
 
     sOrgPan[chnIdx] = (u8)pan;
     if (sMasterPan >= 0)
         pan = sMasterPan;
-    
+
     sOrgVolume[chnIdx] = (u8)volume;
-    if (sSurroundDecay > 0 && (1 << chnIdx) & 0xFFF5) {
+    if (sSurroundDecay > 0 && (1 << chnIdx) & 0xFFF5)
+    {
         volume = CalcSurroundDecay(volume, pan);
     }
 
-    reg_SOUNDoffCNT(off) = (u32)(0x60000000 | (duty << 24) | (pan << 16) | (volumeDiv << 8) | volume);
+    reg_SOUNDoffCNT(off) =
+        (u32)(0x60000000 | (duty << 24) | (pan << 16) | (volumeDiv << 8) | volume);
     reg_SOUNDoffTMR(off) = (u16)(0x10000 - timer);
 }
 
-void SND_SetupChannelNoise(int chnIdx, int volume, int volumeDiv, int timer, int pan) {
+void SND_SetupChannelNoise(int chnIdx, int volume, int volumeDiv, int timer, int pan)
+{
     int off = chnIdx * 0x10;
 
     sOrgPan[chnIdx] = (u8)pan;
     if (sMasterPan >= 0)
         pan = sMasterPan;
-    
+
     sOrgVolume[chnIdx] = (u8)volume;
-    if (sSurroundDecay > 0 && (1 << chnIdx) & 0xFFF5) {
+    if (sSurroundDecay > 0 && (1 << chnIdx) & 0xFFF5)
+    {
         volume = CalcSurroundDecay(volume, pan);
     }
 
@@ -62,7 +79,8 @@ void SND_SetupChannelNoise(int chnIdx, int volume, int volumeDiv, int timer, int
     reg_SOUNDoffTMR(off) = (u16)(0x10000 - timer);
 }
 
-void SND_StopChannel(int idx, int hold) {
+void SND_StopChannel(int idx, int hold)
+{
     vu32 *reg = &reg_SOUNDxCNT(idx);
 
     u32 v = *reg;
@@ -77,10 +95,12 @@ void SND_StopChannel(int idx, int hold) {
     *reg = v;
 }
 
-void SND_SetChannelVolume(int chnIdx, int vol, int volDiv) {
+void SND_SetChannelVolume(int chnIdx, int vol, int volDiv)
+{
     sOrgVolume[chnIdx] = (u8)vol;
 
-    if (sSurroundDecay > 0 && (1 << chnIdx) & 0xFFF5) {
+    if (sSurroundDecay > 0 && (1 << chnIdx) & 0xFFF5)
+    {
         int pan = reg_SOUNDxCNT_PAN(chnIdx);
         vol = CalcSurroundDecay(vol, pan);
     }
@@ -88,64 +108,85 @@ void SND_SetChannelVolume(int chnIdx, int vol, int volDiv) {
     reg_SOUNDxCNT_VOLS(chnIdx) = (u16)((volDiv << 8) | vol);
 }
 
-void SND_SetChannelTimer(int chnIdx, int timer) {
+void SND_SetChannelTimer(int chnIdx, int timer)
+{
     reg_SOUNDxTMR(chnIdx) = (u16)(0x10000 - timer);
 }
 
-void SND_SetChannelPan(int chnIdx, int pan) {
+void SND_SetChannelPan(int chnIdx, int pan)
+{
     sOrgPan[chnIdx] = (u8)pan;
 
-    if (sMasterPan >= 0) {
+    if (sMasterPan >= 0)
+    {
         pan = sMasterPan;
     }
 
     reg_SOUNDxCNT_PAN(chnIdx) = (u8)pan;
 
-    if (sSurroundDecay > 0 && (1 << chnIdx) & 0xFFF5) {
+    if (sSurroundDecay > 0 && (1 << chnIdx) & 0xFFF5)
+    {
         reg_SOUNDxCNT_VOL(chnIdx) = (u8)CalcSurroundDecay(sOrgVolume[chnIdx], pan);
     }
 }
 
-BOOL SND_IsChannelActive(int chnIdx) {
+BOOL SND_IsChannelActive(int chnIdx)
+{
     return (reg_SOUNDxCNT_STAT(chnIdx) & 0x80) != 0;
 }
 
-void SND_SetMasterPan(int pan) {
+void SND_SetMasterPan(int pan)
+{
     sMasterPan = pan;
 
-    if (pan >= 0) {
-        for (int i = 0; i < SND_CHANNEL_COUNT; i++) {
+    if (pan >= 0)
+    {
+        for (int i = 0; i < SND_CHANNEL_COUNT; i++)
+        {
             reg_SOUNDxCNT_PAN(i) = (u8)pan;
         }
-    } else {
-        for (int i = 0; i < SND_CHANNEL_COUNT; i++) {
+    }
+    else
+    {
+        for (int i = 0; i < SND_CHANNEL_COUNT; i++)
+        {
             reg_SOUNDxCNT_PAN(i) = sOrgPan[i];
         }
     }
 }
 
-u32 SND_GetChannelControl(int chnIdx) {
+u32 SND_GetChannelControl(int chnIdx)
+{
     return reg_SOUNDxCNT(chnIdx);
 }
 
-void SNDi_SetSurroundDecay(int decay) {
+void SNDi_SetSurroundDecay(int decay)
+{
     sSurroundDecay = decay;
 
-    for (int i = 0; i < SND_CHANNEL_COUNT; i++) {
+    for (int i = 0; i < SND_CHANNEL_COUNT; i++)
+    {
         // do not process channel 1+3 (capture playback channels)
-        if ((1 << i) & 0xFFF5) {
+        if ((1 << i) & 0xFFF5)
+        {
             int pan = reg_SOUNDxCNT_PAN(i);
             reg_SOUNDxCNT_VOL(i) = (u8)CalcSurroundDecay(sOrgVolume[i], pan);
         }
     }
 }
 
-static int CalcSurroundDecay(int vol, int pan) {
-    if (pan < 24) {
+static int CalcSurroundDecay(int vol, int pan)
+{
+    if (pan < 24)
+    {
         return vol * (sSurroundDecay * (pan + 40) + ((0x7FFF - sSurroundDecay) << 6)) >> 21;
-    } else if (pan <= 104) {
+    }
+    else if (pan <= 104)
+    {
         return vol;
-    } else {
+    }
+    else
+    {
         return vol * (-sSurroundDecay * (pan - 40) + ((sSurroundDecay + 0x7FFF) << 6)) >> 21;
     }
 }
diff --git a/arm7/lib/src/SND_command.c b/arm7/lib/src/SND_command.c
index bcb43d73..f561138a 100644
--- a/arm7/lib/src/SND_command.c
+++ b/arm7/lib/src/SND_command.c
@@ -1,15 +1,15 @@
 #include "SND_command.h"
 
-#include "registers.h"
 #include "mmap.h"
+#include "registers.h"
 
 #include "MI_memory.h"
-#include "PXI_fifo.h"
 #include "OS_message.h"
 #include "OS_system.h"
-#include "SND_channel.h"
+#include "PXI_fifo.h"
 #include "SND_alarm.h"
 #include "SND_capture.h"
+#include "SND_channel.h"
 #include "SND_exChannel.h"
 #include "SND_global.h"
 #include "SND_main.h"
@@ -29,164 +29,167 @@ static void SetChannelVolume(u32 channelMask, int vol, int shift);
 static void SetChannelPan(u32 channelMask, int pan);
 static void ReadDriverInfo(struct SNDDriverInfo *driverInfo);
 
-void SND_CommandInit(void) {
+void SND_CommandInit(void)
+{
     OS_InitMessageQueue(&sMsgQueue, sMsgArray, SND_MSG_ARRAY_SIZE);
     InitPXI();
     SNDi_SharedWork = NULL;
 }
 
-void SND_CommandProc(void) {
+void SND_CommandProc(void)
+{
     struct SNDCommand cmd;
     struct SNDCommand *cmd_ptr;
     OSMessage msg;
 
-    while (OS_ReceiveMessage(&sMsgQueue, &msg, 0)) {
+    while (OS_ReceiveMessage(&sMsgQueue, &msg, 0))
+    {
         // casting it directly below doesn't appear to match
         cmd_ptr = (struct SNDCommand *)msg;
 
-        while (cmd_ptr) {
+        while (cmd_ptr)
+        {
             cmd = *cmd_ptr;
 
-            switch (cmd.id) {
-            case SND_CMD_START_SEQ:
-                SND_StartSeq((int)cmd.arg[0], (const void *)cmd.arg[1], cmd.arg[2], (struct SNDBankData *)cmd.arg[3]);
-                break;
-            case SND_CMD_STOP_SEQ:
-                SND_StopSeq((int)cmd.arg[0]);
-                break;
-            case SND_CMD_PREPARE_SEQ:
-                SND_PrepareSeq((int)cmd.arg[0], (const void *)cmd.arg[1], cmd.arg[2], (struct SNDBankData *)cmd.arg[3]);
-                break;
-            case SND_CMD_START_PREPARED_SEQ:
-                SND_StartPreparedSeq((int)cmd.arg[0]);
-                break;
-            case SND_CMD_PAUSE_SEQ:
-                SND_PauseSeq((int)cmd.arg[0], (BOOL)cmd.arg[1]);
-                break;
-            case SND_CMD_SKIP_SEQ:
-                SND_SkipSeq((int)cmd.arg[0], cmd.arg[1]);
-                break;
-            case SND_CMD_PLAYER_PARAM:
-                SNDi_SetPlayerParam((int)cmd.arg[0], cmd.arg[1], cmd.arg[2], (int)cmd.arg[3]);
-                break;
-            case SND_CMD_TRACK_PARAM:
-                SNDi_SetTrackParam((int)cmd.arg[0] & 0xFFFFFF, cmd.arg[1], cmd.arg[2], cmd.arg[3], (u8)(cmd.arg[0] >> 24));
-                break;
-            case SND_CMD_MUTE_TRACK:
-                SND_SetTrackMute((int)cmd.arg[0], cmd.arg[1], (BOOL)cmd.arg[2]);
-                break;
-            case SND_CMD_ALLOCATABLE_CHANNEL:
-                SND_SetTrackAllocatableChannel((int)cmd.arg[0], cmd.arg[1], cmd.arg[2]);
-                break;
-            case SND_CMD_PLAYER_LOCAL_VAR:
-                SND_SetPlayerLocalVariable((int)cmd.arg[0], (int)cmd.arg[1], (s16)cmd.arg[2]);
-                break;
-            case SND_CMD_PLAYER_GLOBAL_VAR:
-                SND_SetPlayerGlobalVariable((int)cmd.arg[0], (s16)cmd.arg[1]);
-                break;
-            case SND_CMD_START_TIMER:
-                StartTimer(cmd.arg[0], cmd.arg[1], cmd.arg[2], (int)cmd.arg[3]);
-                break;
-            case SND_CMD_STOP_TIMER:
-                StopTimer(cmd.arg[0], cmd.arg[1], cmd.arg[2], (int)cmd.arg[3]);
-                break;
-            case SND_CMD_SETUP_CAPTURE:
-                SND_SetupCapture(
-                    (int)(cmd.arg[2] >> 31u) & 1,
-                    (int)(cmd.arg[2] >> 30u) & 1,
-                    (void *)cmd.arg[0],
-                    (int)cmd.arg[1],
-                    (BOOL)(cmd.arg[2] >> 29u) & 1,
-                    (int)(cmd.arg[2] >> 28u) & 1,
-                    (int)(cmd.arg[2] >> 27u) & 1
-                );
-                break;
-            case SND_CMD_SETUP_ALARM:
-                SND_SetupAlarm(
-                    (int)cmd.arg[0],
-                    cmd.arg[1],
-                    cmd.arg[2],
-                    cmd.arg[3]
-                );
-                break;
-            case SND_CMD_CHANNEL_TIMER:
-                SetChannelTimer(cmd.arg[0], (int)cmd.arg[1]);
-                break;
-            case SND_CMD_CHANNEL_VOLUME:
-                SetChannelVolume(cmd.arg[0], (int)cmd.arg[1], (int)cmd.arg[2]);
-                break;
-            case SND_CMD_CHANNEL_PAN:
-                SetChannelPan(cmd.arg[0], (int)cmd.arg[1]);
-                break;
-            case SND_CMD_SETUP_CHANNEL_PCM:
-                SND_SetupChannelPcm(
-                    (int)cmd.arg[0] & 0xFFFF,
-                    (void *)(cmd.arg[1] & 0x7FFFFFFu),
-                    (int)(cmd.arg[3] >> 24u) & 0x3,
-                    (int)(cmd.arg[3] >> 26u) & 0x3,
-                    (int)cmd.arg[3] & 0xFFFF,
-                    (int)cmd.arg[2] & 0x3FFFFF,
-                    (int)(cmd.arg[2] >> 24u) & 0x7F,
-                    (int)(cmd.arg[2] >> 22u) & 0x3,
-                    (int)(cmd.arg[0] >> 16u) & 0xFFFF,
-                    (int)(cmd.arg[3] >> 16u) & 0x7F
-                );
-                break;
-            case SND_CMD_SETUP_CHANNEL_PSG:
-                SND_SetupChannelPsg(
-                    (int)cmd.arg[0],
-                    (int)cmd.arg[3],
-                    (int)cmd.arg[1] & 0x7F,
-                    (int)(cmd.arg[1] >> 8u) & 0x3,
-                    (int)(cmd.arg[2] >> 8u) & 0xFFFF,
-                    (int)cmd.arg[2] & 0x7F
-                );
-                break;
-            case SND_CMD_SETUP_CHANNEL_NOISE:
-                SND_SetupChannelNoise(
-                    (int)cmd.arg[0],
-                    (int)cmd.arg[1] & 0x7F,
-                    (int)(cmd.arg[1] >> 8u) & 0x3,
-                    (int)(cmd.arg[2] >> 8u) & 0xFFFF,
-                    (int)cmd.arg[2] & 0x7F
-                );
-                break;
-            case SND_CMD_SURROUND_DECAY:
-                SNDi_SetSurroundDecay((int)cmd.arg[0]);
-                break;
-            case SND_CMD_MASTER_VOLUME:
-                SND_SetMasterVolume((int)cmd.arg[0]);
-                break;
-            case SND_CMD_MASTER_PAN:
-                SND_SetMasterPan((int)cmd.arg[0]);
-                break;
-            case SND_CMD_OUTPUT_SELECTOR:
-                SND_SetOutputSelector((int)cmd.arg[0], (int)cmd.arg[1], (int)cmd.arg[2], (int)cmd.arg[3]);
-                break;
-            case SND_CMD_LOCK_CHANNEL:
-                SND_LockChannel(cmd.arg[0], cmd.arg[1]);
-                break;
-            case SND_CMD_UNLOCK_CHANNEL:
-                SND_UnlockChannel(cmd.arg[0], cmd.arg[1]);
-                break;
-            case SND_CMD_STOP_UNLOCKED_CHANNEL:
-                SND_StopUnlockedChannel(cmd.arg[0], cmd.arg[1]);
-                break;
-            case SND_CMD_INVALIDATE_SEQ:
-                SND_InvalidateSeq((void *)cmd.arg[0], (void *)cmd.arg[1]);
-                break;
-            case SND_CMD_INVALIDATE_BANK:
-                SND_InvalidateBank((void *)cmd.arg[0], (void *)cmd.arg[1]);
-                break;
-            case SND_CMD_INVALIDATE_WAVE:
-                SND_InvalidateWave((void *)cmd.arg[0], (void *)cmd.arg[1]);
-                break;
-            case SND_CMD_SET_SHARED_WORK:
-                SNDi_SharedWork = (struct SNDSharedWork *)cmd.arg[0];
-                break;
-            case SND_CMD_READ_DRIVER_INFO:
-                ReadDriverInfo((struct SNDDriverInfo *)cmd.arg[0]);
-                break;
+            switch (cmd.id)
+            {
+                case SND_CMD_START_SEQ:
+                    SND_StartSeq((int)cmd.arg[0],
+                        (const void *)cmd.arg[1],
+                        cmd.arg[2],
+                        (struct SNDBankData *)cmd.arg[3]);
+                    break;
+                case SND_CMD_STOP_SEQ:
+                    SND_StopSeq((int)cmd.arg[0]);
+                    break;
+                case SND_CMD_PREPARE_SEQ:
+                    SND_PrepareSeq((int)cmd.arg[0],
+                        (const void *)cmd.arg[1],
+                        cmd.arg[2],
+                        (struct SNDBankData *)cmd.arg[3]);
+                    break;
+                case SND_CMD_START_PREPARED_SEQ:
+                    SND_StartPreparedSeq((int)cmd.arg[0]);
+                    break;
+                case SND_CMD_PAUSE_SEQ:
+                    SND_PauseSeq((int)cmd.arg[0], (BOOL)cmd.arg[1]);
+                    break;
+                case SND_CMD_SKIP_SEQ:
+                    SND_SkipSeq((int)cmd.arg[0], cmd.arg[1]);
+                    break;
+                case SND_CMD_PLAYER_PARAM:
+                    SNDi_SetPlayerParam((int)cmd.arg[0], cmd.arg[1], cmd.arg[2], (int)cmd.arg[3]);
+                    break;
+                case SND_CMD_TRACK_PARAM:
+                    SNDi_SetTrackParam((int)cmd.arg[0] & 0xFFFFFF,
+                        cmd.arg[1],
+                        cmd.arg[2],
+                        cmd.arg[3],
+                        (u8)(cmd.arg[0] >> 24));
+                    break;
+                case SND_CMD_MUTE_TRACK:
+                    SND_SetTrackMute((int)cmd.arg[0], cmd.arg[1], (BOOL)cmd.arg[2]);
+                    break;
+                case SND_CMD_ALLOCATABLE_CHANNEL:
+                    SND_SetTrackAllocatableChannel((int)cmd.arg[0], cmd.arg[1], cmd.arg[2]);
+                    break;
+                case SND_CMD_PLAYER_LOCAL_VAR:
+                    SND_SetPlayerLocalVariable((int)cmd.arg[0], (int)cmd.arg[1], (s16)cmd.arg[2]);
+                    break;
+                case SND_CMD_PLAYER_GLOBAL_VAR:
+                    SND_SetPlayerGlobalVariable((int)cmd.arg[0], (s16)cmd.arg[1]);
+                    break;
+                case SND_CMD_START_TIMER:
+                    StartTimer(cmd.arg[0], cmd.arg[1], cmd.arg[2], (int)cmd.arg[3]);
+                    break;
+                case SND_CMD_STOP_TIMER:
+                    StopTimer(cmd.arg[0], cmd.arg[1], cmd.arg[2], (int)cmd.arg[3]);
+                    break;
+                case SND_CMD_SETUP_CAPTURE:
+                    SND_SetupCapture((int)(cmd.arg[2] >> 31u) & 1,
+                        (int)(cmd.arg[2] >> 30u) & 1,
+                        (void *)cmd.arg[0],
+                        (int)cmd.arg[1],
+                        (BOOL)(cmd.arg[2] >> 29u) & 1,
+                        (int)(cmd.arg[2] >> 28u) & 1,
+                        (int)(cmd.arg[2] >> 27u) & 1);
+                    break;
+                case SND_CMD_SETUP_ALARM:
+                    SND_SetupAlarm((int)cmd.arg[0], cmd.arg[1], cmd.arg[2], cmd.arg[3]);
+                    break;
+                case SND_CMD_CHANNEL_TIMER:
+                    SetChannelTimer(cmd.arg[0], (int)cmd.arg[1]);
+                    break;
+                case SND_CMD_CHANNEL_VOLUME:
+                    SetChannelVolume(cmd.arg[0], (int)cmd.arg[1], (int)cmd.arg[2]);
+                    break;
+                case SND_CMD_CHANNEL_PAN:
+                    SetChannelPan(cmd.arg[0], (int)cmd.arg[1]);
+                    break;
+                case SND_CMD_SETUP_CHANNEL_PCM:
+                    SND_SetupChannelPcm((int)cmd.arg[0] & 0xFFFF,
+                        (void *)(cmd.arg[1] & 0x7FFFFFFu),
+                        (int)(cmd.arg[3] >> 24u) & 0x3,
+                        (int)(cmd.arg[3] >> 26u) & 0x3,
+                        (int)cmd.arg[3] & 0xFFFF,
+                        (int)cmd.arg[2] & 0x3FFFFF,
+                        (int)(cmd.arg[2] >> 24u) & 0x7F,
+                        (int)(cmd.arg[2] >> 22u) & 0x3,
+                        (int)(cmd.arg[0] >> 16u) & 0xFFFF,
+                        (int)(cmd.arg[3] >> 16u) & 0x7F);
+                    break;
+                case SND_CMD_SETUP_CHANNEL_PSG:
+                    SND_SetupChannelPsg((int)cmd.arg[0],
+                        (int)cmd.arg[3],
+                        (int)cmd.arg[1] & 0x7F,
+                        (int)(cmd.arg[1] >> 8u) & 0x3,
+                        (int)(cmd.arg[2] >> 8u) & 0xFFFF,
+                        (int)cmd.arg[2] & 0x7F);
+                    break;
+                case SND_CMD_SETUP_CHANNEL_NOISE:
+                    SND_SetupChannelNoise((int)cmd.arg[0],
+                        (int)cmd.arg[1] & 0x7F,
+                        (int)(cmd.arg[1] >> 8u) & 0x3,
+                        (int)(cmd.arg[2] >> 8u) & 0xFFFF,
+                        (int)cmd.arg[2] & 0x7F);
+                    break;
+                case SND_CMD_SURROUND_DECAY:
+                    SNDi_SetSurroundDecay((int)cmd.arg[0]);
+                    break;
+                case SND_CMD_MASTER_VOLUME:
+                    SND_SetMasterVolume((int)cmd.arg[0]);
+                    break;
+                case SND_CMD_MASTER_PAN:
+                    SND_SetMasterPan((int)cmd.arg[0]);
+                    break;
+                case SND_CMD_OUTPUT_SELECTOR:
+                    SND_SetOutputSelector(
+                        (int)cmd.arg[0], (int)cmd.arg[1], (int)cmd.arg[2], (int)cmd.arg[3]);
+                    break;
+                case SND_CMD_LOCK_CHANNEL:
+                    SND_LockChannel(cmd.arg[0], cmd.arg[1]);
+                    break;
+                case SND_CMD_UNLOCK_CHANNEL:
+                    SND_UnlockChannel(cmd.arg[0], cmd.arg[1]);
+                    break;
+                case SND_CMD_STOP_UNLOCKED_CHANNEL:
+                    SND_StopUnlockedChannel(cmd.arg[0], cmd.arg[1]);
+                    break;
+                case SND_CMD_INVALIDATE_SEQ:
+                    SND_InvalidateSeq((void *)cmd.arg[0], (void *)cmd.arg[1]);
+                    break;
+                case SND_CMD_INVALIDATE_BANK:
+                    SND_InvalidateBank((void *)cmd.arg[0], (void *)cmd.arg[1]);
+                    break;
+                case SND_CMD_INVALIDATE_WAVE:
+                    SND_InvalidateWave((void *)cmd.arg[0], (void *)cmd.arg[1]);
+                    break;
+                case SND_CMD_SET_SHARED_WORK:
+                    SNDi_SharedWork = (struct SNDSharedWork *)cmd.arg[0];
+                    break;
+                case SND_CMD_READ_DRIVER_INFO:
+                    ReadDriverInfo((struct SNDDriverInfo *)cmd.arg[0]);
+                    break;
             } // end switch
 
             cmd_ptr = cmd.llNext;
@@ -196,15 +199,19 @@ void SND_CommandProc(void) {
     } // end loop over receive message
 }
 
-static void PxiFifoCallback(PXIFifoTag tag, u32 data, BOOL error) {
+static void PxiFifoCallback(PXIFifoTag tag, u32 data, BOOL error)
+{
     (void)tag;
     (void)error;
 
     OSIntrMode intrMode = OS_DisableInterrupts();
 
-    if (data >= HW_MAIN_MEM) {
+    if (data >= HW_MAIN_MEM)
+    {
         (void)OS_SendMessage(&sMsgQueue, (OSMessage)data, 0);
-    } else {
+    }
+    else
+    {
         if (data == 0)
             SND_SendWakeupMessage();
     }
@@ -212,52 +219,68 @@ static void PxiFifoCallback(PXIFifoTag tag, u32 data, BOOL error) {
     (void)OS_RestoreInterrupts(intrMode);
 }
 
-static void InitPXI(void) {
+static void InitPXI(void)
+{
     PXI_SetFifoRecvCallback(PXI_FIFO_TAG_SOUND, PxiFifoCallback);
 }
 
-static void SetChannelTimer(u32 channelMask, int timer) {
-    for (int i = 0; i < SND_CHANNEL_COUNT && channelMask != 0; i++, channelMask >>= 1) {
+static void SetChannelTimer(u32 channelMask, int timer)
+{
+    for (int i = 0; i < SND_CHANNEL_COUNT && channelMask != 0; i++, channelMask >>= 1)
+    {
         if (channelMask & 1)
             SND_SetChannelTimer(i, timer);
     }
 }
 
-static void SetChannelVolume(u32 channelMask, int vol, int shift) {
-    for (int i = 0; i < SND_CHANNEL_COUNT && channelMask != 0; i++, channelMask >>= 1) {
+static void SetChannelVolume(u32 channelMask, int vol, int shift)
+{
+    for (int i = 0; i < SND_CHANNEL_COUNT && channelMask != 0; i++, channelMask >>= 1)
+    {
         if (channelMask & 1)
             SND_SetChannelVolume(i, vol, shift);
     }
 }
 
-static void SetChannelPan(u32 channelMask, int pan) {
-    for (int i = 0; i < SND_CHANNEL_COUNT && channelMask != 0; i++, channelMask >>= 1) {
+static void SetChannelPan(u32 channelMask, int pan)
+{
+    for (int i = 0; i < SND_CHANNEL_COUNT && channelMask != 0; i++, channelMask >>= 1)
+    {
         if (channelMask & 1)
             SND_SetChannelPan(i, pan);
     }
 }
 
-static void StartTimer(u32 channelMask, u32 captureMask, u32 alarmMask, s32 unused) {
+static void StartTimer(u32 channelMask, u32 captureMask, u32 alarmMask, s32 unused)
+{
     (void)unused;
 
     OSIntrMode intrMode = OS_DisableInterrupts();
 
-    for (int i = 0; i < SND_CHANNEL_COUNT && channelMask != 0; i++, channelMask >>= 1) {
+    for (int i = 0; i < SND_CHANNEL_COUNT && channelMask != 0; i++, channelMask >>= 1)
+    {
         if (channelMask & 1)
             reg_SOUNDxCNT_STAT(i) |= 0x80;
     }
 
-    if (captureMask & 1) {
-        if (captureMask & 2) {
+    if (captureMask & 1)
+    {
+        if (captureMask & 2)
+        {
             *(vu16 *)&reg_SNDCAPxCNT(0) |= 0x8080;
-        } else {
+        }
+        else
+        {
             reg_SNDCAPxCNT(0) |= 0x80;
         }
-    } else if (captureMask & 2) {
+    }
+    else if (captureMask & 2)
+    {
         reg_SNDCAPxCNT(1) |= 0x80;
     }
 
-    for (int i = 0; i < SND_ALARM_COUNT && alarmMask != 0; i++, alarmMask >>= 1) {
+    for (int i = 0; i < SND_ALARM_COUNT && alarmMask != 0; i++, alarmMask >>= 1)
+    {
         if (alarmMask & 1)
             SND_StartAlarm(i);
     }
@@ -266,15 +289,18 @@ static void StartTimer(u32 channelMask, u32 captureMask, u32 alarmMask, s32 unus
     SND_UpdateSharedWork();
 }
 
-static void StopTimer(u32 channelMask, u32 captureMask, u32 alarmMask, s32 hold) {
+static void StopTimer(u32 channelMask, u32 captureMask, u32 alarmMask, s32 hold)
+{
     OSIntrMode intrMode = OS_DisableInterrupts();
 
-    for (int i = 0; i < SND_ALARM_COUNT && alarmMask != 0; i++, alarmMask >>= 1) {
+    for (int i = 0; i < SND_ALARM_COUNT && alarmMask != 0; i++, alarmMask >>= 1)
+    {
         if (alarmMask & 1)
             SND_StopAlarm(i);
     }
 
-    for (int i = 0; i < SND_CHANNEL_COUNT && channelMask != 0; i++, channelMask >>= 1) {
+    for (int i = 0; i < SND_CHANNEL_COUNT && channelMask != 0; i++, channelMask >>= 1)
+    {
         if (channelMask & 1)
             SND_StopChannel(i, hold);
     }
@@ -288,12 +314,14 @@ static void StopTimer(u32 channelMask, u32 captureMask, u32 alarmMask, s32 hold)
     SND_UpdateSharedWork();
 }
 
-static void ReadDriverInfo(struct SNDDriverInfo *driverInfo) {
+static void ReadDriverInfo(struct SNDDriverInfo *driverInfo)
+{
     MI_CpuCopy32(&SNDi_Work, driverInfo, sizeof(SNDi_Work));
 
     driverInfo->workPtr = &SNDi_Work;
 
-    for (int i = 0; i < SND_CHANNEL_COUNT; i++) {
+    for (int i = 0; i < SND_CHANNEL_COUNT; i++)
+    {
         driverInfo->channelControls[i] = SND_GetChannelControl(i);
     }
 
diff --git a/arm7/lib/src/SND_exChannel.c b/arm7/lib/src/SND_exChannel.c
index c2231640..dfaabeda 100644
--- a/arm7/lib/src/SND_exChannel.c
+++ b/arm7/lib/src/SND_exChannel.c
@@ -2,8 +2,8 @@
 
 #include "SND_channel.h"
 #include "SND_main.h"
-#include "SND_work.h"
 #include "SND_util.h"
+#include "SND_work.h"
 
 #include "registers.h"
 
@@ -21,15 +21,18 @@ static int ExChannelSweepUpdate(struct SNDExChannel *chn, BOOL step);
 static int ExChannelLfoUpdate(struct SNDExChannel *chn, BOOL step);
 static void ExChannelStart(struct SNDExChannel *chn, int length);
 static int ExChannelVolumeCmp(struct SNDExChannel *chn_a, struct SNDExChannel *chn_b);
-static void ExChannelSetup(struct SNDExChannel *, SNDExChannelCallback callback, void *callbackUserData, int priority);
+static void ExChannelSetup(
+    struct SNDExChannel *, SNDExChannelCallback callback, void *callbackUserData, int priority);
 
-void SND_ExChannelInit(void) {
+void SND_ExChannelInit(void)
+{
     struct SNDExChannel *chn;
     s32 i;
 
-    for (i = 0; i < SND_CHANNEL_COUNT; i++) {
+    for (i = 0; i < SND_CHANNEL_COUNT; i++)
+    {
         chn = &SNDi_Work.channels[i];
-        
+
         chn->id = (u8)i;
         chn->flags.syncFlag = 0;
         chn->flags.active = FALSE;
@@ -39,11 +42,13 @@ void SND_ExChannelInit(void) {
     sWeakLockedChannelMask = 0;
 }
 
-void SND_UpdateExChannel(void) {
+void SND_UpdateExChannel(void)
+{
     struct SNDExChannel *chn;
     s32 i;
 
-    for (i = 0; i < SND_CHANNEL_COUNT; i++) {
+    for (i = 0; i < SND_CHANNEL_COUNT; i++)
+    {
         chn = &SNDi_Work.channels[i];
 
         if (chn->flags.syncFlag == 0)
@@ -51,69 +56,69 @@ void SND_UpdateExChannel(void) {
 
         if (chn->flags.syncFlag & SND_CHN_SYNC_STOP)
             SND_StopChannel(i, 0);
-        
-        if (chn->flags.syncFlag & SND_CHN_SYNC_START) {
-            switch (chn->type) {
-            case SND_CHN_TYPE_PCM:
-                SND_SetupChannelPcm(
-                    i,
-                    chn->waveDataPtr,
-                    chn->waveParam.format,
-                    chn->waveParam.loopEnabled ? 1 : 2,
-                    (s32)chn->waveParam.loopStart,
-                    (s32)chn->waveParam.loopLength,
-                    chn->volume & 0xFF,
-                    chn->volume >> 8,
-                    chn->timer,
-                    chn->pan
-                );
-                break;
-            case SND_CHN_TYPE_PSG:
-                SND_SetupChannelPsg(
-                    i,
-                    chn->dutyCycle,
-                    chn->volume & 0xFF,
-                    chn->volume >> 8,
-                    chn->timer,
-                    chn->pan
-                );
-                break;
-            case SND_CHN_TYPE_NOISE:
-                SND_SetupChannelNoise(
-                    i,
-                    chn->volume & 0xFF,
-                    chn->volume >> 8,
-                    chn->timer,
-                    chn->pan
-                );
-                break;
+
+        if (chn->flags.syncFlag & SND_CHN_SYNC_START)
+        {
+            switch (chn->type)
+            {
+                case SND_CHN_TYPE_PCM:
+                    SND_SetupChannelPcm(i,
+                        chn->waveDataPtr,
+                        chn->waveParam.format,
+                        chn->waveParam.loopEnabled ? 1 : 2,
+                        (s32)chn->waveParam.loopStart,
+                        (s32)chn->waveParam.loopLength,
+                        chn->volume & 0xFF,
+                        chn->volume >> 8,
+                        chn->timer,
+                        chn->pan);
+                    break;
+                case SND_CHN_TYPE_PSG:
+                    SND_SetupChannelPsg(i,
+                        chn->dutyCycle,
+                        chn->volume & 0xFF,
+                        chn->volume >> 8,
+                        chn->timer,
+                        chn->pan);
+                    break;
+                case SND_CHN_TYPE_NOISE:
+                    SND_SetupChannelNoise(
+                        i, chn->volume & 0xFF, chn->volume >> 8, chn->timer, chn->pan);
+                    break;
             }
-        } else {
-            if (chn->flags.syncFlag & SND_CHN_SYNC_TIMER) {
+        }
+        else
+        {
+            if (chn->flags.syncFlag & SND_CHN_SYNC_TIMER)
+            {
                 SND_SetChannelTimer(i, chn->timer);
             }
-            if (chn->flags.syncFlag & SND_CHN_SYNC_VOLUME) {
+            if (chn->flags.syncFlag & SND_CHN_SYNC_VOLUME)
+            {
                 SND_SetChannelVolume(i, chn->volume & 0xFF, chn->volume >> 8);
             }
-            if (chn->flags.syncFlag & SND_CHN_SYNC_PAN) {
+            if (chn->flags.syncFlag & SND_CHN_SYNC_PAN)
+            {
                 SND_SetChannelPan(i, chn->pan);
             }
         }
     }
 
-    for (i = 0; i < SND_CHANNEL_COUNT; i++) {
+    for (i = 0; i < SND_CHANNEL_COUNT; i++)
+    {
         chn = &SNDi_Work.channels[i];
 
         if (!chn->flags.syncFlag)
             continue;
-        
+
         if (chn->flags.syncFlag & SND_CHN_SYNC_START)
             reg_SOUNDxCNT_STAT(i) |= 0x80;
         chn->flags.syncFlag = 0;
     }
 }
 
-void SND_ExChannelMain(BOOL step) {
+void SND_ExChannelMain(BOOL step)
+{
     struct SNDExChannel *chn;
     s32 i;
     s32 vol;
@@ -122,7 +127,8 @@ void SND_ExChannelMain(BOOL step) {
     s32 lfo;
     u16 newTimer;
 
-    for (i = 0; i < SND_CHANNEL_COUNT; i++) {
+    for (i = 0; i < SND_CHANNEL_COUNT; i++)
+    {
         vol = 0;
         pitch = 0;
         pan = 0;
@@ -130,11 +136,14 @@ void SND_ExChannelMain(BOOL step) {
 
         if (!chn->flags.active)
             continue;
-        
-        if (chn->flags.start) {
+
+        if (chn->flags.start)
+        {
             chn->flags.syncFlag |= SND_CHN_SYNC_START;
             chn->flags.start = FALSE;
-        } else if (!SND_IsChannelActive(i)) {
+        }
+        else if (!SND_IsChannelActive(i))
+        {
             if (chn->callback)
                 chn->callback(chn, 1, chn->callbackUserData);
             else
@@ -143,7 +152,7 @@ void SND_ExChannelMain(BOOL step) {
             chn->flags.active = FALSE;
             continue;
         }
-        
+
         vol += SNDi_DecibelSquareTable[chn->velocity];
         pitch += (chn->midiKey - chn->rootMidiKey) * 0x40;
 
@@ -156,26 +165,29 @@ void SND_ExChannelMain(BOOL step) {
 
         lfo = ExChannelLfoUpdate(chn, step);
 
-        switch (chn->lfo.param.target) {
-        case SND_LFO_VOLUME:
-            if (vol > -0x8000)
-                vol += lfo;
-            break;
-        case SND_LFO_PAN:
-            pan += lfo;
-            break;
-        case SND_LFO_PITCH:
-            pitch += lfo;
-            break;
+        switch (chn->lfo.param.target)
+        {
+            case SND_LFO_VOLUME:
+                if (vol > -0x8000)
+                    vol += lfo;
+                break;
+            case SND_LFO_PAN:
+                pan += lfo;
+                break;
+            case SND_LFO_PITCH:
+                pitch += lfo;
+                break;
         }
 
         pan += chn->initPan;
-        if (chn->panRange != 127) {
+        if (chn->panRange != 127)
+        {
             pan = (pan * chn->panRange + 0x40) >> 7;
         }
         pan += chn->userPan;
 
-        if (chn->envStatus == SND_ENV_RELEASE && vol <= -723) {
+        if (chn->envStatus == SND_ENV_RELEASE && vol <= -723)
+        {
             chn->flags.syncFlag = SND_CHN_SYNC_STOP;
             if (chn->callback)
                 chn->callback(chn, 1, chn->callbackUserData);
@@ -183,28 +195,33 @@ void SND_ExChannelMain(BOOL step) {
                 chn->priority = 0;
             chn->volume = 0;
             chn->flags.active = 0;
-        } else {
+        }
+        else
+        {
             vol = SND_CalcChannelVolume(vol);
             newTimer = SND_CalcTimer(chn->waveParam.timer, pitch);
 
             if (chn->type == SND_CHN_TYPE_PSG)
                 newTimer &= 0xFFFC;
-            
+
             pan += 0x40;
             if (pan < 0)
                 pan = 0;
             else if (pan > 127)
                 pan = 127;
-            
-            if (vol != chn->volume) {
+
+            if (vol != chn->volume)
+            {
                 chn->volume = (u16)vol;
                 chn->flags.syncFlag |= SND_CHN_SYNC_VOLUME;
             }
-            if (newTimer != chn->timer) {
+            if (newTimer != chn->timer)
+            {
                 chn->timer = (u16)newTimer;
                 chn->flags.syncFlag |= SND_CHN_SYNC_TIMER;
             }
-            if (pan != chn->pan) {
+            if (pan != chn->pan)
+            {
                 chn->pan = (u8)pan;
                 chn->flags.syncFlag |= SND_CHN_SYNC_PAN;
             }
@@ -212,7 +229,9 @@ void SND_ExChannelMain(BOOL step) {
     }
 }
 
-BOOL SND_StartExChannelPcm(struct SNDExChannel *chn, const struct SNDWaveParam *wave, const void *data, s32 length) {
+BOOL SND_StartExChannelPcm(
+    struct SNDExChannel *chn, const struct SNDWaveParam *wave, const void *data, s32 length)
+{
     chn->type = SND_CHN_TYPE_PCM;
     chn->waveParam = *wave;
     chn->waveDataPtr = data;
@@ -220,12 +239,18 @@ BOOL SND_StartExChannelPcm(struct SNDExChannel *chn, const struct SNDWaveParam *
     return TRUE;
 }
 
-BOOL SND_StartExChannelPsg(struct SNDExChannel *chn, s32 duty, s32 length) {
-    if (chn->id < 8) {
+BOOL SND_StartExChannelPsg(struct SNDExChannel *chn, s32 duty, s32 length)
+{
+    if (chn->id < 8)
+    {
         return FALSE;
-    } else if (chn->id > 13) {
+    }
+    else if (chn->id > 13)
+    {
         return FALSE;
-    } else {
+    }
+    else
+    {
         chn->type = SND_CHN_TYPE_PSG;
         chn->dutyCycle = duty;
         chn->waveParam.timer = 8006;
@@ -234,12 +259,18 @@ BOOL SND_StartExChannelPsg(struct SNDExChannel *chn, s32 duty, s32 length) {
     }
 }
 
-BOOL SND_StartExChannelNoise(struct SNDExChannel *chn, s32 length) {
-    if (chn->id < 14) {
+BOOL SND_StartExChannelNoise(struct SNDExChannel *chn, s32 length)
+{
+    if (chn->id < 14)
+    {
         return FALSE;
-    } else if (chn->id > 15) {
+    }
+    else if (chn->id > 15)
+    {
         return FALSE;
-    } else {
+    }
+    else
+    {
         chn->type = SND_CHN_TYPE_NOISE;
         chn->waveParam.timer = 8006;
         ExChannelStart(chn, length);
@@ -247,63 +278,75 @@ BOOL SND_StartExChannelNoise(struct SNDExChannel *chn, s32 length) {
     }
 }
 
-s32 SND_UpdateExChannelEnvelope(struct SNDExChannel *chn, BOOL step) {
+s32 SND_UpdateExChannelEnvelope(struct SNDExChannel *chn, BOOL step)
+{
     s32 sustain;
 
-    if (step) {
-        switch (chn->envStatus) {
-        case SND_ENV_ATTACK:
-            chn->envAttenuation = -((-chn->envAttenuation * chn->envAttack) >> 8);
-            if (chn->envAttenuation == 0)
-                chn->envStatus = SND_ENV_DECAY;
-            break;
-        case SND_ENV_DECAY:
-            sustain = SNDi_DecibelSquareTable[chn->envSustain] << 7;
-            chn->envAttenuation -= chn->envDecay;
-            if (chn->envAttenuation <= sustain) {
-                chn->envAttenuation = sustain;
-                chn->envStatus = SND_ENV_SUSTAIN;
-            }
-            break;
-        case SND_ENV_SUSTAIN:
-            break;
-        case SND_ENV_RELEASE:
-            chn->envAttenuation -= chn->envRelease;
-            break;
+    if (step)
+    {
+        switch (chn->envStatus)
+        {
+            case SND_ENV_ATTACK:
+                chn->envAttenuation = -((-chn->envAttenuation * chn->envAttack) >> 8);
+                if (chn->envAttenuation == 0)
+                    chn->envStatus = SND_ENV_DECAY;
+                break;
+            case SND_ENV_DECAY:
+                sustain = SNDi_DecibelSquareTable[chn->envSustain] << 7;
+                chn->envAttenuation -= chn->envDecay;
+                if (chn->envAttenuation <= sustain)
+                {
+                    chn->envAttenuation = sustain;
+                    chn->envStatus = SND_ENV_SUSTAIN;
+                }
+                break;
+            case SND_ENV_SUSTAIN:
+                break;
+            case SND_ENV_RELEASE:
+                chn->envAttenuation -= chn->envRelease;
+                break;
         }
     }
 
     return chn->envAttenuation >> 7;
 }
 
-void SND_SetExChannelAttack(struct SNDExChannel *chn, s32 attack) {
+void SND_SetExChannelAttack(struct SNDExChannel *chn, s32 attack)
+{
     if (attack < 109)
         chn->envAttack = (u8)(255 - attack);
     else
         chn->envAttack = sAttackCoeffTable[127 - attack];
 }
 
-void SND_SetExChannelDecay(struct SNDExChannel *chn, s32 decay) {
+void SND_SetExChannelDecay(struct SNDExChannel *chn, s32 decay)
+{
     chn->envDecay = CalcDecayCoeff(decay);
 }
 
-void SND_SetExChannelSustain(struct SNDExChannel *chn, s32 sustain) {
+void SND_SetExChannelSustain(struct SNDExChannel *chn, s32 sustain)
+{
     chn->envSustain = (u8)sustain;
 }
 
-void SND_SetExChannelRelease(struct SNDExChannel *chn, s32 release) {
+void SND_SetExChannelRelease(struct SNDExChannel *chn, s32 release)
+{
     chn->envRelease = CalcDecayCoeff(release);
 }
 
-void SND_ReleaseExChannel(struct SNDExChannel *chn) {
+void SND_ReleaseExChannel(struct SNDExChannel *chn)
+{
     chn->envStatus = SND_ENV_RELEASE;
 }
 
-BOOL SND_IsExChannelActive(struct SNDExChannel *chn) {
+BOOL SND_IsExChannelActive(struct SNDExChannel *chn)
+{
     return chn->flags.active;
 }
 
-struct SNDExChannel *SND_AllocExChannel(u32 channelMask, int priority, u32 flags, SNDExChannelCallback callback, void *callbackUserData) {
+struct SNDExChannel *SND_AllocExChannel(
+    u32 channelMask, int priority, u32 flags, SNDExChannelCallback callback, void *callbackUserData)
+{
     struct SNDExChannel *chnPrev;
     int i;
     struct SNDExChannel *chn;
@@ -315,20 +358,23 @@ struct SNDExChannel *SND_AllocExChannel(u32 channelMask, int priority, u32 flags
 
     chnPrev = NULL;
 
-    for (i = 0; i < SND_CHANNEL_COUNT; i++) {
+    for (i = 0; i < SND_CHANNEL_COUNT; i++)
+    {
         channelCandidate = sChannelAllocationOrder[i];
 
-        if (channelMask & (1 << channelCandidate)) {
+        if (channelMask & (1 << channelCandidate))
+        {
             chn = &SNDi_Work.channels[channelCandidate];
 
-            if (chnPrev == NULL) {
+            if (chnPrev == NULL)
+            {
                 chnPrev = chn;
                 continue;
             }
-            
+
             if (chn->priority > chnPrev->priority)
                 continue;
-            
+
             if (chn->priority != chnPrev->priority || ExChannelVolumeCmp(chnPrev, chn) < 0)
                 chnPrev = chn;
         }
@@ -336,35 +382,39 @@ struct SNDExChannel *SND_AllocExChannel(u32 channelMask, int priority, u32 flags
 
     if (chnPrev == NULL)
         return NULL;
-    
+
     if (priority < chnPrev->priority)
         return NULL;
 
     if (chnPrev->callback)
         chnPrev->callback(chnPrev, 0, chnPrev->callbackUserData);
-    
+
     chnPrev->flags.syncFlag = 2;
     chnPrev->flags.active = 0;
     ExChannelSetup(chnPrev, callback, callbackUserData, priority);
     return chnPrev;
 }
 
-void SND_FreeExChannel(struct SNDExChannel *chn) {
-    if (chn) {
+void SND_FreeExChannel(struct SNDExChannel *chn)
+{
+    if (chn)
+    {
         chn->callback = NULL;
         chn->callbackUserData = NULL;
     }
 }
 
-void SND_StopUnlockedChannel(u32 channelMask, u32 weak) {
+void SND_StopUnlockedChannel(u32 channelMask, u32 weak)
+{
     (void)weak;
 
     struct SNDExChannel *chn;
-    
-    for (int i = 0; i < SND_CHANNEL_COUNT && channelMask != 0; i++, channelMask >>= 1) {
+
+    for (int i = 0; i < SND_CHANNEL_COUNT && channelMask != 0; i++, channelMask >>= 1)
+    {
         if ((channelMask & 1) == 0)
             continue;
-        
+
         chn = &SNDi_Work.channels[i];
 
         if (sLockedChannelMask & (1 << i))
@@ -381,12 +431,14 @@ void SND_StopUnlockedChannel(u32 channelMask, u32 weak) {
     }
 }
 
-void SND_LockChannel(u32 channelMask, u32 weak) {
+void SND_LockChannel(u32 channelMask, u32 weak)
+{
     struct SNDExChannel *chn;
     u32 j = channelMask;
     int i = 0;
 
-    for (; i < SND_CHANNEL_COUNT && j != 0; i++, j >>= 1) {
+    for (; i < SND_CHANNEL_COUNT && j != 0; i++, j >>= 1)
+    {
         if ((j & 1) == 0)
             continue;
 
@@ -405,41 +457,57 @@ void SND_LockChannel(u32 channelMask, u32 weak) {
         chn->flags.active = 0;
     }
 
-    if (weak & 1) {
+    if (weak & 1)
+    {
         sWeakLockedChannelMask |= channelMask;
-    } else {
+    }
+    else
+    {
         sLockedChannelMask |= channelMask;
     }
 }
 
-void SND_UnlockChannel(u32 channelMask, u32 weak) {
-    if (weak & 1) {
+void SND_UnlockChannel(u32 channelMask, u32 weak)
+{
+    if (weak & 1)
+    {
         sWeakLockedChannelMask &= ~channelMask;
-    } else {
+    }
+    else
+    {
         sLockedChannelMask &= ~channelMask;
     }
 }
 
-u32 SND_GetLockedChannel(u32 weak) {
-    if (weak & 1) {
+u32 SND_GetLockedChannel(u32 weak)
+{
+    if (weak & 1)
+    {
         return sWeakLockedChannelMask;
-    } else {
+    }
+    else
+    {
         return sLockedChannelMask;
     }
 }
 
-void SND_InvalidateWave(const void *start, const void *end) {
-    for (u8 i = 0; i < SND_CHANNEL_COUNT; i++) {
+void SND_InvalidateWave(const void *start, const void *end)
+{
+    for (u8 i = 0; i < SND_CHANNEL_COUNT; i++)
+    {
         struct SNDExChannel *chn = &SNDi_Work.channels[i];
 
-        if (chn->flags.active && chn->type == 0 && start <= chn->waveDataPtr && chn->waveDataPtr <= end) {
+        if (chn->flags.active && chn->type == 0 && start <= chn->waveDataPtr &&
+            chn->waveDataPtr <= end)
+        {
             chn->flags.start = FALSE;
             SND_StopChannel(i, 0);
         }
     }
 }
 
-void SND_InitLfoParam(struct SNDLfoParam *lfoParam) {
+void SND_InitLfoParam(struct SNDLfoParam *lfoParam)
+{
     lfoParam->target = SND_LFO_PITCH;
     lfoParam->depth = 0;
     lfoParam->range = 1;
@@ -447,19 +515,25 @@ void SND_InitLfoParam(struct SNDLfoParam *lfoParam) {
     lfoParam->delay = 0;
 }
 
-void SND_StartLfo(struct SNDLfo *lfo) {
+void SND_StartLfo(struct SNDLfo *lfo)
+{
     lfo->counter = 0;
     lfo->delayCounter = 0;
 }
 
-void SND_UpdateLfo(struct SNDLfo *lfo) {
-    if (lfo->delayCounter < lfo->param.delay) {
+void SND_UpdateLfo(struct SNDLfo *lfo)
+{
+    if (lfo->delayCounter < lfo->param.delay)
+    {
         lfo->delayCounter++;
-    } else {
+    }
+    else
+    {
         u32 tmp = lfo->counter;
         tmp += lfo->param.speed << 6;
         tmp >>= 8;
-        while (tmp >= 0x80) {
+        while (tmp >= 0x80)
+        {
             tmp -= 0x80;
         }
         lfo->counter += lfo->param.speed << 6;
@@ -468,17 +542,24 @@ void SND_UpdateLfo(struct SNDLfo *lfo) {
     }
 }
 
-int SND_GetLfoValue(struct SNDLfo *lfo) {
-    if (lfo->param.depth == 0) {
+int SND_GetLfoValue(struct SNDLfo *lfo)
+{
+    if (lfo->param.depth == 0)
+    {
         return 0;
-    } else if (lfo->delayCounter < lfo->param.delay) {
+    }
+    else if (lfo->delayCounter < lfo->param.delay)
+    {
         return 0;
-    } else {
+    }
+    else
+    {
         return SND_SinIdx((s32)((u32)lfo->counter >> 8)) * lfo->param.depth * lfo->param.range;
     }
 }
 
-static u16 CalcDecayCoeff(int vol) {
+static u16 CalcDecayCoeff(int vol)
+{
     if (vol == 127)
         return 0xFFFF;
     else if (vol == 126)
@@ -489,7 +570,9 @@ static u16 CalcDecayCoeff(int vol) {
         return (u16)(0x1E00 / (126 - vol));
 }
 
-static void ExChannelSetup(struct SNDExChannel *chn, SNDExChannelCallback callback, void *callbackUserData, int priority) {
+static void ExChannelSetup(
+    struct SNDExChannel *chn, SNDExChannelCallback callback, void *callbackUserData, int priority)
+{
     chn->channelLLNext = NULL;
     chn->callback = callback;
     chn->callbackUserData = callbackUserData;
@@ -518,7 +601,8 @@ static void ExChannelSetup(struct SNDExChannel *chn, SNDExChannelCallback callba
     SND_InitLfoParam(&chn->lfo.param);
 }
 
-static void ExChannelStart(struct SNDExChannel *chn, int length) {
+static void ExChannelStart(struct SNDExChannel *chn, int length)
+{
     chn->envAttenuation = -92544;
     chn->envStatus = 0;
     chn->length = length;
@@ -527,7 +611,8 @@ static void ExChannelStart(struct SNDExChannel *chn, int length) {
     chn->flags.active = TRUE;
 }
 
-static int ExChannelVolumeCmp(struct SNDExChannel *chn_a, struct SNDExChannel *chn_b) {
+static int ExChannelVolumeCmp(struct SNDExChannel *chn_a, struct SNDExChannel *chn_b)
+{
     int vol_a = chn_a->volume & 0xFF;
     int vol_b = chn_b->volume & 0xFF;
 
@@ -537,7 +622,8 @@ static int ExChannelVolumeCmp(struct SNDExChannel *chn_a, struct SNDExChannel *c
     vol_a >>= sSampleDataShiftTable[chn_a->volume >> 8];
     vol_b >>= sSampleDataShiftTable[chn_b->volume >> 8];
 
-    if (vol_a != vol_b) {
+    if (vol_a != vol_b)
+    {
         if (vol_a < vol_b)
             return 1;
         else
@@ -546,14 +632,20 @@ static int ExChannelVolumeCmp(struct SNDExChannel *chn_a, struct SNDExChannel *c
     return 0;
 }
 
-static int ExChannelSweepUpdate(struct SNDExChannel *chn, BOOL step) {
+static int ExChannelSweepUpdate(struct SNDExChannel *chn, BOOL step)
+{
     s64 result;
 
-    if (chn->sweepPitch == 0) {
+    if (chn->sweepPitch == 0)
+    {
         result = 0;
-    } else if (chn->sweepCounter >= chn->sweepLength) {
+    }
+    else if (chn->sweepCounter >= chn->sweepLength)
+    {
         result = 0;
-    } else {
+    }
+    else
+    {
         result = (s64)chn->sweepPitch * (chn->sweepLength - chn->sweepCounter) / chn->sweepLength;
 
         if (step && chn->flags.autoSweep)
@@ -563,25 +655,29 @@ static int ExChannelSweepUpdate(struct SNDExChannel *chn, BOOL step) {
     return (int)result;
 }
 
-static int ExChannelLfoUpdate(struct SNDExChannel *chn, BOOL step) {
+static int ExChannelLfoUpdate(struct SNDExChannel *chn, BOOL step)
+{
     s64 result = SND_GetLfoValue(&chn->lfo);
 
-    if (result != 0) {
-        switch (chn->lfo.param.target) {
-        case SND_LFO_VOLUME:
-            result *= 60;
-            break;
-        case SND_LFO_PITCH:
-            result <<= 6;
-            break;
-        case SND_LFO_PAN:
-            result <<= 6;
-            break;
+    if (result != 0)
+    {
+        switch (chn->lfo.param.target)
+        {
+            case SND_LFO_VOLUME:
+                result *= 60;
+                break;
+            case SND_LFO_PITCH:
+                result <<= 6;
+                break;
+            case SND_LFO_PAN:
+                result <<= 6;
+                break;
         }
         result >>= 14;
     }
 
-    if (step) {
+    if (step)
+    {
         SND_UpdateLfo(&chn->lfo);
     }
 
diff --git a/arm7/lib/src/SND_global.c b/arm7/lib/src/SND_global.c
index 0654934f..c78fcd5f 100644
--- a/arm7/lib/src/SND_global.c
+++ b/arm7/lib/src/SND_global.c
@@ -8,18 +8,22 @@
 #include "registers.h"
 #include "syscall.h"
 
-void SND_Enable(void) {
+void SND_Enable(void)
+{
     reg_SOUNDCNT_MIX |= 0x80;
 }
 
-void SND_Disable(void) {
+void SND_Disable(void)
+{
     reg_SOUNDCNT_MIX &= ~0x80;
 }
 
-void SND_Shutdown(void) {
+void SND_Shutdown(void)
+{
     SND_Disable();
 
-    for (int i = 0; i < SND_CHANNEL_COUNT; i++) {
+    for (int i = 0; i < SND_CHANNEL_COUNT; i++)
+    {
         SND_StopChannel(i, 1);
     }
 
@@ -27,7 +31,8 @@ void SND_Shutdown(void) {
     reg_SNDCAPxCNT(1) = 0;
 }
 
-void SND_BeginSleep(void) {
+void SND_BeginSleep(void)
+{
     SND_Disable();
     SVC_SoundBiasReset(0x80);
     OS_SpinWait(0x40000);
@@ -35,19 +40,24 @@ void SND_BeginSleep(void) {
     reg_POWCNT2 &= ~1;
 }
 
-void SND_EndSleep(void) {
-    reg_POWCNT2 |= 1;   // enable speakers
+void SND_EndSleep(void)
+{
+    reg_POWCNT2 |= 1; // enable speakers
     PMi_SetControl(1);
     SVC_SoundBiasSet(0x100);
     OS_SpinWait(0x7AB80); // what does this wait for and how long does it wait?
     SND_Enable();
 }
 
-void SND_SetMasterVolume(int vol) {
+void SND_SetMasterVolume(int vol)
+{
     reg_SOUNDCNT_VOL = (u8)vol;
 }
 
-void SND_SetOutputSelector(int leftOutputFrom, int rightOutputFrom, int outputCh1ToMixer, int outputCh3ToMixer) {
+void SND_SetOutputSelector(
+    int leftOutputFrom, int rightOutputFrom, int outputCh1ToMixer, int outputCh3ToMixer)
+{
     int masterEnable = (reg_SOUNDCNT_MIX & 0x80) ? 1 : 0;
-    reg_SOUNDCNT_MIX = (u8)((masterEnable << 7) | (outputCh3ToMixer << 5) | (outputCh1ToMixer << 4) | (rightOutputFrom << 2) | (leftOutputFrom));
+    reg_SOUNDCNT_MIX = (u8)((masterEnable << 7) | (outputCh3ToMixer << 5) |
+                            (outputCh1ToMixer << 4) | (rightOutputFrom << 2) | (leftOutputFrom));
 }
diff --git a/arm7/lib/src/SND_main.c b/arm7/lib/src/SND_main.c
index 24e81d2c..fbf84573 100644
--- a/arm7/lib/src/SND_main.c
+++ b/arm7/lib/src/SND_main.c
@@ -12,8 +12,8 @@
 #include "SND_work.h"
 
 #include "OS_alarm.h"
-#include "OS_thread.h"
 #include "OS_message.h"
+#include "OS_thread.h"
 #include "OS_tick.h"
 
 static void FUN_037fc330(void *);
@@ -26,57 +26,74 @@ OSMessageQueue sMessageQueue;
 OSMessage sMessageArray[8];
 u32 sInitialized = 0;
 
-void SND_Init(u32 priority) {
-    if (sInitialized == 0) {
+void SND_Init(u32 priority)
+{
+    if (sInitialized == 0)
+    {
         sInitialized = 1;
         SND_CommandInit();
         SND_CreateThread(priority);
     }
 }
 
-void SND_CreateThread(u32 priority) {
-    OS_CreateThread(&sThread, SndThread, NULL, &sThreadStack[sizeof(sThreadStack)], sizeof(sThreadStack), priority);
+void SND_CreateThread(u32 priority)
+{
+    OS_CreateThread(&sThread,
+        SndThread,
+        NULL,
+        &sThreadStack[sizeof(sThreadStack)],
+        sizeof(sThreadStack),
+        priority);
     OS_WakeupThreadDirect(&sThread);
 }
 
-void SND_InitIntervalTimer(void) {
+void SND_InitIntervalTimer(void)
+{
     OS_InitMessageQueue(&sMessageQueue, sMessageArray, 8);
     OS_CreateAlarm(&sAlarm);
 }
 
-void SND_StartIntervalTimer(void) {
+void SND_StartIntervalTimer(void)
+{
     OSTick tick = OS_GetTick();
     OS_SetPeriodicAlarm(&sAlarm, tick + 0x10000, 2728, FUN_037fc330, NULL);
 }
 
-void SND_StopIntervalTimer(void) {
+void SND_StopIntervalTimer(void)
+{
     OS_CancelAlarm(&sAlarm);
 }
 
-u32 SND_WaitForIntervalTimer(void) {
+u32 SND_WaitForIntervalTimer(void)
+{
     OSMessage result;
     (void)OS_ReceiveMessage(&sMessageQueue, &result, 1);
     return (u32)result;
 }
 
-void SND_SendWakeupMessage(void) {
+void SND_SendWakeupMessage(void)
+{
     (void)OS_SendMessage(&sMessageQueue, (OSMessage)2, 0);
 }
 
-void SNDi_LockMutex(void) {
+void SNDi_LockMutex(void)
+{
     // nothing
 }
 
-void SNDi_UnlockMutex(void) {
+void SNDi_UnlockMutex(void)
+{
     // nothing
 }
 
-static void FUN_037fc330(void *arg) {
+static void FUN_037fc330(void *arg)
+{
     (void)arg;
     (void)OS_SendMessage(&sMessageQueue, (OSMessage)1, 0);
 }
 
-static void SndThread(void *arg) {
+static void SndThread(void *arg)
+{
     (void)arg;
 
     SND_InitIntervalTimer();
@@ -88,18 +105,20 @@ static void SndThread(void *arg) {
     SND_SetMasterVolume(0x7F);
     SND_StartIntervalTimer();
 
-    while (1) {
+    while (1)
+    {
         BOOL update = FALSE;
-        
+
         u32 result = SND_WaitForIntervalTimer();
 
-        switch (result) {
-        case 2:
-            update = FALSE;
-            break;
-        case 1:
-            update = TRUE;
-            break;
+        switch (result)
+        {
+            case 2:
+                update = FALSE;
+                break;
+            case 1:
+                update = TRUE;
+                break;
         }
 
         SND_UpdateExChannel();
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;
     }
 }
diff --git a/arm7/lib/src/SND_util.c b/arm7/lib/src/SND_util.c
index 6a939c02..c9a98c3f 100644
--- a/arm7/lib/src/SND_util.c
+++ b/arm7/lib/src/SND_util.c
@@ -5,16 +5,19 @@
 // TODO remove this extern once the static const definition of it is here
 extern s8 sLfoSinTable[0x21];
 
-u16 SND_CalcTimer(int timer, int pitch) {
+u16 SND_CalcTimer(int timer, int pitch)
+{
     int octave = 0;
     int pitch_normalized = -pitch;
 
-    while (pitch_normalized < 0) {
+    while (pitch_normalized < 0)
+    {
         octave--;
         pitch_normalized += 768;
     }
 
-    while (pitch_normalized >= 768) {
+    while (pitch_normalized >= 768)
+    {
         octave++;
         pitch_normalized -= 768;
     }
@@ -23,19 +26,24 @@ u16 SND_CalcTimer(int timer, int pitch) {
 
     result += 0x10000;
     result *= timer;
-    
+
     int shift = octave - 16;
 
-    if (shift <= 0) {
+    if (shift <= 0)
+    {
         shift = -shift;
         result >>= shift;
-    } else if (shift < 32) {
+    }
+    else if (shift < 32)
+    {
         // what ???
         u64 tmp = result & ~0uLL << (32 - shift);
         if (tmp != 0)
             return 0xFFFF;
         result <<= shift;
-    } else {
+    }
+    else
+    {
         return 0xFFFF;
     }
 
@@ -47,7 +55,8 @@ u16 SND_CalcTimer(int timer, int pitch) {
     return (u16)result;
 }
 
-u16 SND_CalcChannelVolume(int value) {
+u16 SND_CalcChannelVolume(int value)
+{
     if (value < SND_VOL_DB_MIN)
         value = SND_VOL_DB_MIN;
     else if (value > 0)
@@ -68,21 +77,30 @@ u16 SND_CalcChannelVolume(int value) {
     return (u16)(result | (div << 8));
 }
 
-s8 SND_SinIdx(int x) {
+s8 SND_SinIdx(int x)
+{
     // BUG: UB for out of range values
-    
-    if (x < 0x20) {
+
+    if (x < 0x20)
+    {
         return sLfoSinTable[x];
-    } else if (x < 0x40) {
+    }
+    else if (x < 0x40)
+    {
         return sLfoSinTable[0x40 - x];
-    } else if (x < 0x60) {
+    }
+    else if (x < 0x60)
+    {
         return (s8)(-sLfoSinTable[x - 0x40]);
-    } else {
+    }
+    else
+    {
         return (s8)(-sLfoSinTable[0x20 - (x - 0x60)]);
     }
 }
 
-u16 SND_CalcRandom(void) {
+u16 SND_CalcRandom(void)
+{
     static u32 state = 0x12345678;
 
     // values from "Numerical Recipes"
diff --git a/arm7/lib/src/SND_work.c b/arm7/lib/src/SND_work.c
index d40ccdc6..2256ee3f 100644
--- a/arm7/lib/src/SND_work.c
+++ b/arm7/lib/src/SND_work.c
@@ -1,28 +1,32 @@
 #include "SND_work.h"
 
+#include "SND_capture.h"
 #include "SND_channel.h"
 #include "SND_exChannel.h"
-#include "SND_capture.h"
 
 struct SNDWork SNDi_Work;
 struct SNDSharedWork *SNDi_SharedWork;
 
-void SND_SetPlayerLocalVariable(int player, int var, s16 value) {
+void SND_SetPlayerLocalVariable(int player, int var, s16 value)
+{
     SNDi_SharedWork->players[player].localVars[var] = value;
 }
 
-void SND_SetPlayerGlobalVariable(int var, s16 value) {
+void SND_SetPlayerGlobalVariable(int var, s16 value)
+{
     SNDi_SharedWork->globalVars[var] = value;
 }
 
-void SND_UpdateSharedWork(void) {
+void SND_UpdateSharedWork(void)
+{
     u16 channelActiveMask = 0;
     u16 channelCaptureMask = 0;
 
     if (SNDi_SharedWork == NULL)
         return;
-    
-    for (s32 i = 0; i < SND_CHANNEL_COUNT; i++) {
+
+    for (s32 i = 0; i < SND_CHANNEL_COUNT; i++)
+    {
         if (SND_IsChannelActive(i))
             channelActiveMask |= 1 << i;
     }