24 files changed, 323 insertions, 249 deletions
diff --git a/src/audio_core/audio_core.cpp b/src/audio_core/audio_core.cpp
index 8e19ec0c4..0b36dbb03 100644
--- a/src/audio_core/audio_core.cpp
+++ b/src/audio_core/audio_core.cpp
@@ -42,10 +42,18 @@ void Init() {
 }
 void AddAddressSpace(Kernel::VMManager& address_space) {
-    auto r0_vma = address_space.MapBackingMemory(DSP::HLE::region0_base, reinterpret_cast<u8*>(&DSP::HLE::g_regions[0]), sizeof(DSP::HLE::SharedMemory), Kernel::MemoryState::IO).MoveFrom();
+    auto r0_vma = address_space
+                      .MapBackingMemory(DSP::HLE::region0_base,
+                                        reinterpret_cast<u8*>(&DSP::HLE::g_regions[0]),
+                                        sizeof(DSP::HLE::SharedMemory), Kernel::MemoryState::IO)
+                      .MoveFrom();
    address_space.Reprotect(r0_vma, Kernel::VMAPermission::ReadWrite);
-    auto r1_vma = address_space.MapBackingMemory(DSP::HLE::region1_base, reinterpret_cast<u8*>(&DSP::HLE::g_regions[1]), sizeof(DSP::HLE::SharedMemory), Kernel::MemoryState::IO).MoveFrom();
+    auto r1_vma = address_space
+                      .MapBackingMemory(DSP::HLE::region1_base,
+                                        reinterpret_cast<u8*>(&DSP::HLE::g_regions[1]),
+                                        sizeof(DSP::HLE::SharedMemory), Kernel::MemoryState::IO)
+                      .MoveFrom();
    address_space.Reprotect(r1_vma, Kernel::VMAPermission::ReadWrite);
 }
@@ -58,9 +66,9 @@ void SelectSink(std::string sink_id) {
        return;
    }
