DiscIO: Use std::function for compression callback

5 files changed, 25 insertions, 28 deletions

diff --git a/Source/Core/DiscIO/Blob.h b/Source/Core/DiscIO/Blob.h
index 473aa9bfce..2166d8c677 100644
--- a/Source/Core/DiscIO/Blob.h
+++ b/Source/Core/DiscIO/Blob.h
@@ -15,6 +15,7 @@
 // automatically do the right thing.
 
 #include <array>
+#include <functional>
 #include <memory>
 #include <optional>
 #include <string>
@@ -175,17 +176,16 @@ private:
 // Factory function - examines the path to choose the right type of BlobReader, and returns one.
 std::unique_ptr<BlobReader> CreateBlobReader(const std::string& filename);
 
-typedef bool (*CompressCB)(const std::string& text, float percent, void* arg);
+using CompressCB = std::function<bool(const std::string& text, float percent)>;
 
 bool ConvertToGCZ(BlobReader* infile, const std::string& infile_path,
-                  const std::string& outfile_path, u32 sub_type, int sector_size = 16384,
-                  CompressCB callback = nullptr, void* arg = nullptr);
+                  const std::string& outfile_path, u32 sub_type, int sector_size,
+                  CompressCB callback);
 bool ConvertToPlain(BlobReader* infile, const std::string& infile_path,
-                    const std::string& outfile_path, CompressCB callback = nullptr,
-                    void* arg = nullptr);
+                    const std::string& outfile_path, CompressCB callback);
 bool ConvertToWIAOrRVZ(BlobReader* infile, const std::string& infile_path,
                        const std::string& outfile_path, bool rvz,
                        WIARVZCompressionType compression_type, int compression_level,
-                       int chunk_size, CompressCB callback = nullptr, void* arg = nullptr);
+                       int chunk_size, CompressCB callback);
 
 }  // namespace DiscIO
