Przeniesiono kompresję do osobnej klasy i zoptymalizowano

ChunkManager.cpp

@@ -35,7 +35,7 @@ std::vector<char> ChunkManager::chunked(const std::vector<char>& raw, const bool
 		// Skopiuj fragment danych do chunka
 		std::vector<char> chunk(begin, end);
 
-		std::vector<char> outChunk = encrypt ? eman.encrypt(compress_data(chunk)) : compress_data(chunk);
+		std::vector<char> outChunk = encrypt ? eman.encrypt(cman.compress(chunk)) : cman.compress(chunk);
 
 		uint32_t chs = chunk.size();
 		uint32_t zch = outChunk.size();
@@ -62,56 +62,6 @@ std::vector<char> ChunkManager::chunked(const std::vector<char>& raw, const bool
 	return zip;
 }
 
-// Kompresja
-std::vector<char> ChunkManager::compress_data(const std::vector<char>& input)
-{
-	const int level = COMPRESSION_LEVEL;
-
-	// Obs³uga pustego chunku: zwracamy pusty wynik (0 bajtów).
-	if (input.empty()) return {};
-
-	ZSTD_CCtx* cctx = ZSTD_createCCtx();
-	if (!cctx) {
-		std::cerr << "ZSTD_createCCtx failed\n";
-		return {};
-	}
-
-	// Ustawienia „bez ramek”
-	size_t rc = 0;
-	rc |= ZSTD_CCtx_setParameter(cctx, ZSTD_c_format, ZSTD_f_zstd1_magicless);
-	rc |= ZSTD_CCtx_setParameter(cctx, ZSTD_c_checksumFlag, 0);
-	rc |= ZSTD_CCtx_setParameter(cctx, ZSTD_c_contentSizeFlag, 0);
-	rc |= ZSTD_CCtx_setParameter(cctx, ZSTD_c_dictIDFlag, 0);
-	rc |= ZSTD_CCtx_setParameter(cctx, ZSTD_c_compressionLevel, level);
-
-	if (ZSTD_isError(rc)) {
-		std::cerr << "ZSTD_CCtx_setParameter error\n";
-		ZSTD_freeCCtx(cctx);
-		return {};
-	}
-
-	const size_t srcSize = input.size();
-
-	// Szacowanie rozmiaru skompresowanego vectoru
-	const size_t maxDst = ZSTD_compressBound(srcSize);
-
-	std::vector<char> out(maxDst);
-
-	// Faktyczna kompresja
-	size_t written = ZSTD_compress2(cctx, out.data(), maxDst,
-		input.data(), srcSize);
-
-	ZSTD_freeCCtx(cctx);
-
-	if (ZSTD_isError(written)) {
-		std::cerr << "ZSTD_compress2 error: " << ZSTD_getErrorName(written) << "\n";
-		return {};
-	}
-
-	out.resize(written);
-	return out;
-}
-
 //////////////////////////////////////////////////////////////
 
 //-----------------------------------------------------------------------------
@@ -142,36 +92,11 @@ std::vector<char> ChunkManager::dechunked(const std::vector<char>& zip, const bo
 		std::vector<char> zipChunk = encrypt ? eman.decrypt(inChunk) : std::move(inChunk);
 
 		// Zdeklarój pusty chunk
-		std::vector<char> chunk = decompress_data(zipChunk, chunkSize);
+		std::vector<char> chunk = cman.decompress(zipChunk, chunkSize);
 
 		// Scal chunki
 		chunksString.insert(chunksString.end(), chunk.begin(), chunk.end());
 	}
 
 	return chunksString;
-}
-
-// Dekompresja
-std::vector<char> ChunkManager::decompress_data(const std::vector<char>& input, const size_t& expected)
-{
-	ZSTD_DCtx* dctx = ZSTD_createDCtx();
-	size_t r = 0;
-	r |= ZSTD_DCtx_setParameter(dctx, ZSTD_d_format, ZSTD_f_zstd1_magicless);
-	if (ZSTD_isError(r))
-	{
-		std::cerr << "ZSTD_DCtx_setParameter error" << std::endl;
-		ZSTD_freeDCtx(dctx);
-	}
-
-	std::vector<char> output(expected);
-	
-	size_t dsize = ZSTD_decompressDCtx(dctx, output.data(), expected, input.data(), input.size());
-	ZSTD_freeDCtx(dctx);
-
-	if (ZSTD_isError(dsize)) {
-		std::cerr << "ZSTD_decompressDCtx error: " << ZSTD_getErrorName(dsize) << "\n";
-		return {};
-	}
-
-	return output;
 }