-    auto iter = std::find_if(g_sink_details.begin(), g_sink_details.end(), [sink_id](const auto& sink_detail) {
+    auto iter =
-        return sink_detail.id == sink_id;
+        std::find_if(g_sink_details.begin(), g_sink_details.end(),
-    });
+                     [sink_id](const auto& sink_detail) { return sink_detail.id == sink_id; });
    if (iter == g_sink_details.end()) {
        LOG_ERROR(Audio, "AudioCore::SelectSink given invalid sink_id");
diff --git a/src/audio_core/audio_core.h b/src/audio_core/audio_core.h
index 7e678aba5..0edf6dd15 100644
--- a/src/audio_core/audio_core.h
+++ b/src/audio_core/audio_core.h
@@ -12,7 +12,7 @@ class VMManager;
 namespace AudioCore {
-constexpr int native_sample_rate = 32728;  ///< 32kHz
+constexpr int native_sample_rate = 32728; ///< 32kHz
 /// Initialise Audio Core
 void Init();
diff --git a/src/audio_core/codec.cpp b/src/audio_core/codec.cpp
index 3e23323f1..c7efae753 100644
--- a/src/audio_core/codec.cpp
+++ b/src/audio_core/codec.cpp
@@ -15,22 +15,25 @@
 namespace Codec {
-StereoBuffer16 DecodeADPCM(const u8* const data, const size_t sample_count, const std::array<s16, 16>& adpcm_coeff, ADPCMState& state) {
+StereoBuffer16 DecodeADPCM(const u8* const data, const size_t sample_count,
+                           const std::array<s16, 16>& adpcm_coeff, ADPCMState& state) {
    // GC-ADPCM with scale factor and variable coefficients.
    // Frames are 8 bytes long containing 14 samples each.
    // Samples are 4 bits (one nibble) long.
    constexpr size_t FRAME_LEN = 8;
    constexpr size_t SAMPLES_PER_FRAME = 14;
-    constexpr std::array<int, 16> SIGNED_NIBBLES {{ 0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1 }};
+    constexpr std::array<int, 16> SIGNED_NIBBLES{
+        {0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1}};
-    const size_t ret_size = sample_count % 2 == 0 ? sample_count : sample_count + 1; // Ensure multiple of two.
+    const size_t ret_size =
+        sample_count % 2 == 0 ? sample_count : sample_count + 1; // Ensure multiple of two.
    StereoBuffer16 ret(ret_size);
-    int yn1 = state.yn1,
+    int yn1 = state.yn1, yn2 = state.yn2;
-        yn2 = state.yn2;
-    const size_t NUM_FRAMES = (sample_count + (SAMPLES_PER_FRAME - 1)) / SAMPLES_PER_FRAME; // Round up.
+    const size_t NUM_FRAMES =
+        (sample_count + (SAMPLES_PER_FRAME - 1)) / SAMPLES_PER_FRAME; // Round up.
    for (size_t framei = 0; framei < NUM_FRAMES; framei++) {
        const int frame_header = data[framei * FRAME_LEN];
        const int scale = 1 << (frame_header & 0xF);
@@ -43,7 +46,8 @@ StereoBuffer16 DecodeADPCM(const u8* const data, const size_t sample_count, cons
        // Decodes an audio sample. One nibble produces one sample.
        const auto decode_sample = [&](const int nibble) -> s16 {
            const int xn = nibble * scale;
-            // We first transform everything into 11 bit fixed point, perform the second order digital filter, then transform back.
+            // We first transform everything into 11 bit fixed point, perform the second order
+            // digital filter, then transform back.
            // 0x400 == 0.5 in 11 bit fixed point.
            // Filter: y[n] = x[n] + 0.5 + c1 * y[n-1] + c2 * y[n-2]
            int val = ((xn << 11) + 0x400 + coef1 * yn1 + coef2 * yn2) >> 11;
@@ -82,7 +86,8 @@ static s16 SignExtendS8(u8 x) {
    return static_cast<s16>(static_cast<s8>(x));
 }
-StereoBuffer16 DecodePCM8(const unsigned num_channels, const u8* const data, const size_t sample_count) {
+StereoBuffer16 DecodePCM8(const unsigned num_channels, const u8* const data,
+                          const size_t sample_count) {
    ASSERT(num_channels == 1 || num_channels == 2);
    StereoBuffer16 ret(sample_count);
@@ -101,7 +106,8 @@ StereoBuffer16 DecodePCM8(const unsigned num_channels, const u8* const data, con
    return ret;
 }
-StereoBuffer16 DecodePCM16(const unsigned num_channels, const u8* const data, const size_t sample_count) {
+StereoBuffer16 DecodePCM16(const unsigned num_channels, const u8* const data,
+                           const size_t sample_count) {
    ASSERT(num_channels == 1 || num_channels == 2);
    StereoBuffer16 ret(sample_count);
@@ -118,5 +124,4 @@ StereoBuffer16 DecodePCM16(const unsigned num_channels, const u8* const data, co
    return ret;
 }
 };
diff --git a/src/audio_core/codec.h b/src/audio_core/codec.h
index e695f2edc..77bbf98b5 100644
--- a/src/audio_core/codec.h
+++ b/src/audio_core/codec.h
@@ -29,7 +29,8 @@ struct ADPCMState {
 * @param state ADPCM state, this is updated with new state
 * @return Decoded stereo signed PCM16 data, sample_count in length
 */
-StereoBuffer16 DecodeADPCM(const u8* const data, const size_t sample_count, const std::array<s16, 16>& adpcm_coeff, ADPCMState& state);
+StereoBuffer16 DecodeADPCM(const u8* const data, const size_t sample_count,
+                           const std::array<s16, 16>& adpcm_coeff, ADPCMState& state);
 /**
 * @param num_channels Number of channels
@@ -37,7 +38,8 @@ StereoBuffer16 DecodeADPCM(const u8* const data, const size_t sample_count, cons
 * @param sample_count Length of buffer in terms of number of samples
 * @return Decoded stereo signed PCM16 data, sample_count in length
 */
-StereoBuffer16 DecodePCM8(const unsigned num_channels, const u8* const data, const size_t sample_count);
+StereoBuffer16 DecodePCM8(const unsigned num_channels, const u8* const data,
+                          const size_t sample_count);
 /**
 * @param num_channels Number of channels
@@ -45,6 +47,6 @@ StereoBuffer16 DecodePCM8(const unsigned num_channels, const u8* const data, con
 * @param sample_count Length of buffer in terms of number of samples
 * @return Decoded stereo signed PCM16 data, sample_count in length
 */
-StereoBuffer16 DecodePCM16(const unsigned num_channels, const u8* const data, const size_t sample_count);
+StereoBuffer16 DecodePCM16(const unsigned num_channels, const u8* const data,
+                           const size_t sample_count);
 };
diff --git a/src/audio_core/hle/common.h b/src/audio_core/hle/common.h
index 596b67eaf..8e7e5c3cd 100644
--- a/src/audio_core/hle/common.h
+++ b/src/audio_core/hle/common.h
@@ -13,23 +13,22 @@ namespace DSP {
 namespace HLE {
 constexpr int num_sources = 24;
-constexpr int samples_per_frame = 160;     ///< Samples per audio frame at native sample rate
+constexpr int samples_per_frame = 160; ///< Samples per audio frame at native sample rate
 /// The final output to the speakers is stereo. Preprocessing output in Source is also stereo.
 using StereoFrame16 = std::array<std::array<s16, 2>, samples_per_frame>;
 /// The DSP is quadraphonic internally.
-using QuadFrame32   = std::array<std::array<s32, 4>, samples_per_frame>;
+using QuadFrame32 = std::array<std::array<s32, 4>, samples_per_frame>;
 /**
 * This performs the filter operation defined by FilterT::ProcessSample on the frame in-place.
 * FilterT::ProcessSample is called sequentially on the samples.
 */
-template<typename FrameT, typename FilterT>
+template <typename FrameT, typename FilterT>
 void FilterFrame(FrameT& frame, FilterT& filter) {
-    std::transform(frame.begin(), frame.end(), frame.begin(), [&filter](const auto& sample) {
+    std::transform(frame.begin(), frame.end(), frame.begin(),
-        return filter.ProcessSample(sample);
+                   [&filter](const auto& sample) { return filter.ProcessSample(sample); });
-    });
 }
 } // namespace HLE
diff --git a/src/audio_core/hle/dsp.cpp b/src/audio_core/hle/dsp.cpp
index 1420bf2dd..5c8afa111 100644
--- a/src/audio_core/hle/dsp.cpp
+++ b/src/audio_core/hle/dsp.cpp
@@ -47,11 +47,9 @@ static SharedMemory& WriteRegion() {
 // Audio processing and mixing
 static std::array<Source, num_sources> sources = {
-    Source(0), Source(1), Source(2), Source(3), Source(4), Source(5),
+    Source(0),  Source(1),  Source(2),  Source(3),  Source(4),  Source(5),  Source(6),  Source(7),
-    Source(6), Source(7), Source(8), Source(9), Source(10), Source(11),
+    Source(8),  Source(9),  Source(10), Source(11), Source(12), Source(13), Source(14), Source(15),
-    Source(12), Source(13), Source(14), Source(15), Source(16), Source(17),
+    Source(16), Source(17), Source(18), Source(19), Source(20), Source(21), Source(22), Source(23)};
-    Source(18), Source(19), Source(20), Source(21), Source(22), Source(23)
-};
 static Mixers mixers;
 static StereoFrame16 GenerateCurrentFrame() {
@@ -62,14 +60,16 @@ static StereoFrame16 GenerateCurrentFrame() {
    // Generate intermediate mixes
    for (size_t i = 0; i < num_sources; i++) {
-        write.source_statuses.status[i] = sources[i].Tick(read.source_configurations.config[i], read.adpcm_coefficients.coeff[i]);
+        write.source_statuses.status[i] =
+            sources[i].Tick(read.source_configurations.config[i], read.adpcm_coefficients.coeff[i]);
        for (size_t mix = 0; mix < 3; mix++) {
            sources[i].MixInto(intermediate_mixes[mix], mix);
        }
    }
    // Generate final mix
-    write.dsp_status = mixers.Tick(read.dsp_configuration, read.intermediate_mix_samples, write.intermediate_mix_samples, intermediate_mixes);
+    write.dsp_status = mixers.Tick(read.dsp_configuration, read.intermediate_mix_samples,
+                                   write.intermediate_mix_samples, intermediate_mixes);
    StereoFrame16 output_frame = mixers.GetOutput();
@@ -152,7 +152,8 @@ void Shutdown() {
 bool Tick() {
    StereoFrame16 current_frame = {};
-    // TODO: Check dsp::DSP semaphore (which indicates emulated application has finished writing to shared memory region)
+    // TODO: Check dsp::DSP semaphore (which indicates emulated application has finished writing to
+    // shared memory region)
    current_frame = GenerateCurrentFrame();
    OutputCurrentFrame(current_frame);
diff --git a/src/audio_core/hle/dsp.h b/src/audio_core/hle/dsp.h
index 565f20b6f..5b216eb87 100644
--- a/src/audio_core/hle/dsp.h
+++ b/src/audio_core/hle/dsp.h
@@ -30,7 +30,8 @@ namespace HLE {
 // Second Region: 0x1FF70000 (Size: 0x8000)
 //
 // The DSP reads from each region alternately based on the frame counter for each region much like a
-// double-buffer. The frame counter is located as the very last u16 of each region and is incremented
+// double-buffer. The frame counter is located as the very last u16 of each region and is
+// incremented
 // each audio tick.
 constexpr VAddr region0_base = 0x1FF50000;
@@ -56,6 +57,7 @@ struct u32_dsp {
    void operator=(u32 new_value) {
        storage = Convert(new_value);
    }
 private:
    static constexpr u32 Convert(u32 value) {
        return (value << 16) | (value >> 16);
@@ -89,11 +91,13 @@ static_assert(std::is_trivially_copyable<u32_dsp>::value, "u32_dsp isn't trivial
 // #: This refers to the order in which they appear in the DspPipe::Audio DSP pipe.
 //    See also: DSP::HLE::PipeRead.
 //
-// Note that the above addresses do vary slightly between audio firmwares observed; the addresses are
+// Note that the above addresses do vary slightly between audio firmwares observed; the addresses
+// are
 // not fixed in stone. The addresses above are only an examplar; they're what this implementation
 // does and provides to applications.
 //
-// Application requests the DSP service to convert DSP addresses into ARM11 virtual addresses using the
+// Application requests the DSP service to convert DSP addresses into ARM11 virtual addresses using
+// the
 // ConvertProcessAddressFromDspDram service call. Applications seem to derive the addresses for the
 // second region via:
 //     second_region_dsp_addr = first_region_dsp_addr | 0x10000
@@ -110,14 +114,17 @@ static_assert(std::is_trivially_copyable<u32_dsp>::value, "u32_dsp isn't trivial
 // GCC versions < 5.0 do not implement std::is_trivially_copyable.
 // Excluding MSVC because it has weird behaviour for std::is_trivially_copyable.
 #if (__GNUC__ >= 5) || defined(__clang__)
-    #define ASSERT_DSP_STRUCT(name, size) \
+#define ASSERT_DSP_STRUCT(name, size)                                                              \
-        static_assert(std::is_standard_layout<name>::value, "DSP structure " #name " doesn't use standard layout"); \
+    static_assert(std::is_standard_layout<name>::value,                                            \
-        static_assert(std::is_trivially_copyable<name>::value, "DSP structure " #name " isn't trivially copyable"); \
+                  "DSP structure " #name " doesn't use standard layout");                          \
-        static_assert(sizeof(name) == (size), "Unexpected struct size for DSP structure " #name)
+    static_assert(std::is_trivially_copyable<name>::value,                                         \
+                  "DSP structure " #name " isn't trivially copyable");                             \
+    static_assert(sizeof(name) == (size), "Unexpected struct size for DSP structure " #name)
 #else
-    #define ASSERT_DSP_STRUCT(name, size) \
+#define ASSERT_DSP_STRUCT(name, size)                                                              \
-        static_assert(std::is_standard_layout<name>::value, "DSP structure " #name " doesn't use standard layout"); \
+    static_assert(std::is_standard_layout<name>::value,                                            \
-        static_assert(sizeof(name) == (size), "Unexpected struct size for DSP structure " #name)
+                  "DSP structure " #name " doesn't use standard layout");                          \
+    static_assert(sizeof(name) == (size), "Unexpected struct size for DSP structure " #name)
 #endif
 struct SourceConfiguration {
@@ -130,7 +137,8 @@ struct SourceConfiguration {
            BitField<0, 1, u32_le> format_dirty;
            BitField<1, 1, u32_le> mono_or_stereo_dirty;
            BitField<2, 1, u32_le> adpcm_coefficients_dirty;
-            BitField<3, 1, u32_le> partial_embedded_buffer_dirty; ///< Tends to be set when a looped buffer is queued.
+            BitField<3, 1, u32_le>
+                partial_embedded_buffer_dirty; ///< Tends to be set when a looped buffer is queued.
            BitField<4, 1, u32_le> partial_reset_flag;
            BitField<16, 1, u32_le> enable_dirty;
@@ -138,7 +146,8 @@ struct SourceConfiguration {
            BitField<18, 1, u32_le> rate_multiplier_dirty;
            BitField<19, 1, u32_le> buffer_queue_dirty;
            BitField<20, 1, u32_le> loop_related_dirty;
-            BitField<21, 1, u32_le> play_position_dirty; ///< Tends to also be set when embedded buffer is updated.
+            BitField<21, 1, u32_le>
+                play_position_dirty; ///< Tends to also be set when embedded buffer is updated.
            BitField<22, 1, u32_le> filters_enabled_dirty;
            BitField<23, 1, u32_le> simple_filter_dirty;
            BitField<24, 1, u32_le> biquad_filter_dirty;
@@ -164,11 +173,7 @@ struct SourceConfiguration {
        /// Multiplier for sample rate. Resampling occurs with the selected interpolation method.
        float_le rate_multiplier;
-        enum class InterpolationMode : u8 {
+        enum class InterpolationMode : u8 { Polyphase = 0, Linear = 1, None = 2 };
-            Polyphase = 0,
-            Linear = 1,
-            None = 2
-        };
        InterpolationMode interpolation_mode;
        INSERT_PADDING_BYTES(1); ///< Interpolation related
@@ -191,7 +196,8 @@ struct SourceConfiguration {
         * This is a normalised biquad filter (second-order).
         * The transfer function of this filter is:
         *     H(z) = (b0 + b1 z^-1 + b2 z^-2) / (1 - a1 z^-1 - a2 z^-2)
-         * Nintendo chose to negate the feedbackward coefficients. This differs from standard notation
+         * Nintendo chose to negate the feedbackward coefficients. This differs from standard
+         * notation
         * as in: https://ccrma.stanford.edu/~jos/filters/Direct_Form_I.html
         * Values are signed fixed point with 14 fractional bits.
         */
@@ -239,23 +245,24 @@ struct SourceConfiguration {
            /// Is a looping buffer.
            u8 is_looping;
-            /// This value is shown in SourceStatus::previous_buffer_id when this buffer has finished.
+            /// This value is shown in SourceStatus::previous_buffer_id when this buffer has
+            /// finished.
            /// This allows the emulated application to tell what buffer is currently playing
            u16_le buffer_id;
            INSERT_PADDING_DSPWORDS(1);
        };
-        u16_le buffers_dirty;             ///< Bitmap indicating which buffers are dirty (bit i -> buffers[i])
+        u16_le buffers_dirty; ///< Bitmap indicating which buffers are dirty (bit i -> buffers[i])
-        Buffer buffers[4];                ///< Queued Buffers
+        Buffer buffers[4];    ///< Queued Buffers
        // Playback controls
        u32_dsp loop_related;
        u8 enable;
        INSERT_PADDING_BYTES(1);
-        u16_le sync;                      ///< Application-side sync (See also: SourceStatus::sync)
+        u16_le sync;           ///< Application-side sync (See also: SourceStatus::sync)
-        u32_dsp play_position;            ///< Position. (Units: number of samples)
+        u32_dsp play_position; ///< Position. (Units: number of samples)
        INSERT_PADDING_DSPWORDS(2);
        // Embedded Buffer
@@ -268,16 +275,9 @@ struct SourceConfiguration {
        /// Note a sample takes up different number of bytes in different buffer formats.
        u32_dsp length;
-        enum class MonoOrStereo : u16_le {
+        enum class MonoOrStereo : u16_le { Mono = 1, Stereo = 2 };
-            Mono = 1,
-            Stereo = 2
-        };
-        enum class Format : u16_le {
+        enum class Format : u16_le { PCM8 = 0, PCM16 = 1, ADPCM = 2 };
-            PCM8 = 0,
-            PCM16 = 1,
-            ADPCM = 2
-        };
        union {
            u16_le flags1_raw;
@@ -299,10 +299,11 @@ struct SourceConfiguration {
        union {
            u16_le flags2_raw;
            BitField<0, 1, u16_le> adpcm_dirty; ///< Has the ADPCM info above been changed?
-            BitField<1, 1, u16_le> is_looping; ///< Is this a looping buffer?
+            BitField<1, 1, u16_le> is_looping;  ///< Is this a looping buffer?
        };
-        /// Buffer id of embedded buffer (used as a buffer id in SourceStatus to reference this buffer).
+        /// Buffer id of embedded buffer (used as a buffer id in SourceStatus to reference this
+        /// buffer).
        u16_le buffer_id;
    };
@@ -313,11 +314,11 @@ ASSERT_DSP_STRUCT(SourceConfiguration::Configuration::Buffer, 20);
 struct SourceStatus {
    struct Status {
-        u8 is_enabled;               ///< Is this channel enabled? (Doesn't have to be playing anything.)
+        u8 is_enabled; ///< Is this channel enabled? (Doesn't have to be playing anything.)
-        u8 current_buffer_id_dirty;  ///< Non-zero when current_buffer_id changes
+        u8 current_buffer_id_dirty; ///< Non-zero when current_buffer_id changes
-        u16_le sync;                 ///< Is set by the DSP to the value of SourceConfiguration::sync
+        u16_le sync;                ///< Is set by the DSP to the value of SourceConfiguration::sync
-        u32_dsp buffer_position;     ///< Number of samples into the current buffer
+        u32_dsp buffer_position;    ///< Number of samples into the current buffer
-        u16_le current_buffer_id;    ///< Updated when a buffer finishes playing
+        u16_le current_buffer_id;   ///< Updated when a buffer finishes playing
        INSERT_PADDING_DSPWORDS(1);
    };
@@ -347,16 +348,13 @@ struct DspConfiguration {
        BitField<28, 1, u32_le> headphones_connected_dirty;
    };
-    /// The DSP has three intermediate audio mixers. This controls the volume level (0.0-1.0) for each at the final mixer
+    /// The DSP has three intermediate audio mixers. This controls the volume level (0.0-1.0) for
+    /// each at the final mixer
    float_le volume[3];
    INSERT_PADDING_DSPWORDS(3);
-    enum class OutputFormat : u16_le {
+    enum class OutputFormat : u16_le { Mono = 0, Stereo = 1, Surround = 2 };
-        Mono = 0,
-        Stereo = 1,
-        Surround = 2
-    };
    OutputFormat output_format;
@@ -388,8 +386,9 @@ struct DspConfiguration {
        u16_le enable;
        INSERT_PADDING_DSPWORDS(1);
        u16_le outputs;
-        u32_dsp work_buffer_address; ///< The application allocates a block of memory for the DSP to use as a work buffer.
+        u32_dsp work_buffer_address; ///< The application allocates a block of memory for the DSP to
-        u16_le frame_count;  ///< Frames to delay by
+                                     /// use as a work buffer.
+        u16_le frame_count;          ///< Frames to delay by
        // Coefficients
        s16_le g; ///< Fixed point with 7 fractional bits
@@ -506,21 +505,36 @@ ASSERT_DSP_STRUCT(SharedMemory, 0x8000);
 extern std::array<SharedMemory, 2> g_regions;
 // Structures must have an offset that is a multiple of two.
-static_assert(offsetof(SharedMemory, frame_counter) % 2 == 0, "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+static_assert(offsetof(SharedMemory, frame_counter) % 2 == 0,
-static_assert(offsetof(SharedMemory, source_configurations) % 2 == 0, "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+              "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
-static_assert(offsetof(SharedMemory, source_statuses) % 2 == 0, "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+static_assert(offsetof(SharedMemory, source_configurations) % 2 == 0,
-static_assert(offsetof(SharedMemory, adpcm_coefficients) % 2 == 0, "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+              "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
-static_assert(offsetof(SharedMemory, dsp_configuration) % 2 == 0, "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+static_assert(offsetof(SharedMemory, source_statuses) % 2 == 0,
-static_assert(offsetof(SharedMemory, dsp_status) % 2 == 0, "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+              "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
-static_assert(offsetof(SharedMemory, final_samples) % 2 == 0, "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+static_assert(offsetof(SharedMemory, adpcm_coefficients) % 2 == 0,
-static_assert(offsetof(SharedMemory, intermediate_mix_samples) % 2 == 0, "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+              "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
-static_assert(offsetof(SharedMemory, compressor) % 2 == 0, "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+static_assert(offsetof(SharedMemory, dsp_configuration) % 2 == 0,
-static_assert(offsetof(SharedMemory, dsp_debug) % 2 == 0, "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+              "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
-static_assert(offsetof(SharedMemory, unknown10) % 2 == 0, "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+static_assert(offsetof(SharedMemory, dsp_status) % 2 == 0,
-static_assert(offsetof(SharedMemory, unknown11) % 2 == 0, "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+              "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
-static_assert(offsetof(SharedMemory, unknown12) % 2 == 0, "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+static_assert(offsetof(SharedMemory, final_samples) % 2 == 0,
-static_assert(offsetof(SharedMemory, unknown13) % 2 == 0, "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+              "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
-static_assert(offsetof(SharedMemory, unknown14) % 2 == 0, "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+static_assert(offsetof(SharedMemory, intermediate_mix_samples) % 2 == 0,
+              "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+static_assert(offsetof(SharedMemory, compressor) % 2 == 0,
+              "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+static_assert(offsetof(SharedMemory, dsp_debug) % 2 == 0,
+              "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+static_assert(offsetof(SharedMemory, unknown10) % 2 == 0,
+              "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+static_assert(offsetof(SharedMemory, unknown11) % 2 == 0,
+              "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+static_assert(offsetof(SharedMemory, unknown12) % 2 == 0,
+              "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+static_assert(offsetof(SharedMemory, unknown13) % 2 == 0,
+              "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
+static_assert(offsetof(SharedMemory, unknown14) % 2 == 0,
+              "Structures in DSP::HLE::SharedMemory must be 2-byte aligned");
 #undef INSERT_PADDING_DSPWORDS
 #undef ASSERT_DSP_STRUCT
diff --git a/src/audio_core/hle/filter.cpp b/src/audio_core/hle/filter.cpp
index 2c65ef026..ab8814e59 100644
--- a/src/audio_core/hle/filter.cpp
+++ b/src/audio_core/hle/filter.cpp
@@ -59,7 +59,8 @@ void SourceFilters::SimpleFilter::Reset() {
    b0 = 1 << 15;
 }
-void SourceFilters::SimpleFilter::Configure(SourceConfiguration::Configuration::SimpleFilter config) {
+void SourceFilters::SimpleFilter::Configure(
+    SourceConfiguration::Configuration::SimpleFilter config) {
    a1 = config.a1;
    b0 = config.b0;
 }
@@ -88,7 +89,8 @@ void SourceFilters::BiquadFilter::Reset() {
    b0 = 1 << 14;
 }
-void SourceFilters::BiquadFilter::Configure(SourceConfiguration::Configuration::BiquadFilter config) {
+void SourceFilters::BiquadFilter::Configure(
+    SourceConfiguration::Configuration::BiquadFilter config) {
    a1 = config.a1;
    a2 = config.a2;
    b0 = config.b0;
diff --git a/src/audio_core/hle/filter.h b/src/audio_core/hle/filter.h
index 43d2035cd..73d5ce670 100644
--- a/src/audio_core/hle/filter.h
+++ b/src/audio_core/hle/filter.h
@@ -17,7 +17,9 @@ namespace HLE {
 /// Preprocessing filters. There is an independent set of filters for each Source.
 class SourceFilters final {
 public:
-    SourceFilters() { Reset(); }
+    SourceFilters() {
+        Reset();
+    }
    /// Reset internal state.
    void Reset();
@@ -54,7 +56,9 @@ private:
    bool biquad_filter_enabled;
    struct SimpleFilter {
-        SimpleFilter() { Reset(); }
+        SimpleFilter() {
+            Reset();
+        }
        /// Resets internal state.
        void Reset();
@@ -80,7 +84,9 @@ private:
    } simple_filter;
    struct BiquadFilter {
-        BiquadFilter() { Reset(); }
+        BiquadFilter() {
+            Reset();
+        }
        /// Resets internal state.
        void Reset();
diff --git a/src/audio_core/hle/mixers.cpp b/src/audio_core/hle/mixers.cpp
index 18335f7f0..a661a7b27 100644
--- a/src/audio_core/hle/mixers.cpp
+++ b/src/audio_core/hle/mixers.cpp
@@ -20,11 +20,9 @@ void Mixers::Reset() {
    state = {};
 }
-DspStatus Mixers::Tick(DspConfiguration& config,
+DspStatus Mixers::Tick(DspConfiguration& config, const IntermediateMixSamples& read_samples,
-        const IntermediateMixSamples& read_samples,
+                       IntermediateMixSamples& write_samples,
-        IntermediateMixSamples& write_samples,
+                       const std::array<QuadFrame32, 3>& input) {
-        const std::array<QuadFrame32, 3>& input)
-{
    ParseConfig(config);
    AuxReturn(read_samples);
@@ -73,13 +71,15 @@ void Mixers::ParseConfig(DspConfiguration& config) {
    if (config.output_format_dirty) {
        config.output_format_dirty.Assign(0);
        state.output_format = config.output_format;
-        LOG_TRACE(Audio_DSP, "mixers output_format = %zu", static_cast<size_t>(config.output_format));
+        LOG_TRACE(Audio_DSP, "mixers output_format = %zu",
+                  static_cast<size_t>(config.output_format));
    }
    if (config.headphones_connected_dirty) {
        config.headphones_connected_dirty.Assign(0);
        // Do nothing.
-        // (Note: Whether headphones are connected does affect coefficients used for surround sound.)
+        // (Note: Whether headphones are connected does affect coefficients used for surround
+        // sound.)
        LOG_TRACE(Audio_DSP, "mixers headphones_connected=%hu", config.headphones_connected);
    }
@@ -94,11 +94,10 @@ static s16 ClampToS16(s32 value) {
    return static_cast<s16>(MathUtil::Clamp(value, -32768, 32767));
 }
-static std::array<s16, 2> AddAndClampToS16(const std::array<s16, 2>& a, const std::array<s16, 2>& b) {
+static std::array<s16, 2> AddAndClampToS16(const std::array<s16, 2>& a,
-    return {
+                                           const std::array<s16, 2>& b) {
-        ClampToS16(static_cast<s32>(a[0]) + static_cast<s32>(b[0])),
+    return {ClampToS16(static_cast<s32>(a[0]) + static_cast<s32>(b[0])),
-        ClampToS16(static_cast<s32>(a[1]) + static_cast<s32>(b[1]))
+            ClampToS16(static_cast<s32>(a[1]) + static_cast<s32>(b[1]))};
-    };
 }
 void Mixers::DownmixAndMixIntoCurrentFrame(float gain, const QuadFrame32& samples) {
@@ -106,27 +105,33 @@ void Mixers::DownmixAndMixIntoCurrentFrame(float gain, const QuadFrame32& sample
    switch (state.output_format) {
    case OutputFormat::Mono:
-        std::transform(current_frame.begin(), current_frame.end(), samples.begin(), current_frame.begin(),
+        std::transform(
-            [gain](const std::array<s16, 2>& accumulator, const std::array<s32, 4>& sample) -> std::array<s16, 2> {
+            current_frame.begin(), current_frame.end(), samples.begin(), current_frame.begin(),
+            [gain](const std::array<s16, 2>& accumulator,
+                   const std::array<s32, 4>& sample) -> std::array<s16, 2> {
                // Downmix to mono
-                s16 mono = ClampToS16(static_cast<s32>((gain * sample[0] + gain * sample[1] + gain * sample[2] + gain * sample[3]) / 2));
+                s16 mono = ClampToS16(static_cast<s32>(
+                    (gain * sample[0] + gain * sample[1] + gain * sample[2] + gain * sample[3]) /
+                    2));
                // Mix into current frame
-                return AddAndClampToS16(accumulator, { mono, mono });
+                return AddAndClampToS16(accumulator, {mono, mono});
            });
        return;
    case OutputFormat::Surround:
-        // TODO(merry): Implement surround sound.
+    // TODO(merry): Implement surround sound.
-        // fallthrough
+    // fallthrough
    case OutputFormat::Stereo:
-        std::transform(current_frame.begin(), current_frame.end(), samples.begin(), current_frame.begin(),
+        std::transform(
-            [gain](const std::array<s16, 2>& accumulator, const std::array<s32, 4>& sample) -> std::array<s16, 2> {
+            current_frame.begin(), current_frame.end(), samples.begin(), current_frame.begin(),
+            [gain](const std::array<s16, 2>& accumulator,
+                   const std::array<s32, 4>& sample) -> std::array<s16, 2> {
                // Downmix to stereo
                s16 left = ClampToS16(static_cast<s32>(gain * sample[0] + gain * sample[2]));
                s16 right = ClampToS16(static_cast<s32>(gain * sample[1] + gain * sample[3]));
                // Mix into current frame
-                return AddAndClampToS16(accumulator, { left, right });
+                return AddAndClampToS16(accumulator, {left, right});
            });
        return;
    }
@@ -135,12 +140,14 @@ void Mixers::DownmixAndMixIntoCurrentFrame(float gain, const QuadFrame32& sample
 }
 void Mixers::AuxReturn(const IntermediateMixSamples& read_samples) {
-    // NOTE: read_samples.mix{1,2}.pcm32 annoyingly have their dimensions in reverse order to QuadFrame32.
+    // NOTE: read_samples.mix{1,2}.pcm32 annoyingly have their dimensions in reverse order to
+    // QuadFrame32.
    if (state.mixer1_enabled) {
        for (size_t sample = 0; sample < samples_per_frame; sample++) {
            for (size_t channel = 0; channel < 4; channel++) {
-                state.intermediate_mix_buffer[1][sample][channel] = read_samples.mix1.pcm32[channel][sample];
+                state.intermediate_mix_buffer[1][sample][channel] =
+                    read_samples.mix1.pcm32[channel][sample];
            }
        }
    }
@@ -148,14 +155,17 @@ void Mixers::AuxReturn(const IntermediateMixSamples& read_samples) {
    if (state.mixer2_enabled) {
        for (size_t sample = 0; sample < samples_per_frame; sample++) {
            for (size_t channel = 0; channel < 4; channel++) {
-                state.intermediate_mix_buffer[2][sample][channel] = read_samples.mix2.pcm32[channel][sample];
+                state.intermediate_mix_buffer[2][sample][channel] =
+                    read_samples.mix2.pcm32[channel][sample];
            }
        }
    }
 }
-void Mixers::AuxSend(IntermediateMixSamples& write_samples, const std::array<QuadFrame32, 3>& input) {
+void Mixers::AuxSend(IntermediateMixSamples& write_samples,
-    // NOTE: read_samples.mix{1,2}.pcm32 annoyingly have their dimensions in reverse order to QuadFrame32.
+                     const std::array<QuadFrame32, 3>& input) {
+    // NOTE: read_samples.mix{1,2}.pcm32 annoyingly have their dimensions in reverse order to
+    // QuadFrame32.
    state.intermediate_mix_buffer[0] = input[0];
@@ -184,7 +194,8 @@ void Mixers::MixCurrentFrame() {
    current_frame.fill({});
    for (size_t mix = 0; mix < 3; mix++) {
-        DownmixAndMixIntoCurrentFrame(state.intermediate_mixer_volume[mix], state.intermediate_mix_buffer[mix]);
+        DownmixAndMixIntoCurrentFrame(state.intermediate_mixer_volume[mix],
+                                      state.intermediate_mix_buffer[mix]);
    }
    // TODO(merry): Compressor. (We currently assume a disabled compressor.)
diff --git a/src/audio_core/hle/mixers.h b/src/audio_core/hle/mixers.h
index b52952eb5..537c3a3b9 100644
--- a/src/audio_core/hle/mixers.h
+++ b/src/audio_core/hle/mixers.h
@@ -20,10 +20,8 @@ public:
    void Reset();
-    DspStatus Tick(DspConfiguration& config,
+    DspStatus Tick(DspConfiguration& config, const IntermediateMixSamples& read_samples,
-                   const IntermediateMixSamples& read_samples,
+                   IntermediateMixSamples& write_samples, const std::array<QuadFrame32, 3>& input);
-                   IntermediateMixSamples& write_samples,
-                   const std::array<QuadFrame32, 3>& input);
    StereoFrame16 GetOutput() const {
        return current_frame;
@@ -53,7 +51,8 @@ private:
    void AuxSend(IntermediateMixSamples& write_samples, const std::array<QuadFrame32, 3>& input);
    /// INTERNAL: Mix current_frame.
    void MixCurrentFrame();
-    /// INTERNAL: Downmix from quadraphonic to stereo based on status.output_format and accumulate into current_frame.
+    /// INTERNAL: Downmix from quadraphonic to stereo based on status.output_format and accumulate
+    /// into current_frame.
    void DownmixAndMixIntoCurrentFrame(float gain, const QuadFrame32& samples);
    /// INTERNAL: Generate DspStatus based on internal state.
    DspStatus GetCurrentStatus() const;
diff --git a/src/audio_core/hle/pipe.cpp b/src/audio_core/hle/pipe.cpp
index 44dff1345..fe67d2503 100644
--- a/src/audio_core/hle/pipe.cpp
+++ b/src/audio_core/hle/pipe.cpp
@@ -44,8 +44,10 @@ std::vector<u8> PipeRead(DspPipe pipe_number, u32 length) {
    std::vector<u8>& data = pipe_data[pipe_index];
    if (length > data.size()) {
-        LOG_WARNING(Audio_DSP, "pipe_number = %zu is out of data, application requested read of %u but %zu remain",
+        LOG_WARNING(
-                    pipe_index, length, data.size());
+            Audio_DSP,
+            "pipe_number = %zu is out of data, application requested read of %u but %zu remain",
+            pipe_index, length, data.size());
        length = static_cast<u32>(data.size());
    }
@@ -95,8 +97,7 @@ static void AudioPipeWriteStructAddresses() {
        0x8000 + offsetof(SharedMemory, unknown11) / 2,
        0x8000 + offsetof(SharedMemory, unknown12) / 2,
        0x8000 + offsetof(SharedMemory, unknown13) / 2,
-        0x8000 + offsetof(SharedMemory, unknown14) / 2
+        0x8000 + offsetof(SharedMemory, unknown14) / 2};
-    };
    // Begin with a u16 denoting the number of structs.
    WriteU16(DspPipe::Audio, static_cast<u16>(struct_addresses.size()));
@@ -112,16 +113,12 @@ void PipeWrite(DspPipe pipe_number, const std::vector<u8>& buffer) {
    switch (pipe_number) {
    case DspPipe::Audio: {
        if (buffer.size() != 4) {
-            LOG_ERROR(Audio_DSP, "DspPipe::Audio: Unexpected buffer length %zu was written", buffer.size());
+            LOG_ERROR(Audio_DSP, "DspPipe::Audio: Unexpected buffer length %zu was written",
+                      buffer.size());
            return;
        }
-        enum class StateChange {
+        enum class StateChange { Initalize = 0, Shutdown = 1, Wakeup = 2, Sleep = 3 };
-            Initalize = 0,
-            Shutdown = 1,
-            Wakeup = 2,
-            Sleep = 3
-        };
        // The difference between Initialize and Wakeup is that Input state is maintained
        // when sleeping but isn't when turning it off and on again. (TODO: Implement this.)
@@ -152,7 +149,9 @@ void PipeWrite(DspPipe pipe_number, const std::vector<u8>& buffer) {
            dsp_state = DspState::Sleeping;
            break;
        default:
-            LOG_ERROR(Audio_DSP, "Application has requested unknown state transition of DSP hardware %hhu", buffer[0]);
+            LOG_ERROR(Audio_DSP,
+                      "Application has requested unknown state transition of DSP hardware %hhu",
+                      buffer[0]);
            dsp_state = DspState::Off;
            break;
        }
@@ -160,7 +159,8 @@ void PipeWrite(DspPipe pipe_number, const std::vector<u8>& buffer) {
        return;
    }
    default:
-        LOG_CRITICAL(Audio_DSP, "pipe_number = %zu unimplemented", static_cast<size_t>(pipe_number));
+        LOG_CRITICAL(Audio_DSP, "pipe_number = %zu unimplemented",
+                     static_cast<size_t>(pipe_number));
        UNIMPLEMENTED();
        return;
    }
diff --git a/src/audio_core/hle/pipe.h b/src/audio_core/hle/pipe.h
index b714c0496..73b857a90 100644
--- a/src/audio_core/hle/pipe.h
+++ b/src/audio_core/hle/pipe.h
@@ -15,20 +15,17 @@ namespace HLE {
 /// Reset the pipes by setting pipe positions back to the beginning.
 void ResetPipes();
-enum class DspPipe {
+enum class DspPipe { Debug = 0, Dma = 1, Audio = 2, Binary = 3 };
-    Debug = 0,
-    Dma = 1,
-    Audio = 2,
-    Binary = 3
-};
 constexpr size_t NUM_DSP_PIPE = 8;
 /**
 * Reads `length` bytes from the DSP pipe identified with `pipe_number`.
 * @note Can read up to the maximum value of a u16 in bytes (65,535).
- * @note IF an error is encoutered with either an invalid `pipe_number` or `length` value, an empty vector will be returned.
+ * @note IF an error is encoutered with either an invalid `pipe_number` or `length` value, an empty
+ * vector will be returned.
 * @note IF `length` is set to 0, an empty vector will be returned.
- * @note IF `length` is greater than the amount of data available, this function will only read the available amount.
+ * @note IF `length` is greater than the amount of data available, this function will only read the
+ * available amount.
 * @param pipe_number a `DspPipe`
 * @param length the number of bytes to read. The max is 65,535 (max of u16).
 * @returns a vector of bytes from the specified pipe. On error, will be empty.
@@ -49,11 +46,7 @@ size_t GetPipeReadableSize(DspPipe pipe_number);
 */
 void PipeWrite(DspPipe pipe_number, const std::vector<u8>& buffer);
-enum class DspState {
+enum class DspState { Off, On, Sleeping };
-    Off,
-    On,
-    Sleeping
-};
 /// Get the state of the DSP
 DspState GetDspState();
diff --git a/src/audio_core/hle/source.cpp b/src/audio_core/hle/source.cpp
index 30552fe26..fad0ce2ad 100644
--- a/src/audio_core/hle/source.cpp
+++ b/src/audio_core/hle/source.cpp
@@ -18,7 +18,8 @@
 namespace DSP {
 namespace HLE {
-SourceStatus::Status Source::Tick(SourceConfiguration::Configuration& config, const s16_le (&adpcm_coeffs)[16]) {
+SourceStatus::Status Source::Tick(SourceConfiguration::Configuration& config,
+                                  const s16_le (&adpcm_coeffs)[16]) {
    ParseConfig(config, adpcm_coeffs);
    if (state.enabled) {
@@ -47,7 +48,8 @@ void Source::Reset() {
    state = {};
 }
-void Source::ParseConfig(SourceConfiguration::Configuration& config, const s16_le (&adpcm_coeffs)[16]) {
+void Source::ParseConfig(SourceConfiguration::Configuration& config,
+                         const s16_le (&adpcm_coeffs)[16]) {
    if (!config.dirty_raw) {
        return;
    }
@@ -82,7 +84,8 @@ void Source::ParseConfig(SourceConfiguration::Configuration& config, const s16_l
        LOG_TRACE(Audio_DSP, "source_id=%zu rate=%f", source_id, state.rate_multiplier);
        if (state.rate_multiplier <= 0) {
-            LOG_ERROR(Audio_DSP, "Was given an invalid rate multiplier: source_id=%zu rate=%f", source_id, state.rate_multiplier);
+            LOG_ERROR(Audio_DSP, "Was given an invalid rate multiplier: source_id=%zu rate=%f",
+                      source_id, state.rate_multiplier);
            state.rate_multiplier = 1.0f;
            // Note: Actual firmware starts producing garbage if this occurs.
        }
@@ -90,37 +93,39 @@ void Source::ParseConfig(SourceConfiguration::Configuration& config, const s16_l
    if (config.adpcm_coefficients_dirty) {
        config.adpcm_coefficients_dirty.Assign(0);
-        std::transform(adpcm_coeffs, adpcm_coeffs + state.adpcm_coeffs.size(), state.adpcm_coeffs.begin(),
+        std::transform(adpcm_coeffs, adpcm_coeffs + state.adpcm_coeffs.size(),
-            [](const auto& coeff) { return static_cast<s16>(coeff); });
+                       state.adpcm_coeffs.begin(),
+                       [](const auto& coeff) { return static_cast<s16>(coeff); });
        LOG_TRACE(Audio_DSP, "source_id=%zu adpcm update", source_id);
    }
    if (config.gain_0_dirty) {
        config.gain_0_dirty.Assign(0);
        std::transform(config.gain[0], config.gain[0] + state.gain[0].size(), state.gain[0].begin(),
-            [](const auto& coeff) { return static_cast<float>(coeff); });
+                       [](const auto& coeff) { return static_cast<float>(coeff); });
        LOG_TRACE(Audio_DSP, "source_id=%zu gain 0 update", source_id);
    }
    if (config.gain_1_dirty) {
        config.gain_1_dirty.Assign(0);
        std::transform(config.gain[1], config.gain[1] + state.gain[1].size(), state.gain[1].begin(),
-            [](const auto& coeff) { return static_cast<float>(coeff); });
+                       [](const auto& coeff) { return static_cast<float>(coeff); });
        LOG_TRACE(Audio_DSP, "source_id=%zu gain 1 update", source_id);
    }
    if (config.gain_2_dirty) {
        config.gain_2_dirty.Assign(0);
        std::transform(config.gain[2], config.gain[2] + state.gain[2].size(), state.gain[2].begin(),
-            [](const auto& coeff) { return static_cast<float>(coeff); });
+                       [](const auto& coeff) { return static_cast<float>(coeff); });
        LOG_TRACE(Audio_DSP, "source_id=%zu gain 2 update", source_id);
    }
    if (config.filters_enabled_dirty) {
        config.filters_enabled_dirty.Assign(0);
-        state.filters.Enable(config.simple_filter_enabled.ToBool(), config.biquad_filter_enabled.ToBool());
+        state.filters.Enable(config.simple_filter_enabled.ToBool(),
-        LOG_TRACE(Audio_DSP, "source_id=%zu enable_simple=%hu enable_biquad=%hu",
+                             config.biquad_filter_enabled.ToBool());
-                  source_id, config.simple_filter_enabled.Value(), config.biquad_filter_enabled.Value());
+        LOG_TRACE(Audio_DSP, "source_id=%zu enable_simple=%hu enable_biquad=%hu", source_id,
+                  config.simple_filter_enabled.Value(), config.biquad_filter_enabled.Value());
    }
    if (config.simple_filter_dirty) {
@@ -138,36 +143,38 @@ void Source::ParseConfig(SourceConfiguration::Configuration& config, const s16_l
    if (config.interpolation_dirty) {
        config.interpolation_dirty.Assign(0);
        state.interpolation_mode = config.interpolation_mode;
-        LOG_TRACE(Audio_DSP, "source_id=%zu interpolation_mode=%zu", source_id, static_cast<size_t>(state.interpolation_mode));
+        LOG_TRACE(Audio_DSP, "source_id=%zu interpolation_mode=%zu", source_id,
+                  static_cast<size_t>(state.interpolation_mode));
    }
    if (config.format_dirty || config.embedded_buffer_dirty) {
        config.format_dirty.Assign(0);
        state.format = config.format;
-        LOG_TRACE(Audio_DSP, "source_id=%zu format=%zu", source_id, static_cast<size_t>(state.format));
+        LOG_TRACE(Audio_DSP, "source_id=%zu format=%zu", source_id,
+                  static_cast<size_t>(state.format));
    }
    if (config.mono_or_stereo_dirty || config.embedded_buffer_dirty) {
        config.mono_or_stereo_dirty.Assign(0);
        state.mono_or_stereo = config.mono_or_stereo;
-        LOG_TRACE(Audio_DSP, "source_id=%zu mono_or_stereo=%zu", source_id, static_cast<size_t>(state.mono_or_stereo));
+        LOG_TRACE(Audio_DSP, "source_id=%zu mono_or_stereo=%zu", source_id,
+                  static_cast<size_t>(state.mono_or_stereo));
    }
    if (config.embedded_buffer_dirty) {
        config.embedded_buffer_dirty.Assign(0);
-        state.input_queue.emplace(Buffer{
+        state.input_queue.emplace(Buffer{config.physical_address,
-            config.physical_address,
+                                         config.length,
-            config.length,
+                                         static_cast<u8>(config.adpcm_ps),
-            static_cast<u8>(config.adpcm_ps),
+                                         {config.adpcm_yn[0], config.adpcm_yn[1]},
-            { config.adpcm_yn[0], config.adpcm_yn[1] },
+                                         config.adpcm_dirty.ToBool(),
-            config.adpcm_dirty.ToBool(),
+                                         config.is_looping.ToBool(),
-            config.is_looping.ToBool(),
+                                         config.buffer_id,
-            config.buffer_id,
+                                         state.mono_or_stereo,
-            state.mono_or_stereo,
+                                         state.format,
-            state.format,
+                                         false});
-            false
+        LOG_TRACE(Audio_DSP, "enqueuing embedded addr=0x%08x len=%u id=%hu",
-        });
+                  config.physical_address, config.length, config.buffer_id);
-        LOG_TRACE(Audio_DSP, "enqueuing embedded addr=0x%08x len=%u id=%hu", config.physical_address, config.length, config.buffer_id);
    }
    if (config.buffer_queue_dirty) {
@@ -175,19 +182,18 @@ void Source::ParseConfig(SourceConfiguration::Configuration& config, const s16_l
        for (size_t i = 0; i < 4; i++) {
            if (config.buffers_dirty & (1 << i)) {
                const auto& b = config.buffers[i];
-                state.input_queue.emplace(Buffer{
+                state.input_queue.emplace(Buffer{b.physical_address,
-                    b.physical_address,
+                                                 b.length,
-                    b.length,
+                                                 static_cast<u8>(b.adpcm_ps),
-                    static_cast<u8>(b.adpcm_ps),
+                                                 {b.adpcm_yn[0], b.adpcm_yn[1]},
-                    { b.adpcm_yn[0], b.adpcm_yn[1] },
+                                                 b.adpcm_dirty != 0,
-                    b.adpcm_dirty != 0,
+                                                 b.is_looping != 0,
-                    b.is_looping != 0,
+                                                 b.buffer_id,
-                    b.buffer_id,
+                                                 state.mono_or_stereo,
-                    state.mono_or_stereo,
+                                                 state.format,
-                    state.format,
+                                                 true});
-                    true
+                LOG_TRACE(Audio_DSP, "enqueuing queued %zu addr=0x%08x len=%u id=%hu", i,
-                });
+                          b.physical_address, b.length, b.buffer_id);
-                LOG_TRACE(Audio_DSP, "enqueuing queued %zu addr=0x%08x len=%u id=%hu", i, b.physical_address, b.length, b.buffer_id);
            }
        }
        config.buffers_dirty = 0;
@@ -218,10 +224,13 @@ void Source::GenerateFrame() {
            break;
        }
-        const size_t size_to_copy = std::min(state.current_buffer.size(), current_frame.size() - frame_position);
+        const size_t size_to_copy =
+            std::min(state.current_buffer.size(), current_frame.size() - frame_position);
-        std::copy(state.current_buffer.begin(), state.current_buffer.begin() + size_to_copy, current_frame.begin() + frame_position);
+        std::copy(state.current_buffer.begin(), state.current_buffer.begin() + size_to_copy,
-        state.current_buffer.erase(state.current_buffer.begin(), state.current_buffer.begin() + size_to_copy);
+                  current_frame.begin() + frame_position);
+        state.current_buffer.erase(state.current_buffer.begin(),
+                                   state.current_buffer.begin() + size_to_copy);
        frame_position += size_to_copy;
        state.next_sample_number += static_cast<u32>(size_to_copy);
@@ -230,9 +239,9 @@ void Source::GenerateFrame() {
    state.filters.ProcessFrame(current_frame);
 }
 bool Source::DequeueBuffer() {
-    ASSERT_MSG(state.current_buffer.empty(), "Shouldn't dequeue; we still have data in current_buffer");
+    ASSERT_MSG(state.current_buffer.empty(),
+               "Shouldn't dequeue; we still have data in current_buffer");
    if (state.input_queue.empty())
        return false;
@@ -261,29 +270,34 @@ bool Source::DequeueBuffer() {
            break;
        case Format::ADPCM:
            DEBUG_ASSERT(num_channels == 1);
-            state.current_buffer = Codec::DecodeADPCM(memory, buf.length, state.adpcm_coeffs, state.adpcm_state);
+            state.current_buffer =
+                Codec::DecodeADPCM(memory, buf.length, state.adpcm_coeffs, state.adpcm_state);
            break;
        default:
            UNIMPLEMENTED();
            break;
        }
    } else {
-        LOG_WARNING(Audio_DSP, "source_id=%zu buffer_id=%hu length=%u: Invalid physical address 0x%08X",
+        LOG_WARNING(Audio_DSP,
-                               source_id, buf.buffer_id, buf.length, buf.physical_address);
+                    "source_id=%zu buffer_id=%hu length=%u: Invalid physical address 0x%08X",
+                    source_id, buf.buffer_id, buf.length, buf.physical_address);
        state.current_buffer.clear();
        return true;
    }
    switch (state.interpolation_mode) {
    case InterpolationMode::None:
-        state.current_buffer = AudioInterp::None(state.interp_state, state.current_buffer, state.rate_multiplier);
+        state.current_buffer =
+            AudioInterp::None(state.interp_state, state.current_buffer, state.rate_multiplier);
        break;
    case InterpolationMode::Linear:
-        state.current_buffer = AudioInterp::Linear(state.interp_state, state.current_buffer, state.rate_multiplier);
+        state.current_buffer =
+            AudioInterp::Linear(state.interp_state, state.current_buffer, state.rate_multiplier);
        break;
    case InterpolationMode::Polyphase:
        // TODO(merry): Implement polyphase interpolation
-        state.current_buffer = AudioInterp::Linear(state.interp_state, state.current_buffer, state.rate_multiplier);
+        state.current_buffer =
+            AudioInterp::Linear(state.interp_state, state.current_buffer, state.rate_multiplier);
        break;
    default:
        UNIMPLEMENTED();
@@ -296,7 +310,8 @@ bool Source::DequeueBuffer() {
    state.buffer_update = buf.from_queue;
    LOG_TRACE(Audio_DSP, "source_id=%zu buffer_id=%hu from_queue=%s current_buffer.size()=%zu",
-                         source_id, buf.buffer_id, buf.from_queue ? "true" : "false", state.current_buffer.size());
+              source_id, buf.buffer_id, buf.from_queue ? "true" : "false",
+              state.current_buffer.size());
    return true;
 }
diff --git a/src/audio_core/hle/source.h b/src/audio_core/hle/source.h
index 7ee08d424..a1ab15520 100644
--- a/src/audio_core/hle/source.h
+++ b/src/audio_core/hle/source.h
@@ -40,13 +40,17 @@ public:
    /**
     * This is called once every audio frame. This performs per-source processing every frame.
     * @param config The new configuration we've got for this Source from the application.
-     * @param adpcm_coeffs ADPCM coefficients to use if config tells us to use them (may contain invalid values otherwise).
+     * @param adpcm_coeffs ADPCM coefficients to use if config tells us to use them (may contain
-     * @return The current status of this Source. This is given back to the emulated application via SharedMemory.
+     * invalid values otherwise).
+     * @return The current status of this Source. This is given back to the emulated application via
+     * SharedMemory.
     */
-    SourceStatus::Status Tick(SourceConfiguration::Configuration& config, const s16_le (&adpcm_coeffs)[16]);
+    SourceStatus::Status Tick(SourceConfiguration::Configuration& config,
+                              const s16_le (&adpcm_coeffs)[16]);
    /**
-     * Mix this source's output into dest, using the gains for the `intermediate_mix_id`-th intermediate mixer.
+     * Mix this source's output into dest, using the gains for the `intermediate_mix_id`-th
+     * intermediate mixer.
     * @param dest The QuadFrame32 to mix into.
     * @param intermediate_mix_id The id of the intermediate mix whose gains we are using.
     */
@@ -77,7 +81,7 @@ private:
    };
    struct BufferOrder {
-        bool operator() (const Buffer& a, const Buffer& b) const {
+        bool operator()(const Buffer& a, const Buffer& b) const {
            // Lower buffer_id comes first.
            return a.buffer_id > b.buffer_id;
        }
@@ -134,7 +138,8 @@ private:
    void ParseConfig(SourceConfiguration::Configuration& config, const s16_le (&adpcm_coeffs)[16]);
    /// INTERNAL: Generate the current audio output for this frame based on our internal state.
    void GenerateFrame();
-    /// INTERNAL: Dequeues a buffer and does preprocessing on it (decoding, resampling). Puts it into current_buffer.
+    /// INTERNAL: Dequeues a buffer and does preprocessing on it (decoding, resampling). Puts it
+    /// into current_buffer.
    bool DequeueBuffer();
    /// INTERNAL: Generates a SourceStatus::Status based on our internal state.
    SourceStatus::Status GetCurrentStatus();
diff --git a/src/audio_core/interpolate.cpp b/src/audio_core/interpolate.cpp
index fcd3aa066..7751c545d 100644
--- a/src/audio_core/interpolate.cpp
+++ b/src/audio_core/interpolate.cpp
@@ -17,7 +17,8 @@ constexpr u64 scale_mask = scale_factor - 1;
 /// Here we step over the input in steps of rate_multiplier, until we consume all of the input.
 /// Three adjacent samples are passed to fn each step.
 template <typename Function>
-static StereoBuffer16 StepOverSamples(State& state, const StereoBuffer16& input, float rate_multiplier, Function fn) {
+static StereoBuffer16 StepOverSamples(State& state, const StereoBuffer16& input,
+                                      float rate_multiplier, Function fn) {
    ASSERT(rate_multiplier > 0);
    if (input.size() < 2)
@@ -63,22 +64,21 @@ static StereoBuffer16 StepOverSamples(State& state, const StereoBuffer16& input,
 }
 StereoBuffer16 None(State& state, const StereoBuffer16& input, float rate_multiplier) {
-    return StepOverSamples(state, input, rate_multiplier, [](u64 fraction, const auto& x0, const auto& x1, const auto& x2) {
+    return StepOverSamples(
-        return x0;
+        state, input, rate_multiplier,
-    });
+        [](u64 fraction, const auto& x0, const auto& x1, const auto& x2) { return x0; });
 }
 StereoBuffer16 Linear(State& state, const StereoBuffer16& input, float rate_multiplier) {
    // Note on accuracy: Some values that this produces are +/- 1 from the actual firmware.
-    return StepOverSamples(state, input, rate_multiplier, [](u64 fraction, const auto& x0, const auto& x1, const auto& x2) {
+    return StepOverSamples(state, input, rate_multiplier, [](u64 fraction, const auto& x0,
+                                                             const auto& x1, const auto& x2) {
        // This is a saturated subtraction. (Verified by black-box fuzzing.)
        s64 delta0 = MathUtil::Clamp<s64>(x1[0] - x0[0], -32768, 32767);
        s64 delta1 = MathUtil::Clamp<s64>(x1[1] - x0[1], -32768, 32767);
-        return std::array<s16, 2> {
+        return std::array<s16, 2>{static_cast<s16>(x0[0] + fraction * delta0 / scale_factor),
-            static_cast<s16>(x0[0] + fraction * delta0 / scale_factor),
+                                  static_cast<s16>(x0[1] + fraction * delta1 / scale_factor)};
-            static_cast<s16>(x0[1] + fraction * delta1 / scale_factor)
-        };
    });
 }
diff --git a/src/audio_core/interpolate.h b/src/audio_core/interpolate.h
index a4c0a453d..99e5b9657 100644
--- a/src/audio_core/interpolate.h
+++ b/src/audio_core/interpolate.h
@@ -24,7 +24,8 @@ struct State {
 * No interpolation. This is equivalent to a zero-order hold. There is a two-sample predelay.
 * @param input Input buffer.
 * @param rate_multiplier Stretch factor. Must be a positive non-zero value.
- *                        rate_multiplier > 1.0 performs decimation and rate_multipler < 1.0 performs upsampling.
+ *                        rate_multiplier > 1.0 performs decimation and rate_multipler < 1.0
+ * performs upsampling.
 * @return The resampled audio buffer.
 */
 StereoBuffer16 None(State& state, const StereoBuffer16& input, float rate_multiplier);
@@ -33,7 +34,8 @@ StereoBuffer16 None(State& state, const StereoBuffer16& input, float rate_multip
 * Linear interpolation. This is equivalent to a first-order hold. There is a two-sample predelay.
 * @param input Input buffer.
 * @param rate_multiplier Stretch factor. Must be a positive non-zero value.
- *                        rate_multiplier > 1.0 performs decimation and rate_multipler < 1.0 performs upsampling.
+ *                        rate_multiplier > 1.0 performs decimation and rate_multipler < 1.0
+ * performs upsampling.
 * @return The resampled audio buffer.
 */
 StereoBuffer16 Linear(State& state, const StereoBuffer16& input, float rate_multiplier);
diff --git a/src/audio_core/null_sink.h b/src/audio_core/null_sink.h
index 9931c4778..b82cd3b9a 100644
--- a/src/audio_core/null_sink.h
+++ b/src/audio_core/null_sink.h
@@ -19,7 +19,8 @@ public:
        return native_sample_rate;
    }
-    void EnqueueSamples(const s16*, size_t) override {}
+    void EnqueueSamples(const s16*, size_t) override {
+    }
    size_t SamplesInQueue() const override {
        return 0;
diff --git a/src/audio_core/sdl2_sink.cpp b/src/audio_core/sdl2_sink.cpp
index 1d7912715..65aac877a 100644
--- a/src/audio_core/sdl2_sink.cpp
+++ b/src/audio_core/sdl2_sink.cpp
@@ -10,9 +10,9 @@
 #include "audio_core/audio_core.h"
 #include "audio_core/sdl2_sink.h"
+#include <numeric>
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include <numeric>
 namespace AudioCore {
@@ -45,7 +45,8 @@ SDL2Sink::SDL2Sink() : impl(std::make_unique<Impl>()) {
    SDL_AudioSpec obtained_audiospec;
    SDL_zero(obtained_audiospec);
-    impl->audio_device_id = SDL_OpenAudioDevice(nullptr, false, &desired_audiospec, &obtained_audiospec, 0);
+    impl->audio_device_id =
+        SDL_OpenAudioDevice(nullptr, false, &desired_audiospec, &obtained_audiospec, 0);
    if (impl->audio_device_id <= 0) {
        LOG_CRITICAL(Audio_Sink, "SDL_OpenAudioDevice failed");
        return;
@@ -86,11 +87,12 @@ size_t SDL2Sink::SamplesInQueue() const {
    SDL_LockAudioDevice(impl->audio_device_id);
-    size_t total_size = std::accumulate(impl->queue.begin(), impl->queue.end(), static_cast<size_t>(0),
+    size_t total_size = std::accumulate(impl->queue.begin(), impl->queue.end(),
-        [](size_t sum, const auto& buffer) {
+                                        static_cast<size_t>(0), [](size_t sum, const auto& buffer) {
-            // Division by two because each stereo sample is made of two s16.
+                                            // Division by two because each stereo sample is made of
-            return sum + buffer.size() / 2;
+                                            // two s16.
-        });
+                                            return sum + buffer.size() / 2;
+                                        });
    SDL_UnlockAudioDevice(impl->audio_device_id);
@@ -100,7 +102,8 @@ size_t SDL2Sink::SamplesInQueue() const {
 void SDL2Sink::Impl::Callback(void* impl_, u8* buffer, int buffer_size_in_bytes) {
    Impl* impl = reinterpret_cast<Impl*>(impl_);
-    size_t remaining_size = static_cast<size_t>(buffer_size_in_bytes) / sizeof(s16); // Keep track of size in 16-bit increments.
+    size_t remaining_size = static_cast<size_t>(buffer_size_in_bytes) /
+                            sizeof(s16); // Keep track of size in 16-bit increments.
    while (remaining_size > 0 && !impl->queue.empty()) {
        if (impl->queue.front().size() <= remaining_size) {
@@ -111,7 +114,8 @@ void SDL2Sink::Impl::Callback(void* impl_, u8* buffer, int buffer_size_in_bytes)
        } else {
            memcpy(buffer, impl->queue.front().data(), remaining_size * sizeof(s16));
            buffer += remaining_size * sizeof(s16);
-            impl->queue.front().erase(impl->queue.front().begin(), impl->queue.front().begin() + remaining_size);
+            impl->queue.front().erase(impl->queue.front().begin(),
+                                      impl->queue.front().begin() + remaining_size);
            remaining_size = 0;
        }
    }
diff --git a/src/audio_core/sink.h b/src/audio_core/sink.h
index a06fc3dcc..c938e87d2 100644
--- a/src/audio_core/sink.h
+++ b/src/audio_core/sink.h
@@ -11,14 +11,16 @@
 namespace AudioCore {
 /**
- * This class is an interface for an audio sink. An audio sink accepts samples in stereo signed PCM16 format to be output.
+ * This class is an interface for an audio sink. An audio sink accepts samples in stereo signed
+ * PCM16 format to be output.
 * Sinks *do not* handle resampling and expect the correct sample rate. They are dumb outputs.
 */
 class Sink {
 public:
    virtual ~Sink() = default;
-    /// The native rate of this sink. The sink expects to be fed samples that respect this. (Units: samples/sec)
+    /// The native rate of this sink. The sink expects to be fed samples that respect this. (Units:
+    /// samples/sec)
    virtual unsigned int GetNativeSampleRate() const = 0;
    /**
diff --git a/src/audio_core/sink_details.cpp b/src/audio_core/sink_details.cpp
index ba5e83d17..ff529f4cf 100644
--- a/src/audio_core/sink_details.cpp
+++ b/src/audio_core/sink_details.cpp
@@ -17,9 +17,9 @@ namespace AudioCore {
 // g_sink_details is ordered in terms of desirability, with the best choice at the top.
 const std::vector<SinkDetails> g_sink_details = {
 #ifdef HAVE_SDL2
-    { "sdl2", []() { return std::make_unique<SDL2Sink>(); } },
+    {"sdl2", []() { return std::make_unique<SDL2Sink>(); }},
 #endif
-    { "null", []() { return std::make_unique<NullSink>(); } },
+    {"null", []() { return std::make_unique<NullSink>(); }},
 };
 } // namespace AudioCore
diff --git a/src/audio_core/sink_details.h b/src/audio_core/sink_details.h
index 4b30cf835..34110c97a 100644
--- a/src/audio_core/sink_details.h
+++ b/src/audio_core/sink_details.h
@@ -14,7 +14,8 @@ class Sink;
 struct SinkDetails {
    SinkDetails(const char* id_, std::function<std::unique_ptr<Sink>()> factory_)
-        : id(id_), factory(factory_) {}
+        : id(id_), factory(factory_) {
+    }
    /// Name for this sink.
    const char* id;
diff --git a/src/audio_core/time_stretch.cpp b/src/audio_core/time_stretch.cpp
index ea38f40d0..f44807c84 100644
--- a/src/audio_core/time_stretch.cpp
+++ b/src/audio_core/time_stretch.cpp
@@ -26,8 +26,8 @@ static double ClampRatio(double ratio) {
    return MathUtil::Clamp(ratio, MIN_RATIO, MAX_RATIO);
 }
-constexpr double MIN_DELAY_TIME = 0.05; // Units: seconds
+constexpr double MIN_DELAY_TIME = 0.05;            // Units: seconds
-constexpr double MAX_DELAY_TIME = 0.25; // Units: seconds
+constexpr double MAX_DELAY_TIME = 0.25;            // Units: seconds
 constexpr size_t DROP_FRAMES_SAMPLE_DELAY = 16000; // Units: samples
 constexpr double SMOOTHING_FACTOR = 0.007;
@@ -48,7 +48,8 @@ std::vector<s16> TimeStretcher::Process(size_t samples_in_queue) {
    double ratio = CalculateCurrentRatio();
    ratio = CorrectForUnderAndOverflow(ratio, samples_in_queue);
-    impl->smoothed_ratio = (1.0 - SMOOTHING_FACTOR) * impl->smoothed_ratio + SMOOTHING_FACTOR * ratio;
+    impl->smoothed_ratio =
+        (1.0 - SMOOTHING_FACTOR) * impl->smoothed_ratio + SMOOTHING_FACTOR * ratio;
    impl->smoothed_ratio = ClampRatio(impl->smoothed_ratio);
    // SoundTouch's tempo definition the inverse of our ratio definition.
@@ -100,7 +101,8 @@ double TimeStretcher::CalculateCurrentRatio() {
    const steady_clock::time_point now = steady_clock::now();
    const std::chrono::duration<double> duration = now - impl->frame_timer;
-    const double expected_time = static_cast<double>(impl->samples_queued) / static_cast<double>(native_sample_rate);
+    const double expected_time =
+        static_cast<double>(impl->samples_queued) / static_cast<double>(native_sample_rate);
    const double actual_time = duration.count();
    double ratio;
diff --git a/src/audio_core/time_stretch.h b/src/audio_core/time_stretch.h
index 1fde3f72a..42a213679 100644
--- a/src/audio_core/time_stretch.h
+++ b/src/audio_core/time_stretch.h
@@ -37,7 +37,8 @@ public:
    /**
     * Does audio stretching and produces the time-stretched samples.
     * Timer calculations use sample_delay to determine how much of a margin we have.
-     * @param sample_delay How many samples are buffered downstream of this module and haven't been played yet.
+     * @param sample_delay How many samples are buffered downstream of this module and haven't been
+     * played yet.
     * @return Samples to play in interleaved stereo PCM16 format.
     */
    std::vector<s16> Process(size_t sample_delay);
@@ -48,7 +49,8 @@ private:
    /// INTERNAL: ratio = wallclock time / emulated time
    double CalculateCurrentRatio();
-    /// INTERNAL: If we have too many or too few samples downstream, nudge ratio in the appropriate direction.
+    /// INTERNAL: If we have too many or too few samples downstream, nudge ratio in the appropriate
+    /// direction.
    double CorrectForUnderAndOverflow(double ratio, size_t sample_delay) const;
    /// INTERNAL: Gets the time-stretched samples from SoundTouch.
    std::vector<s16> GetSamples();