use std::span for compression utils

Author: moritz-h

libsave/src/GameTypes/Save/ChunkHelper.cpp

@@ -22,8 +22,8 @@ std::vector<std::byte> SatisfactorySave::decompressChunks(IStreamArchive& inAr)
     for (int64_t i = 0; i < size; i++) {
         const ChunkInfo& chunk = chunk_list[i];
         std::byte* decompressed_buffer_ptr = file_data_blob.data() + chunk.decompressed_offset;
-        zlibUncompress(decompressed_buffer_ptr, chunk.header.uncompressedSize(), chunk.compressed_chunk.data(),
-            chunk.compressed_chunk.size());
+        zlibUncompress({decompressed_buffer_ptr, static_cast<std::size_t>(chunk.header.uncompressedSize())},
+            chunk.compressed_chunk);
     }
 
     return file_data_blob;

libsave/src/IO/OodleUtils.cpp

@@ -56,19 +56,11 @@ void SatisfactorySave::checkOodleLibraryIsLoaded() {
 #endif
 }
 
-std::vector<std::byte> SatisfactorySave::oodleDecompress(const std::vector<std::byte>& buffer,
-    std::size_t decompressed_size) {
-    std::vector<std::byte> buffer_uncompressed(decompressed_size);
-    oodleDecompress(buffer_uncompressed.data(), decompressed_size, buffer.data(), buffer.size());
-    return buffer_uncompressed;
-}
-
-void SatisfactorySave::oodleDecompress(std::byte* dest, std::size_t destLen, const std::byte* source,
-    std::size_t sourceLen) {
+void SatisfactorySave::oodleDecompress(std::span<std::byte> dest, std::span<const std::byte> source) {
 #ifdef _WIN32
-    auto len = dispatch().OodleLZ_Decompress(source, static_cast<int64_t>(sourceLen), dest,
-        static_cast<int64_t>(destLen), 1, 0, 0, nullptr, 0, nullptr, nullptr, nullptr, 0, 3);
-    if (len != destLen) {
+    auto len = dispatch().OodleLZ_Decompress(source.data(), static_cast<int64_t>(source.size()), dest.data(),
+        static_cast<int64_t>(dest.size()), 1, 0, 0, nullptr, 0, nullptr, nullptr, nullptr, 0, 3);
+    if (len != dest.size()) {
         throw std::runtime_error("Error decompressing Oodle!");
     }
 #else

libsave/src/IO/OodleUtils.h

@@ -1,12 +1,10 @@
 #pragma once
 
 #include <cstddef>
-#include <vector>
+#include <span>
 
 namespace SatisfactorySave {
     void checkOodleLibraryIsLoaded();
 
-    std::vector<std::byte> oodleDecompress(const std::vector<std::byte>& buffer, std::size_t decompressed_size);
-
-    void oodleDecompress(std::byte* dest, std::size_t destLen, const std::byte* source, std::size_t sourceLen);
+    void oodleDecompress(std::span<std::byte> dest, std::span<const std::byte> source);
 } // namespace SatisfactorySave

libsave/src/IO/ZlibUtils.cpp

@@ -4,7 +4,7 @@
 
 #include <zlib.h>
 
-std::vector<std::byte> SatisfactorySave::zlibCompress(const std::vector<std::byte>& buffer) {
+std::vector<std::byte> SatisfactorySave::zlibCompress(std::span<const std::byte> buffer) {
     uLong size = compressBound(static_cast<uLong>(buffer.size()));
     std::vector<std::byte> buffer_compressed(static_cast<std::size_t>(size));
     int state = ::compress(reinterpret_cast<Bytef*>(buffer_compressed.data()), &size,
@@ -16,19 +16,11 @@ std::vector<std::byte> SatisfactorySave::zlibCompress(const std::vector<std::byt
     return buffer_compressed;
 }
 
-std::vector<std::byte> SatisfactorySave::zlibUncompress(const std::vector<std::byte>& buffer,
-    std::size_t uncompressed_size) {
-    std::vector<std::byte> buffer_uncompressed(uncompressed_size);
-    zlibUncompress(buffer_uncompressed.data(), uncompressed_size, buffer.data(), buffer.size());
-    return buffer_uncompressed;
-}
-
-void SatisfactorySave::zlibUncompress(std::byte* dest, std::size_t destLen, const std::byte* source,
-    std::size_t sourceLen) {
-    auto size = static_cast<uLongf>(destLen);
-    int state = ::uncompress(reinterpret_cast<Bytef*>(dest), &size, reinterpret_cast<const Bytef*>(source),
-        static_cast<uLong>(sourceLen));
-    if (state != Z_OK || size != destLen) {
+void SatisfactorySave::zlibUncompress(std::span<std::byte> dest, std::span<const std::byte> source) {
+    auto size = static_cast<uLongf>(dest.size());
+    int state = ::uncompress(reinterpret_cast<Bytef*>(dest.data()), &size,
+        reinterpret_cast<const Bytef*>(source.data()), static_cast<uLong>(source.size()));
+    if (state != Z_OK || size != dest.size()) {
         throw std::runtime_error("Error decompressing buffer with zlib!");
     }
 }

libsave/src/IO/ZlibUtils.h

@@ -1,14 +1,11 @@
 #pragma once
 
 #include <cstddef>
+#include <span>
 #include <vector>
 
 namespace SatisfactorySave {
+    std::vector<std::byte> zlibCompress(std::span<const std::byte> buffer);
 
-    std::vector<std::byte> zlibCompress(const std::vector<std::byte>& buffer);
-
-    std::vector<std::byte> zlibUncompress(const std::vector<std::byte>& buffer, std::size_t uncompressed_size);
-
-    void zlibUncompress(std::byte* dest, std::size_t destLen, const std::byte* source, std::size_t sourceLen);
-
+    void zlibUncompress(std::span<std::byte> dest, std::span<const std::byte> source);
 } // namespace SatisfactorySave

libsave/src/Pak/IoStoreFile.cpp

@@ -150,7 +150,7 @@ void SatisfactorySave::IoStoreFile::readCompressionBlock(uint64_t blockIdx, std:
         ar.serializeRaw(dst, compBlock.GetCompressedSize());
     } else if (compMethod == "Oodle") {
         const auto comp_buf = ar.read_buffer(compBlock.GetCompressedSize());
-        oodleDecompress(dst, compBlock.GetUncompressedSize(), comp_buf.data(), compBlock.GetCompressedSize());
+        oodleDecompress({dst, compBlock.GetUncompressedSize()}, comp_buf);
     } else {
         throw std::runtime_error("Unknown compression method: " + compMethod);
     }

libsave/src/Pak/PakFile.cpp

@@ -142,7 +142,7 @@ std::vector<std::byte> SatisfactorySave::PakFile::readAssetFileContent(const std
                 const auto& compressedBuffer = ar.read_buffer(blockSize);
                 int64_t destLen =
                     std::min(entry.UncompressedSize - bufferPos, static_cast<int64_t>(entry.CompressionBlockSize));
-                zlibUncompress(buffer.data() + bufferPos, destLen, compressedBuffer.data(), compressedBuffer.size());
+                zlibUncompress({buffer.data() + bufferPos, static_cast<std::size_t>(destLen)}, compressedBuffer);
                 bufferPos += destLen;
             }
             return buffer;