General: Fix clang format.

src/common/address_space.inc

@@ -261,8 +261,8 @@ MAP_MEMBER(void)::UnmapLocked(VaType virt, VaType size) {
         unmapCallback(virt, size);
 }
 
-ALLOC_MEMBER_CONST()::FlatAllocator(VaType vaStart_, VaType vaLimit)
+ALLOC_MEMBER_CONST()::FlatAllocator(VaType vaStart_, VaType vaLimit_)
-    : Base(vaLimit), currentLinearAllocEnd(vaStart_), vaStart(vaStart_) {}
+    : Base(vaLimit_), currentLinearAllocEnd(vaStart_), vaStart(vaStart_) {}
 
 ALLOC_MEMBER(VaType)::Allocate(VaType size) {
     std::scoped_lock lock(this->blockMutex);

src/video_core/control/channel_state_cache.h

@@ -9,6 +9,7 @@
 #include <mutex>
 #include <optional>
 #include <unordered_map>
+#include <vector>
 
 #include "common/common_types.h"
 

src/video_core/host1x/codecs/vp9.cpp

@@ -382,8 +382,9 @@ Vp9FrameContainer VP9::GetCurrentFrame(const Host1x::NvdecCommon::NvdecRegisters
         // gpu.SyncGuestHost(); epic, why?
         current_frame.info = GetVp9PictureInfo(state);
         current_frame.bit_stream.resize(current_frame.info.bitstream_size);
-        host1x.MemoryManager().ReadBlock(state.frame_bitstream_offset, current_frame.bit_stream.data(),
+        host1x.MemoryManager().ReadBlock(state.frame_bitstream_offset,
-                                      current_frame.info.bitstream_size);
+                                         current_frame.bit_stream.data(),
+                                         current_frame.info.bitstream_size);
     }
     if (!next_frame.bit_stream.empty()) {
         Vp9FrameContainer temp{

src/video_core/host1x/syncpoint_manager.h

@@ -49,9 +49,9 @@ public:
                               expected_value, func);
     }
 
-    void DeregisterGuestAction(u32 syncpoint_id,ActionHandle& handle);
+    void DeregisterGuestAction(u32 syncpoint_id, ActionHandle& handle);
 
-    void DeregisterHostAction(u32 syncpoint_id,ActionHandle& handle);
+    void DeregisterHostAction(u32 syncpoint_id, ActionHandle& handle);
 
     void IncrementGuest(u32 syncpoint_id);
 

src/video_core/host1x/vic.cpp

@@ -157,8 +157,8 @@ void Vic::WriteRGBFrame(const AVFrame* frame, const VicConfig& config) {
         const auto size = Texture::CalculateSize(true, 4, width, height, 1, block_height, 0);
         luma_buffer.resize(size);
         std::span<const u8> frame_buff(converted_frame_buf_addr, 4 * width * height);
-        Texture::SwizzleSubrect(luma_buffer, frame_buff, 4, width, height, 1,
+        Texture::SwizzleSubrect(luma_buffer, frame_buff, 4, width, height, 1, 0, 0, width, height,
-                                0, 0, width, height, block_height, 0, width * 4);
+                                block_height, 0, width * 4);
 
         host1x.MemoryManager().WriteBlock(output_surface_luma_address, luma_buffer.data(), size);
     } else {

src/video_core/memory_manager.cpp

@@ -619,7 +619,6 @@ bool MemoryManager::IsContinousRange(GPUVAddr gpu_addr, std::size_t size) const
 }
 
 bool MemoryManager::IsFullyMappedRange(GPUVAddr gpu_addr, std::size_t size) const {
-    std::optional<VAddr> old_page_addr{};
     bool result{true};
     auto fail = [&]([[maybe_unused]] std::size_t page_index, [[maybe_unused]] std::size_t offset,
                     [[maybe_unused]] std::size_t copy_amount) {

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -95,19 +95,14 @@ RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_,
                                Core::Frontend::EmuWindow& emu_window,
                                Core::Memory::Memory& cpu_memory_, Tegra::GPU& gpu_,
                                std::unique_ptr<Core::Frontend::GraphicsContext> context_) try
-    : RendererBase(emu_window, std::move(context_)),
+    : RendererBase(emu_window, std::move(context_)), telemetry_session(telemetry_session_),
-      telemetry_session(telemetry_session_),
+      cpu_memory(cpu_memory_), gpu(gpu_), library(OpenLibrary()),
-      cpu_memory(cpu_memory_),
-      gpu(gpu_),
-      library(OpenLibrary()),
       instance(CreateInstance(library, dld, VK_API_VERSION_1_1, render_window.GetWindowInfo().type,
                               true, Settings::values.renderer_debug.GetValue())),
       debug_callback(Settings::values.renderer_debug ? CreateDebugCallback(instance) : nullptr),
       surface(CreateSurface(instance, render_window)),
-      device(CreateDevice(instance, dld, *surface)),
+      device(CreateDevice(instance, dld, *surface)), memory_allocator(device, false),
-      memory_allocator(device, false),
+      state_tracker(), scheduler(device, state_tracker),
-      state_tracker(),
-      scheduler(device, state_tracker),
       swapchain(*surface, device, scheduler, render_window.GetFramebufferLayout().width,
                 render_window.GetFramebufferLayout().height, false),
       blit_screen(cpu_memory, render_window, device, memory_allocator, swapchain, scheduler,