ChunkManager.h

@@ -6,17 +6,11 @@
 #include <stdexcept>
 #include <algorithm>
 #include <iostream>
-#define ZSTD_STATIC_LINKING_ONLY
-#include <zstd.h>
-
-#if ZSTD_VERSION_NUMBER < 10400
-#error "Wymagane zstd >= 1.4.0 dla ZSTD_c_format / ZSTD_f_zstd1_magicless"
-#endif
 
 #include "EncryptionManager.h"
+#include "CompressionManager.h"
 
 #define BLOCK_SIZE          131072 // 128KB
-#define COMPRESSION_LEVEL   3
 
 struct BlockSize
 {
@@ -38,6 +32,7 @@ public:
 
 private:
 	EncryptionManager eman;
+	CompressionManager cman;
 	std::vector<BlockSize> blockSizes;
 
 	// Przekonwertuj zmienn¹ na ci¹g na vector
@@ -59,11 +54,5 @@ private:
 	
 		return tmp;
 	}
-
-	// Kompresja
-	std::vector<char> compress_data(const std::vector<char>&);
-
-	// Dekompresja
-	std::vector<char> decompress_data(const std::vector<char>&, const size_t&);
 };
 

CompressionManager.cpp

@@ -0,0 +1,95 @@
+#include "CompressionManager.h"
+
+CompressionManager::CompressionManager()
+	:cctx(ZSTD_createCCtx())
+	,dctx(ZSTD_createDCtx())
+{
+	// Tu ustawienia pod kompresjê
+	const int level = COMPRESSION_LEVEL;
+
+	// Ustawienia frameless
+	size_t rc = 0;
+
+	// Wy³¹cza ramkê i przestawia strumieñ na czyste bloki
+	rc |= ZSTD_CCtx_setParameter(cctx, ZSTD_c_format, ZSTD_f_zstd1_magicless);
+
+	// Wy³¹cza sumê kontroln¹ na poziomie ramki
+	rc |= ZSTD_CCtx_setParameter(cctx, ZSTD_c_checksumFlag, 0);
+
+	// Wy³¹cza zapisywanie „content size” w nag³ówku ramki
+	rc |= ZSTD_CCtx_setParameter(cctx, ZSTD_c_contentSizeFlag, 0);
+
+	// Wy³¹cza zapisywanie identyfikatora s³ownika
+	rc |= ZSTD_CCtx_setParameter(cctx, ZSTD_c_dictIDFlag, 0);
+
+	// Ustawia poziom kompresji
+	rc |= ZSTD_CCtx_setParameter(cctx, ZSTD_c_compressionLevel, level);
+
+	if (ZSTD_isError(rc)) {
+		std::cerr << "ZSTD_CCtx_setParameter error" << std::endl;
+		ZSTD_freeCCtx(cctx);
+	}
+
+	/*====Tutaj Dekompresja=============================================================*/
+
+	size_t r = 0;
+
+	// Przestawia dekompresjê na czyste bloki bez nag³ówka
+	r |= ZSTD_DCtx_setParameter(dctx, ZSTD_d_format, ZSTD_f_zstd1_magicless);
+	if (ZSTD_isError(r))
+	{
+		std::cerr << "ZSTD_DCtx_setParameter error" << std::endl;
+		ZSTD_freeDCtx(dctx);
+	}
+}
+
+CompressionManager::~CompressionManager()
+{
+	ZSTD_freeCCtx(cctx);
+	ZSTD_freeDCtx(dctx);
+}
+
+//-----------------------------------------------------------------------------
+//	Kompresja ZSTD frameless
+//-----------------------------------------------------------------------------
+std::vector<char> CompressionManager::compress(const std::vector<char>& input)
+{
+	// Obs³uga pustego chunku: zwracamy pusty wynik (0 bajtów).
+	if (input.empty()) return {};
+
+	const size_t srcSize = input.size();
+
+	// Szacowanie rozmiaru skompresowanego vectoru
+	const size_t maxDst = ZSTD_compressBound(srcSize);
+
+	std::vector<char> out(maxDst);
+
+	// Faktyczna kompresja
+	size_t written = ZSTD_compress2(cctx, out.data(), maxDst,
+		input.data(), srcSize);
+
+	if (ZSTD_isError(written)) {
+		std::cerr << "ZSTD_compress error: " << ZSTD_getErrorName(written) << std::endl;
+		return {};
+	}
+
+	out.resize(written);
+	return out;
+}
+
+//-----------------------------------------------------------------------------
+//	Dekompresja ZSTD
+//-----------------------------------------------------------------------------
+std::vector<char> CompressionManager::decompress(const std::vector<char>& input, const size_t& expected)
+{
+	std::vector<char> output(expected);
+
+	size_t dsize = ZSTD_decompressDCtx(dctx, output.data(), expected, input.data(), input.size());
+
+	if (ZSTD_isError(dsize)) {
+		std::cerr << "ZSTD_decompressDCtx error: " << ZSTD_getErrorName(dsize) << "\n";
+		return {};
+	}
+
+	return output;
+}