diff --git a/Source/Core/DiscIO/CompressedBlob.cpp b/Source/Core/DiscIO/CompressedBlob.cpp
index fdfd65baf8..4486b54827 100644
--- a/Source/Core/DiscIO/CompressedBlob.cpp
+++ b/Source/Core/DiscIO/CompressedBlob.cpp
@@ -238,7 +238,7 @@ static ConversionResult<OutputParameters> Compress(CompressThreadState* state,
 
 static ConversionResultCode Output(OutputParameters parameters, File::IOFile* outfile,
                                    u64* position, std::vector<u64>* offsets, int progress_monitor,
-                                   u32 num_blocks, CompressCB callback, void* arg)
+                                   u32 num_blocks, CompressCB callback)
 {
   u64 offset = *position;
   if (!parameters.compressed)
@@ -261,7 +261,7 @@ static ConversionResultCode Output(OutputParameters parameters, File::IOFile* ou
 
     const float completion = static_cast<float>(parameters.block_number) / num_blocks;
 
-    if (!callback(text, completion, arg))
+    if (!callback(text, completion))
       return ConversionResultCode::Canceled;
   }
 
@@ -270,7 +270,7 @@ static ConversionResultCode Output(OutputParameters parameters, File::IOFile* ou
 
 bool ConvertToGCZ(BlobReader* infile, const std::string& infile_path,
                   const std::string& outfile_path, u32 sub_type, int block_size,
-                  CompressCB callback, void* arg)
+                  CompressCB callback)
 {
   ASSERT(infile->IsDataSizeAccurate());
 
@@ -284,7 +284,7 @@ bool ConvertToGCZ(BlobReader* infile, const std::string& infile_path,
     return false;
   }
 
-  callback(Common::GetStringT("Files opened, ready to compress."), 0, arg);
+  callback(Common::GetStringT("Files opened, ready to compress."), 0);
 
   CompressedBlobHeader header;
   header.magic_cookie = GCZ_MAGIC;
@@ -317,7 +317,7 @@ bool ConvertToGCZ(BlobReader* infile, const std::string& infile_path,
 
   const auto output = [&](OutputParameters parameters) {
     return Output(std::move(parameters), &outfile, &position, &offsets, progress_monitor,
-                  header.num_blocks, callback, arg);
+                  header.num_blocks, callback);
   };
 
   MultithreadedCompressor<CompressThreadState, CompressParameters, OutputParameters> compressor(
@@ -364,7 +364,7 @@ bool ConvertToGCZ(BlobReader* infile, const std::string& infile_path,
     outfile.WriteArray(offsets.data(), header.num_blocks);
     outfile.WriteArray(hashes.data(), header.num_blocks);
 
-    callback(Common::GetStringT("Done compressing disc image."), 1.0f, arg);
+    callback(Common::GetStringT("Done compressing disc image."), 1.0f);
   }
 
   if (result == ConversionResultCode::ReadFailed)
diff --git a/Source/Core/DiscIO/FileBlob.cpp b/Source/Core/DiscIO/FileBlob.cpp
index ca0aa2cfd0..980b158dc9 100644
--- a/Source/Core/DiscIO/FileBlob.cpp
+++ b/Source/Core/DiscIO/FileBlob.cpp
@@ -42,7 +42,7 @@ bool PlainFileReader::Read(u64 offset, u64 nbytes, u8* out_ptr)
 }
 
 bool ConvertToPlain(BlobReader* infile, const std::string& infile_path,
-                    const std::string& outfile_path, CompressCB callback, void* arg)
+                    const std::string& outfile_path, CompressCB callback)
 {
   ASSERT(infile->IsDataSizeAccurate());
 
@@ -78,7 +78,7 @@ bool ConvertToPlain(BlobReader* infile, const std::string& infile_path,
     if (i % progress_monitor == 0)
     {
       const bool was_cancelled =
-          !callback(Common::GetStringT("Unpacking"), (float)i / (float)num_buffers, arg);
+          !callback(Common::GetStringT("Unpacking"), (float)i / (float)num_buffers);
       if (was_cancelled)
       {
         success = false;
diff --git a/Source/Core/DiscIO/WIABlob.cpp b/Source/Core/DiscIO/WIABlob.cpp
index 51a9c65694..4d4b104242 100644
--- a/Source/Core/DiscIO/WIABlob.cpp
+++ b/Source/Core/DiscIO/WIABlob.cpp
@@ -1686,9 +1686,9 @@ ConversionResultCode WIARVZFileReader<RVZ>::Output(std::vector<OutputParametersE
 }
 
 template <bool RVZ>
-ConversionResultCode
-WIARVZFileReader<RVZ>::RunCallback(size_t groups_written, u64 bytes_read, u64 bytes_written,
-                                   u32 total_groups, u64 iso_size, CompressCB callback, void* arg)
+ConversionResultCode WIARVZFileReader<RVZ>::RunCallback(size_t groups_written, u64 bytes_read,
+                                                        u64 bytes_written, u32 total_groups,
+                                                        u64 iso_size, CompressCB callback)
 {
   int ratio = 0;
   if (bytes_read != 0)
@@ -1700,8 +1700,8 @@ WIARVZFileReader<RVZ>::RunCallback(size_t groups_written, u64 bytes_read, u64 by
 
   const float completion = static_cast<float>(bytes_read) / iso_size;
 
-  return callback(text, completion, arg) ? ConversionResultCode::Success :
-                                           ConversionResultCode::Canceled;
+  return callback(text, completion) ? ConversionResultCode::Success :
+                                      ConversionResultCode::Canceled;
 }
 
 template <bool RVZ>
@@ -1729,8 +1729,7 @@ template <bool RVZ>
 ConversionResultCode
 WIARVZFileReader<RVZ>::Convert(BlobReader* infile, const VolumeDisc* infile_volume,
                                File::IOFile* outfile, WIARVZCompressionType compression_type,
-                               int compression_level, int chunk_size, CompressCB callback,
-                               void* arg)
+                               int compression_level, int chunk_size, CompressCB callback)
 {
   ASSERT(infile->IsDataSizeAccurate());
   ASSERT(chunk_size > 0);
@@ -1832,7 +1831,7 @@ WIARVZFileReader<RVZ>::Convert(BlobReader* infile, const VolumeDisc* infile_volu
       return result;
 
     return RunCallback(parameters.group_index + parameters.entries.size(), parameters.bytes_read,
-                       bytes_written, total_groups, iso_size, callback, arg);
+                       bytes_written, total_groups, iso_size, callback);
   };
 
   MultithreadedCompressor<CompressThreadState, CompressParameters, OutputParameters> mt_compressor(
@@ -2030,7 +2029,7 @@ WIARVZFileReader<RVZ>::Convert(BlobReader* infile, const VolumeDisc* infile_volu
 bool ConvertToWIAOrRVZ(BlobReader* infile, const std::string& infile_path,
                        const std::string& outfile_path, bool rvz,
                        WIARVZCompressionType compression_type, int compression_level,
-                       int chunk_size, CompressCB callback, void* arg)
+                       int chunk_size, CompressCB callback)
 {
   File::IOFile outfile(outfile_path, "wb");
   if (!outfile)
@@ -2047,7 +2046,7 @@ bool ConvertToWIAOrRVZ(BlobReader* infile, const std::string& infile_path,
   const auto convert = rvz ? RVZFileReader::Convert : WIAFileReader::Convert;
   const ConversionResultCode result =
       convert(infile, infile_volume.get(), &outfile, compression_type, compression_level,
-              chunk_size, callback, arg);
+              chunk_size, callback);
 
   if (result == ConversionResultCode::ReadFailed)
     PanicAlertT("Failed to read from the input file \"%s\".", infile_path.c_str());
diff --git a/Source/Core/DiscIO/WIABlob.h b/Source/Core/DiscIO/WIABlob.h
index c76af169f2..5b08dd227c 100644
--- a/Source/Core/DiscIO/WIABlob.h
+++ b/Source/Core/DiscIO/WIABlob.h
@@ -64,8 +64,7 @@ public:
 
   static ConversionResultCode Convert(BlobReader* infile, const VolumeDisc* infile_volume,
                                       File::IOFile* outfile, WIARVZCompressionType compression_type,
-                                      int compression_level, int chunk_size, CompressCB callback,
-                                      void* arg);
+                                      int compression_level, int chunk_size, CompressCB callback);
 
 private:
   using SHA1 = std::array<u8, 20>;
@@ -351,8 +350,7 @@ private:
                                      std::mutex* reusable_groups_mutex, GroupEntry* group_entry,
                                      u64* bytes_written);
   static ConversionResultCode RunCallback(size_t groups_written, u64 bytes_read, u64 bytes_written,
-                                          u32 total_groups, u64 iso_size, CompressCB callback,
-                                          void* arg);
+                                          u32 total_groups, u64 iso_size, CompressCB callback);
 
   bool m_valid;
   WIARVZCompressionType m_compression_type;