Merge pull request #7061 from ameerj/dma-buffer-misc

buffer_cache, maxwell_dma: Minor refactoring and code fixes

src/video_core/buffer_cache/buffer_cache.h

@@ -570,13 +570,12 @@ bool BufferCache<P>::DMACopy(GPUVAddr src_address, GPUVAddr dest_address, u64 am
     ForEachWrittenRange(*cpu_src_address, amount, mirror);
     // This subtraction in this order is important for overlapping copies.
     common_ranges.subtract(subtract_interval);
-    bool atleast_1_download = tmp_intervals.size() != 0;
+    const bool has_new_downloads = tmp_intervals.size() != 0;
-    for (const IntervalType add_interval : tmp_intervals) {
+    for (const IntervalType& add_interval : tmp_intervals) {
         common_ranges.add(add_interval);
     }
-
     runtime.CopyBuffer(dest_buffer, src_buffer, copies);
-    if (atleast_1_download) {
+    if (has_new_downloads) {
         dest_buffer.MarkRegionAsGpuModified(*cpu_dest_address, amount);
     }
     std::vector<u8> tmp_buffer(amount);

src/video_core/engines/maxwell_dma.cpp

@@ -82,41 +82,41 @@ void MaxwellDMA::Launch() {
 }
 
 void MaxwellDMA::CopyPitchToPitch() {
-    // When `multi_line_enable` bit is disabled the copy is performed as if we were copying a 1D
+    // When `multi_line_enable` bit is enabled we copy a 2D image of dimensions
-    // buffer of length `line_length_in`.
+    // (line_length_in, line_count).
-    // Otherwise we copy a 2D image of dimensions (line_length_in, line_count).
+    // Otherwise the copy is performed as if we were copying a 1D buffer of length line_length_in.
-    auto& accelerate = rasterizer->AccessAccelerateDMA();
+    const bool remap_enabled = regs.launch_dma.remap_enable != 0;
-    if (!regs.launch_dma.multi_line_enable) {
+    if (regs.launch_dma.multi_line_enable) {
-        const bool is_buffer_clear = regs.launch_dma.remap_enable != 0 &&
+        UNIMPLEMENTED_IF(remap_enabled);
-                                     regs.remap_const.dst_x == RemapConst::Swizzle::CONST_A;
+
-        // TODO: allow multisized components.
+        // Perform a line-by-line copy.
-        if (is_buffer_clear) {
+        // We're going to take a subrect of size (line_length_in, line_count) from the source
-            ASSERT(regs.remap_const.component_size_minus_one == 3);
+        // rectangle. There is no need to manually flush/invalidate the regions because CopyBlock
-            accelerate.BufferClear(regs.offset_out, regs.line_length_in, regs.remap_consta_value);
+        // does that for us.
-            std::vector<u32> tmp_buffer(regs.line_length_in, regs.remap_consta_value);
+        for (u32 line = 0; line < regs.line_count; ++line) {
-            memory_manager.WriteBlockUnsafe(regs.offset_out,
+            const GPUVAddr source_line = regs.offset_in + static_cast<size_t>(line) * regs.pitch_in;
-                                            reinterpret_cast<u8*>(tmp_buffer.data()),
+            const GPUVAddr dest_line = regs.offset_out + static_cast<size_t>(line) * regs.pitch_out;
-                                            regs.line_length_in * sizeof(u32));
+            memory_manager.CopyBlock(dest_line, source_line, regs.line_length_in);
-            return;
-        }
-        UNIMPLEMENTED_IF(regs.launch_dma.remap_enable != 0);
-        if (!accelerate.BufferCopy(regs.offset_in, regs.offset_out, regs.line_length_in)) {
-            std::vector<u8> tmp_buffer(regs.line_length_in);
-            memory_manager.ReadBlockUnsafe(regs.offset_in, tmp_buffer.data(), regs.line_length_in);
-            memory_manager.WriteBlock(regs.offset_out, tmp_buffer.data(), regs.line_length_in);
         }
         return;
     }
-
+    // TODO: allow multisized components.
-    UNIMPLEMENTED_IF(regs.launch_dma.remap_enable != 0);
+    auto& accelerate = rasterizer->AccessAccelerateDMA();
-
+    const bool is_const_a_dst = regs.remap_const.dst_x == RemapConst::Swizzle::CONST_A;
-    // Perform a line-by-line copy.
+    const bool is_buffer_clear = remap_enabled && is_const_a_dst;
-    // We're going to take a subrect of size (line_length_in, line_count) from the source rectangle.
+    if (is_buffer_clear) {
-    // There is no need to manually flush/invalidate the regions because CopyBlock does that for us.
+        ASSERT(regs.remap_const.component_size_minus_one == 3);
-    for (u32 line = 0; line < regs.line_count; ++line) {
+        accelerate.BufferClear(regs.offset_out, regs.line_length_in, regs.remap_consta_value);
-        const GPUVAddr source_line = regs.offset_in + static_cast<size_t>(line) * regs.pitch_in;
+        std::vector<u32> tmp_buffer(regs.line_length_in, regs.remap_consta_value);
-        const GPUVAddr dest_line = regs.offset_out + static_cast<size_t>(line) * regs.pitch_out;
+        memory_manager.WriteBlockUnsafe(regs.offset_out, reinterpret_cast<u8*>(tmp_buffer.data()),
-        memory_manager.CopyBlock(dest_line, source_line, regs.line_length_in);
+                                        regs.line_length_in * sizeof(u32));
+        return;
+    }
+    UNIMPLEMENTED_IF(remap_enabled);
+    if (!accelerate.BufferCopy(regs.offset_in, regs.offset_out, regs.line_length_in)) {
+        std::vector<u8> tmp_buffer(regs.line_length_in);
+        memory_manager.ReadBlockUnsafe(regs.offset_in, tmp_buffer.data(), regs.line_length_in);
+        memory_manager.WriteBlock(regs.offset_out, tmp_buffer.data(), regs.line_length_in);
     }
 }
 

src/video_core/engines/maxwell_dma.h

@@ -175,7 +175,7 @@ public:
     static_assert(sizeof(LaunchDMA) == 4);
 
     struct RemapConst {
-        enum Swizzle : u32 {
+        enum class Swizzle : u32 {
             SRC_X = 0,
             SRC_Y = 1,
             SRC_Z = 2,

src/video_core/renderer_opengl/gl_buffer_cache.cpp

@@ -147,8 +147,7 @@ void BufferCacheRuntime::CopyBuffer(Buffer& dst_buffer, Buffer& src_buffer,
 
 void BufferCacheRuntime::ClearBuffer(Buffer& dest_buffer, u32 offset, size_t size, u32 value) {
     glClearNamedBufferSubData(dest_buffer.Handle(), GL_R32UI, static_cast<GLintptr>(offset),
-                              static_cast<GLsizeiptr>(size / sizeof(u32)), GL_RED, GL_UNSIGNED_INT,
+                              static_cast<GLsizeiptr>(size), GL_RED, GL_UNSIGNED_INT, &value);
-                              &value);
 }
 
 void BufferCacheRuntime::BindIndexBuffer(Buffer& buffer, u32 offset, u32 size) {