CompressionManager.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <iostream>
+#include <stdexcept>
+#include <algorithm>
+#include <vector>
+#define ZSTD_STATIC_LINKING_ONLY
+#include <zstd.h>
+
+#if ZSTD_VERSION_NUMBER < 10400
+#error "Wymagane zstd >= 1.4.0 dla ZSTD_c_format / ZSTD_f_zstd1_magicless"
+#endif
+
+#define COMPRESSION_LEVEL   3 
+
+class CompressionManager
+{
+public:
+	CompressionManager();
+	~CompressionManager();
+
+	std::vector<char> compress(const std::vector<char>&);
+	std::vector<char> decompress(const std::vector<char>&, const size_t&);
+
+private:
+	ZSTD_CCtx* cctx;
+	ZSTD_DCtx* dctx;
+};
+

voidcmd.vcxproj

@@ -133,6 +133,7 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="ChunkManager.cpp" />
+    <ClCompile Include="CompressionManager.cpp" />
     <ClCompile Include="CreateCargo.cpp" />
     <ClCompile Include="EncryptionManager.cpp" />
     <ClCompile Include="ExtractCargo.cpp" />
@@ -142,6 +143,7 @@
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="ChunkManager.h" />
+    <ClInclude Include="CompressionManager.h" />
     <ClInclude Include="CreateCargo.h" />
     <ClInclude Include="DataStruct.h" />
     <ClInclude Include="EncryptionManager.h" />

voidcmd.vcxproj.filters

@@ -36,6 +36,9 @@
     <ClCompile Include="EncryptionManager.cpp">
       <Filter>Pliki źródłowe</Filter>
     </ClCompile>
+    <ClCompile Include="CompressionManager.cpp">
+      <Filter>Pliki źródłowe</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="CreateCargo.h">
@@ -59,6 +62,9 @@
     <ClInclude Include="EncryptionManager.h">
       <Filter>Pliki nagłówkowe</Filter>
     </ClInclude>
+    <ClInclude Include="CompressionManager.h">
+      <Filter>Pliki nagłówkowe</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Image Include="icon.ico">