Bump par2-turbo to v1.4.0-20260803, pass -T flag, and clamp stage progress

dnzbk · dnzbk · commit 1cd950e5d264 · 2026-08-03T08:59:06.000+03:00
diff --git a/cmake/par2-turbo.cmake b/cmake/par2-turbo.cmake
@@ -57,7 +57,7 @@ ExternalProject_add(
 	par2-turbo
 	PREFIX			par2-turbo
 	GIT_REPOSITORY	https://github.com/nzbgetcom/par2cmdline-turbo.git
-	GIT_TAG			v1.4.0-20260323
+	GIT_TAG			v1.4.0-20260803
 	TLS_VERIFY		TRUE
 	GIT_SHALLOW		TRUE
 	GIT_PROGRESS	TRUE
diff --git a/daemon/postprocess/ParChecker.cpp b/daemon/postprocess/ParChecker.cpp
@@ -25,6 +25,7 @@
 
 #include <vector>
 #include <string>
+#include <algorithm>
 
 #include <par2/libpar2.h>
 #include <par2/commandline.h>
@@ -36,7 +37,7 @@
 #include "Util.h"
 #include "FileSystem.h"
 
-const char* Par2CmdLineErrStr[] = { 
+static const char* Par2CmdLineErrStr[] = { 
 	"OK",
 	"data files are damaged and there is enough recovery data available to repair them",
 	"data files are damaged and there is insufficient recovery data available to be able to repair them",
@@ -48,7 +49,7 @@ const char* Par2CmdLineErrStr[] = {
 	"out of memory" 
 };
 
-const char* Par2StageMessage[] = { 
+static const char* Par2StageMessage[] = { 
 	"Loading file", 
 	"Verifying file", 
 	"Repairing file", 
@@ -73,7 +74,7 @@ class Repairer final : public Par2::Par2Repairer, public ParChecker::AbstractRep
 	}
 	Par2::Result PreProcess(const std::string& parFilename);
 	Par2::Result Process(bool dorepair);
-	virtual Repairer* GetRepairer() { return this; }
+	Repairer* GetRepairer() override { return this; }
 
 protected:
 	void SigFilename(std::string filename) override { m_owner->SignalFilename(std::move(filename)); }
@@ -110,8 +111,10 @@ class RepairCreatorPacket : public Par2::CreatorPacket
 
 Par2::Result Repairer::PreProcess(const std::string& parFilename)
 {
+	std::string threadsStr = std::to_string(m_threadsToUse);
 	std::string memParam = "-m" + std::to_string(m_memToUse);
-	std::string threadsParam = "-t" + std::to_string(m_threadsToUse);
+	std::string threadsParam = "-t" + threadsStr;
+	std::string fileThreadsParam = "-T" + threadsStr;
 
 	if (g_Options->GetParScan() == Options::psFull)
 	{
@@ -123,16 +126,16 @@ Par2::Result Repairer::PreProcess(const std::string& parFilename)
 			basename[1] = '\0';
 		}
 
-		const char* argv[] = { "par2", "r", "-v", memParam.c_str(), threadsParam.c_str(), parFilename.c_str(), wildcardParam };
-		if (!m_commandLine.Parse(7, (char**)argv))
+		const char* argv[] = { "par2", "r", "-v", memParam.c_str(), threadsParam.c_str(), fileThreadsParam.c_str(), parFilename.c_str(), wildcardParam };
+		if (!m_commandLine.Parse(8, const_cast<char**>(argv)))
 		{
 			return Par2::eInvalidCommandLineArguments;
 		}
 	}
 	else
 	{
-		const char* argv[] = { "par2", "r", "-v", memParam.c_str(), threadsParam.c_str(), parFilename.c_str() };
-		if (!m_commandLine.Parse(6, (char**)argv))
+		const char* argv[] = { "par2", "r", "-v", memParam.c_str(), threadsParam.c_str(), fileThreadsParam.c_str(), parFilename.c_str() };
+		if (!m_commandLine.Parse(7, const_cast<char**>(argv)))
 		{
 			return Par2::eInvalidCommandLineArguments;
 		}
@@ -179,11 +182,11 @@ bool Repairer::ScanDataFile(
 
 		if (!(m_owner->GetStage() == ParChecker::ptVerifyingRepaired && m_owner->GetParFull()))
 		{
-			int availableBlocks = sourcefile->BlockCount();
+			int availableBlocks = static_cast<int>(sourcefile->BlockCount());
 			ParChecker::EFileStatus fileStatus = m_owner->VerifyDataFile(*diskfile, *sourcefile, availableBlocks);
 			if (fileStatus != ParChecker::fsUnknown)
 			{
-				SigDone(name, availableBlocks, sourcefile->BlockCount());
+				SigDone(name, availableBlocks, static_cast<int>(sourcefile->BlockCount()));
 				SigProgress(1000);
 				matchtype = fileStatus == ParChecker::fsSuccess ? Par2::eFullMatch :
 					fileStatus == ParChecker::fsPartial ? Par2::ePartialMatch : Par2::eNoMatch;
@@ -206,8 +209,8 @@ bool Repairer::ScanDataFile(
 
 void Repairer::BeginRepair()
 {
-	m_owner->PrintMessage(Message::mkInfo, "Using %i thread(s) and %i MB to repair %i block(s) for %s",
-		m_threadsToUse, m_memToUse, (int)missingblockcount, m_owner->m_nzbName.c_str());
+	m_owner->PrintMessage(Message::mkInfo, "Using %i thread(s) and %i MB to repair %u block(s) for %s",
+		m_threadsToUse, m_memToUse, missingblockcount, m_owner->m_nzbName.c_str());
 }
 
 int ParChecker::StreamBuf::overflow(int ch)
@@ -387,7 +390,7 @@ ParChecker::EStatus ParChecker::RunParCheck(std::string parFilename)
 
 	if (m_hasDamagedFiles && !IsStopped() && res == Par2::eRepairNotPossible)
 	{
-		res = (Par2::Result)ProcessMorePars();
+		res = static_cast<Par2::Result>(ProcessMorePars());
 	}
 
 	if (m_hasDamagedFiles && !IsStopped() && res == Par2::eRepairNotPossible &&
@@ -398,7 +401,7 @@ ParChecker::EStatus ParChecker::RunParCheck(std::string parFilename)
 			res = GetRepairer()->Process(false);
 			if (!IsStopped() && res == Par2::eRepairNotPossible)
 			{
-				res = (Par2::Result)ProcessMorePars();
+				res = static_cast<Par2::Result>(ProcessMorePars());
 			}
 		}
 	}
@@ -429,7 +432,7 @@ ParChecker::EStatus ParChecker::RunParCheck(std::string parFilename)
 			m_stageProgress = 0;
 			m_processedCount = 0;
 			m_stage = ptRepairing;
-			m_filesToRepair = GetRepairer()->damagedfilecount + GetRepairer()->missingfilecount;
+			m_filesToRepair = static_cast<int>(GetRepairer()->damagedfilecount + GetRepairer()->missingfilecount);
 			UpdateProgress();
 
 			res = GetRepairer()->Process(true);
@@ -468,7 +471,7 @@ ParChecker::EStatus ParChecker::RunParCheck(std::string parFilename)
 	}
 	else if (status == psFailed)
 	{
-		if (m_errMsg.empty() && (int)res >= 0 && (int)res <= 8)
+		if (m_errMsg.empty() && static_cast<int>(res) >= 0 && static_cast<int>(res) <= 8)
 		{
 			m_errMsg = Par2CmdLineErrStr[res];
 		}
@@ -593,8 +596,7 @@ int ParChecker::ProcessMorePars()
 	bool moreFilesLoaded = true;
 	while (!IsStopped() && res == Par2::eRepairNotPossible)
 	{
-		int missingblockcount = GetRepairer()->missingblockcount -
-			GetRepairer()->recoverypacketmap.size();
+		int missingblockcount = static_cast<int>(GetRepairer()->missingblockcount - GetRepairer()->recoverypacketmap.size());
 		if (missingblockcount <= 0)
 		{
 			return Par2::eRepairPossible;
@@ -754,7 +756,7 @@ bool ParChecker::AddSplittedFragments()
 bool ParChecker::MaybeSplittedFragement(const char* filename1, const char* filename2)
 {
 	// check if name is same but the first name has additional numerical extension
-	int len = strlen(filename2);
+	size_t len = strlen(filename2);
 	if (!strncasecmp(filename1, filename2, len))
 	{
 		const char* p = filename1 + len;
@@ -803,24 +805,24 @@ bool ParChecker::AddDupeFiles()
 
 		if (!m_dupeSources.empty())
 		{
-			int wasBlocksMissing = GetRepairer()->missingblockcount;
+			uint32_t wasBlocksMissing = GetRepairer()->missingblockcount;
 
 			for (DupeSource& dupeSource : m_dupeSources)
 			{
 				if (GetRepairer()->missingblockcount > 0 && FileSystem::DirectoryExists(dupeSource.GetDirectory()))
 				{
-					int wasBlocksMissing2 = GetRepairer()->missingblockcount;
+					uint32_t wasBlocksMissing2 = GetRepairer()->missingblockcount;
 					bool oneAdded = AddExtraFiles(false, true, dupeSource.GetDirectory());
 					added |= oneAdded;
-					int blocksMissing2 = GetRepairer()->missingblockcount;
-					dupeSource.SetUsedBlocks(dupeSource.GetUsedBlocks() + (wasBlocksMissing2 - blocksMissing2));
+					uint32_t blocksMissing2 = GetRepairer()->missingblockcount;
+					dupeSource.SetUsedBlocks(dupeSource.GetUsedBlocks() + static_cast<int>((wasBlocksMissing2 - blocksMissing2)));
 				}
 			}
 
-			int blocksMissing = GetRepairer()->missingblockcount;
+			uint32_t blocksMissing = GetRepairer()->missingblockcount;
 			if (blocksMissing < wasBlocksMissing)
 			{
-				PrintMessage(Message::mkInfo, "Found extra %i blocks in dupe sources", wasBlocksMissing - blocksMissing);
+				PrintMessage(Message::mkInfo, "Found extra %u blocks in dupe sources", wasBlocksMissing - blocksMissing);
 			}
 			else
 			{
@@ -906,14 +908,14 @@ bool ParChecker::AddExtraFiles(bool onlyMissing, bool externalDir, const char* d
 			const std::string& extraFile = extrafiles[idx];
 			++idx;
 
-			int wasFilesMissing = GetRepairer()->missingfilecount;
-			int wasBlocksMissing = GetRepairer()->missingblockcount;
+			uint32_t wasFilesMissing = GetRepairer()->missingfilecount;
+			uint32_t wasBlocksMissing = GetRepairer()->missingblockcount;
 
 			GetRepairer()->VerifyExtraFiles({ extraFile }, m_destDir, false);
 			GetRepairer()->UpdateVerificationResults();
 
-			bool fileAdded = wasFilesMissing > (int)GetRepairer()->missingfilecount;
-			bool blockAdded = wasBlocksMissing > (int)GetRepairer()->missingblockcount;
+			bool fileAdded = wasFilesMissing > GetRepairer()->missingfilecount;
+			bool blockAdded = wasBlocksMissing > GetRepairer()->missingblockcount;
 
 			if (fileAdded && !externalDir)
 			{
@@ -922,7 +924,7 @@ bool ParChecker::AddExtraFiles(bool onlyMissing, bool externalDir, const char* d
 			}
 			else if (blockAdded)
 			{
-				PrintMessage(Message::mkInfo, "Found %i missing blocks", wasBlocksMissing - (int)GetRepairer()->missingblockcount);
+				PrintMessage(Message::mkInfo, "Found %u missing blocks", wasBlocksMissing - GetRepairer()->missingblockcount);
 			}
 
 			filesAdded |= fileAdded | blockAdded;
@@ -1011,7 +1013,7 @@ void ParChecker::SignalProgress(int progress)
 		else
 		{
 			// verifying individual files
-			totalFiles = GetRepairer()->sourcefiles.size() + m_extraFiles;
+			totalFiles = static_cast<int>(GetRepairer()->sourcefiles.size()) + m_extraFiles;
 			if (m_extraFiles > 0)
 			{
 				// during extra par scan don't count quickly verified files;
@@ -1041,6 +1043,8 @@ void ParChecker::SignalProgress(int progress)
 
 	debug("Current-progress: %i, Total-progress: %i", m_fileProgress, m_stageProgress);
 
+	m_stageProgress = std::clamp(m_stageProgress, 0, 1000);
+
 	UpdateProgress();
 }
 
@@ -1115,8 +1119,8 @@ void ParChecker::CheckEmptyFiles()
 				bool ignore = Util::MatchFileExt(filenameObj.c_str(), g_Options->GetParIgnoreExt(), ",;");
 				m_hasDamagedFiles |= !ignore;
 
-				int total = sourcefile->GetVerificationPacket() ? sourcefile->GetVerificationPacket()->BlockCount() : 0;
-				PrintMessage(Message::mkWarning, "File %s has %i bad block(s) of total %i block(s)%s",
+				uint32_t total = sourcefile->GetVerificationPacket() ? sourcefile->GetVerificationPacket()->BlockCount() : 0;
+				PrintMessage(Message::mkWarning, "File %s has %u bad block(s) of total %u block(s)%s",
 					filenameObj.c_str(), total, total, ignore ? ", ignoring" : "");
 			}
 		}
@@ -1151,7 +1155,7 @@ void ParChecker::SaveSourceList()
 		}
 
 		std::vector<Par2::DataBlock>::iterator it2 = sourcefile->SourceBlocks();
-		for (int i = 0; i < (int)sourcefile->BlockCount(); i++, it2++)
+		for (uint32_t i = 0; i < sourcefile->BlockCount(); ++i, ++it2)
 		{
 			Par2::DataBlock block = *it2;
 			Par2::DiskFile* sourceFile = block.GetDiskFile();
@@ -1293,14 +1297,14 @@ ParChecker::EFileStatus ParChecker::VerifyDataFile(Par2::DiskFile& diskFile, Par
 	return fileStatus;
 }
 
-bool ParChecker::VerifySuccessDataFile(Par2::DiskFile& diskFile, Par2::Par2RepairerSourceFile& sourceFile, uint32 downloadCrc)
+bool ParChecker::VerifySuccessDataFile(Par2::DiskFile&, Par2::Par2RepairerSourceFile& sourceFile, uint32 downloadCrc)
 {
 	Par2::u64 blocksize = GetRepairer()->mainpacket->BlockSize();
 	Par2::VerificationPacket* packet = sourceFile.GetVerificationPacket();
 
 	// extend lDownloadCrc to block size
 	downloadCrc = Par2::CRCUpdateBlock(downloadCrc ^ 0xFFFFFFFF,
-		(size_t)(blocksize * packet->BlockCount() > sourceFile.GetTargetFile()->FileSize() ?
+		(blocksize * packet->BlockCount() > sourceFile.GetTargetFile()->FileSize() ?
 			blocksize * packet->BlockCount() - sourceFile.GetTargetFile()->FileSize() : 0)
 		) ^ 0xFFFFFFFF;
 	debug("Download-CRC: %.8x", downloadCrc);
@@ -1319,7 +1323,7 @@ bool ParChecker::VerifySuccessDataFile(Par2::DiskFile& diskFile, Par2::Par2Repai
 	return parCrc == downloadCrc;
 }
 
-bool ParChecker::VerifyPartialDataFile(Par2::DiskFile& diskFile, Par2::Par2RepairerSourceFile& sourceFile, SegmentList& segments, ValidBlocks& validBlocks)
+bool ParChecker::VerifyPartialDataFile(Par2::DiskFile&, Par2::Par2RepairerSourceFile& sourceFile, SegmentList& segments, ValidBlocks& validBlocks)
 {
 	Par2::VerificationPacket* packet = sourceFile.GetVerificationPacket();
 	int64 blocksize = GetRepairer()->mainpacket->BlockSize();
diff --git a/daemon/postprocess/ParChecker.h b/daemon/postprocess/ParChecker.h
@@ -30,8 +30,6 @@
 
 #include <par2/par2repairer.h>
 
-#include "NString.h"
-#include "Container.h"
 #include "FileSystem.h"
 #include "Log.h"
 
@@ -61,7 +59,7 @@ class ParChecker
 	class AbstractRepairer
 	{
 	public:
-		virtual ~AbstractRepairer() {};
+		virtual ~AbstractRepairer() = default;
 		virtual Repairer* GetRepairer() = 0;
 	};
 
@@ -120,8 +118,8 @@ class ParChecker
 
 	private:
 		int m_id;
-		std::string m_directory;
 		int m_usedBlocks = 0;
+		std::string m_directory;
 	};
 
 	typedef std::deque<DupeSource> DupeSourceList;
@@ -141,7 +139,7 @@ class ParChecker
 	*/
 	virtual bool RequestMorePars(int blockNeeded, int* blockFound) = 0;
 	virtual void UpdateProgress() {}
-	virtual bool IsStopped() { return false; };
+	virtual bool IsStopped() { return false; }
 	virtual void Completed() {}
 	virtual void PrintMessage([[maybe_unused]] Message::EKind kind,
 		[[maybe_unused]] const char* format, ...) PRINTF_SYNTAX(3) {}
@@ -158,42 +156,39 @@ class ParChecker
 	int GetStageProgress() { return m_stageProgress; }
 
 private:
-	class StreamBuf : public std::streambuf
+	class StreamBuf final : public std::streambuf
 	{
 	public:
 		StreamBuf(ParChecker* owner, Message::EKind kind) : m_owner(owner), m_kind(kind) {}
 		virtual int overflow(int ch) override;
 	private:
+		std::string m_buffer;
 		ParChecker* m_owner;
 		Message::EKind m_kind;
-		std::string m_buffer;
 	};
 
 	typedef std::deque<std::string> FileList;
 	typedef std::deque<Par2::DiskFile*> SourceList;
 	typedef std::vector<bool> ValidBlocks;
 
-	bool m_queuedParFilesChanged;
-	bool m_verifyingExtraFiles;
-	bool m_cancelled;
-	bool m_hasDamagedFiles;
-	bool m_forceRepair = false;
-	int m_processedCount;
-	int m_filesToRepair;
-	int m_extraFiles;
-	int m_fileProgress;
-	int m_stageProgress;
-	std::atomic<bool> m_parQuick{false};
-	std::atomic<bool> m_parFull{false};
-	std::atomic<int> m_quickFiles{0};
 	std::string m_infoName;
 	std::string m_destDir;
 	std::string m_nzbName;
 	std::string m_parFilename;
 	std::string m_progressLabel;
 	std::string m_errMsg;
+
+	int m_processedCount;
+	int m_filesToRepair;
+	int m_extraFiles;
+	int m_fileProgress;
+	int m_stageProgress;
+
 	EStatus m_status = psFailed;
+
 	std::atomic<EStage> m_stage{ptLoadingPars};
+	std::atomic<int> m_quickFiles{0};
+
 	FileList m_queuedParFiles;
 	FileList m_processedFiles;
 	SourceList m_sourceFiles;
@@ -209,6 +204,16 @@ class ParChecker
 	// "m_repairer" should be of type "Par2::Par2Repairer", however to prevent the
 	// including of libpar2-headers into this header-file we use an empty abstract class.
 	std::unique_ptr<AbstractRepairer> m_repairer;
+
+	std::atomic<bool> m_parQuick{false};
+	std::atomic<bool> m_parFull{false};
+
+	bool m_queuedParFilesChanged;
+	bool m_verifyingExtraFiles;
+	bool m_cancelled;
+	bool m_hasDamagedFiles;
+	bool m_forceRepair = false;
+
 	Repairer* GetRepairer() { return m_repairer->GetRepairer(); }
 
 	void Cleanup();
diff --git a/daemon/queue/DownloadInfo.h b/daemon/queue/DownloadInfo.h

Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,7 @@`
`25`	`25`
`26`	`26`	`#include <vector>`
`27`	`27`	`#include <string>`
	`28`	`+#include <algorithm>`
`28`	`29`
`29`	`30`	`#include <par2/libpar2.h>`
`30`	`31`	`#include <par2/commandline.h>`
`@@ -36,7 +37,7 @@`
`36`	`37`	`#include "Util.h"`
`37`	`38`	`#include "FileSystem.h"`
`38`	`39`
`39`		`-const char* Par2CmdLineErrStr[] = {`
	`40`	`+static const char* Par2CmdLineErrStr[] = {`
`40`	`41`	`"OK",`
`41`	`42`	`"data files are damaged and there is enough recovery data available to repair them",`
`42`	`43`	`"data files are damaged and there is insufficient recovery data available to be able to repair them",`
`@@ -48,7 +49,7 @@ const char* Par2CmdLineErrStr[] = {`
`48`	`49`	`"out of memory"`
`49`	`50`	`};`
`50`	`51`
`51`		`-const char* Par2StageMessage[] = {`
	`52`	`+static const char* Par2StageMessage[] = {`
`52`	`53`	`"Loading file",`
`53`	`54`	`"Verifying file",`
`54`	`55`	`"Repairing file",`
`@@ -73,7 +74,7 @@ class Repairer final : public Par2::Par2Repairer, public ParChecker::AbstractRep`
`73`	`74`	`}`
`74`	`75`	`Par2::Result PreProcess(const std::string& parFilename);`
`75`	`76`	`Par2::Result Process(bool dorepair);`
`76`		`- virtual Repairer* GetRepairer() { return this; }`
	`77`	`+ Repairer* GetRepairer() override { return this; }`
`77`	`78`
`78`	`79`	`protected:`
`79`	`80`	`void SigFilename(std::string filename) override { m_owner->SignalFilename(std::move(filename)); }`
`@@ -110,8 +111,10 @@ class RepairCreatorPacket : public Par2::CreatorPacket`
`110`	`111`
`111`	`112`	`Par2::Result Repairer::PreProcess(const std::string& parFilename)`
`112`	`113`	`{`
	`114`	`+ std::string threadsStr = std::to_string(m_threadsToUse);`
`113`	`115`	`std::string memParam = "-m" + std::to_string(m_memToUse);`
`114`		`- std::string threadsParam = "-t" + std::to_string(m_threadsToUse);`
	`116`	`+ std::string threadsParam = "-t" + threadsStr;`
	`117`	`+ std::string fileThreadsParam = "-T" + threadsStr;`
`115`	`118`
`116`	`119`	`if (g_Options->GetParScan() == Options::psFull)`
`117`	`120`	`{`
`@@ -123,16 +126,16 @@ Par2::Result Repairer::PreProcess(const std::string& parFilename)`
`123`	`126`	`basename[1] = '\0';`
`124`	`127`	`}`
`125`	`128`
`126`		`- const char* argv[] = { "par2", "r", "-v", memParam.c_str(), threadsParam.c_str(), parFilename.c_str(), wildcardParam };`
`127`		`- if (!m_commandLine.Parse(7, (char**)argv))`
	`129`	`+ const char* argv[] = { "par2", "r", "-v", memParam.c_str(), threadsParam.c_str(), fileThreadsParam.c_str(), parFilename.c_str(), wildcardParam };`
	`130`	`+ if (!m_commandLine.Parse(8, const_cast<char**>(argv)))`
`128`	`131`	`{`
`129`	`132`	`return Par2::eInvalidCommandLineArguments;`
`130`	`133`	`}`
`131`	`134`	`}`
`132`	`135`	`else`
`133`	`136`	`{`
`134`		`- const char* argv[] = { "par2", "r", "-v", memParam.c_str(), threadsParam.c_str(), parFilename.c_str() };`
`135`		`- if (!m_commandLine.Parse(6, (char**)argv))`
	`137`	`+ const char* argv[] = { "par2", "r", "-v", memParam.c_str(), threadsParam.c_str(), fileThreadsParam.c_str(), parFilename.c_str() };`
	`138`	`+ if (!m_commandLine.Parse(7, const_cast<char**>(argv)))`
`136`	`139`	`{`
`137`	`140`	`return Par2::eInvalidCommandLineArguments;`
`138`	`141`	`}`
`@@ -179,11 +182,11 @@ bool Repairer::ScanDataFile(`
`179`	`182`
`180`	`183`	`if (!(m_owner->GetStage() == ParChecker::ptVerifyingRepaired && m_owner->GetParFull()))`
`181`	`184`	`{`
`182`		`- int availableBlocks = sourcefile->BlockCount();`
	`185`	`+ int availableBlocks = static_cast<int>(sourcefile->BlockCount());`
`183`	`186`	`ParChecker::EFileStatus fileStatus = m_owner->VerifyDataFile(diskfile, sourcefile, availableBlocks);`
`184`	`187`	`if (fileStatus != ParChecker::fsUnknown)`
`185`	`188`	`{`
`186`		`- SigDone(name, availableBlocks, sourcefile->BlockCount());`
	`189`	`+ SigDone(name, availableBlocks, static_cast<int>(sourcefile->BlockCount()));`
`187`	`190`	`SigProgress(1000);`
`188`	`191`	`matchtype = fileStatus == ParChecker::fsSuccess ? Par2::eFullMatch :`
`189`	`192`	`fileStatus == ParChecker::fsPartial ? Par2::ePartialMatch : Par2::eNoMatch;`
`@@ -206,8 +209,8 @@ bool Repairer::ScanDataFile(`
`206`	`209`
`207`	`210`	`void Repairer::BeginRepair()`
`208`	`211`	`{`
`209`		`- m_owner->PrintMessage(Message::mkInfo, "Using %i thread(s) and %i MB to repair %i block(s) for %s",`
`210`		`- m_threadsToUse, m_memToUse, (int)missingblockcount, m_owner->m_nzbName.c_str());`
	`212`	`+ m_owner->PrintMessage(Message::mkInfo, "Using %i thread(s) and %i MB to repair %u block(s) for %s",`
	`213`	`+ m_threadsToUse, m_memToUse, missingblockcount, m_owner->m_nzbName.c_str());`
`211`	`214`	`}`
`212`	`215`
`213`	`216`	`int ParChecker::StreamBuf::overflow(int ch)`
`@@ -387,7 +390,7 @@ ParChecker::EStatus ParChecker::RunParCheck(std::string parFilename)`
`387`	`390`
`388`	`391`	`if (m_hasDamagedFiles && !IsStopped() && res == Par2::eRepairNotPossible)`
`389`	`392`	`{`
`390`		`- res = (Par2::Result)ProcessMorePars();`
	`393`	`+ res = static_cast<Par2::Result>(ProcessMorePars());`
`391`	`394`	`}`
`392`	`395`
`393`	`396`	`if (m_hasDamagedFiles && !IsStopped() && res == Par2::eRepairNotPossible &&`
`@@ -398,7 +401,7 @@ ParChecker::EStatus ParChecker::RunParCheck(std::string parFilename)`
`398`	`401`	`res = GetRepairer()->Process(false);`
`399`	`402`	`if (!IsStopped() && res == Par2::eRepairNotPossible)`
`400`	`403`	`{`
`401`		`- res = (Par2::Result)ProcessMorePars();`
	`404`	`+ res = static_cast<Par2::Result>(ProcessMorePars());`
`402`	`405`	`}`
`403`	`406`	`}`
`404`	`407`	`}`
`@@ -429,7 +432,7 @@ ParChecker::EStatus ParChecker::RunParCheck(std::string parFilename)`
`429`	`432`	`m_stageProgress = 0;`
`430`	`433`	`m_processedCount = 0;`
`431`	`434`	`m_stage = ptRepairing;`
`432`		`- m_filesToRepair = GetRepairer()->damagedfilecount + GetRepairer()->missingfilecount;`
	`435`	`+ m_filesToRepair = static_cast<int>(GetRepairer()->damagedfilecount + GetRepairer()->missingfilecount);`
`433`	`436`	`UpdateProgress();`
`434`	`437`
`435`	`438`	`res = GetRepairer()->Process(true);`
`@@ -468,7 +471,7 @@ ParChecker::EStatus ParChecker::RunParCheck(std::string parFilename)`
`468`	`471`	`}`
`469`	`472`	`else if (status == psFailed)`
`470`	`473`	`{`
`471`		`- if (m_errMsg.empty() && (int)res >= 0 && (int)res <= 8)`
	`474`	`+ if (m_errMsg.empty() && static_cast<int>(res) >= 0 && static_cast<int>(res) <= 8)`
`472`	`475`	`{`
`473`	`476`	`m_errMsg = Par2CmdLineErrStr[res];`
`474`	`477`	`}`
`@@ -593,8 +596,7 @@ int ParChecker::ProcessMorePars()`
`593`	`596`	`bool moreFilesLoaded = true;`
`594`	`597`	`while (!IsStopped() && res == Par2::eRepairNotPossible)`
`595`	`598`	`{`
`596`		`- int missingblockcount = GetRepairer()->missingblockcount -`
`597`		`- GetRepairer()->recoverypacketmap.size();`
	`599`	`+ int missingblockcount = static_cast<int>(GetRepairer()->missingblockcount - GetRepairer()->recoverypacketmap.size());`
`598`	`600`	`if (missingblockcount <= 0)`
`599`	`601`	`{`
`600`	`602`	`return Par2::eRepairPossible;`
`@@ -754,7 +756,7 @@ bool ParChecker::AddSplittedFragments()`
`754`	`756`	`bool ParChecker::MaybeSplittedFragement(const char* filename1, const char* filename2)`
`755`	`757`	`{`
`756`	`758`	`// check if name is same but the first name has additional numerical extension`
`757`		`- int len = strlen(filename2);`
	`759`	`+ size_t len = strlen(filename2);`
`758`	`760`	`if (!strncasecmp(filename1, filename2, len))`
`759`	`761`	`{`
`760`	`762`	`const char* p = filename1 + len;`
`@@ -803,24 +805,24 @@ bool ParChecker::AddDupeFiles()`
`803`	`805`
`804`	`806`	`if (!m_dupeSources.empty())`
`805`	`807`	`{`
`806`		`- int wasBlocksMissing = GetRepairer()->missingblockcount;`
	`808`	`+ uint32_t wasBlocksMissing = GetRepairer()->missingblockcount;`
`807`	`809`
`808`	`810`	`for (DupeSource& dupeSource : m_dupeSources)`
`809`	`811`	`{`
`810`	`812`	`if (GetRepairer()->missingblockcount > 0 && FileSystem::DirectoryExists(dupeSource.GetDirectory()))`
`811`	`813`	`{`
`812`		`- int wasBlocksMissing2 = GetRepairer()->missingblockcount;`
	`814`	`+ uint32_t wasBlocksMissing2 = GetRepairer()->missingblockcount;`
`813`	`815`	`bool oneAdded = AddExtraFiles(false, true, dupeSource.GetDirectory());`
`814`	`816`	`added \|= oneAdded;`
`815`		`- int blocksMissing2 = GetRepairer()->missingblockcount;`
`816`		`- dupeSource.SetUsedBlocks(dupeSource.GetUsedBlocks() + (wasBlocksMissing2 - blocksMissing2));`
	`817`	`+ uint32_t blocksMissing2 = GetRepairer()->missingblockcount;`
	`818`	`+ dupeSource.SetUsedBlocks(dupeSource.GetUsedBlocks() + static_cast<int>((wasBlocksMissing2 - blocksMissing2)));`
`817`	`819`	`}`
`818`	`820`	`}`
`819`	`821`
`820`		`- int blocksMissing = GetRepairer()->missingblockcount;`
	`822`	`+ uint32_t blocksMissing = GetRepairer()->missingblockcount;`
`821`	`823`	`if (blocksMissing < wasBlocksMissing)`
`822`	`824`	`{`
`823`		`- PrintMessage(Message::mkInfo, "Found extra %i blocks in dupe sources", wasBlocksMissing - blocksMissing);`
	`825`	`+ PrintMessage(Message::mkInfo, "Found extra %u blocks in dupe sources", wasBlocksMissing - blocksMissing);`
`824`	`826`	`}`
`825`	`827`	`else`
`826`	`828`	`{`
`@@ -906,14 +908,14 @@ bool ParChecker::AddExtraFiles(bool onlyMissing, bool externalDir, const char* d`
`906`	`908`	`const std::string& extraFile = extrafiles[idx];`
`907`	`909`	`++idx;`
`908`	`910`
`909`		`- int wasFilesMissing = GetRepairer()->missingfilecount;`
`910`		`- int wasBlocksMissing = GetRepairer()->missingblockcount;`
	`911`	`+ uint32_t wasFilesMissing = GetRepairer()->missingfilecount;`
	`912`	`+ uint32_t wasBlocksMissing = GetRepairer()->missingblockcount;`
`911`	`913`
`912`	`914`	`GetRepairer()->VerifyExtraFiles({ extraFile }, m_destDir, false);`
`913`	`915`	`GetRepairer()->UpdateVerificationResults();`
`914`	`916`
`915`		`- bool fileAdded = wasFilesMissing > (int)GetRepairer()->missingfilecount;`
`916`		`- bool blockAdded = wasBlocksMissing > (int)GetRepairer()->missingblockcount;`
	`917`	`+ bool fileAdded = wasFilesMissing > GetRepairer()->missingfilecount;`
	`918`	`+ bool blockAdded = wasBlocksMissing > GetRepairer()->missingblockcount;`
`917`	`919`
`918`	`920`	`if (fileAdded && !externalDir)`
`919`	`921`	`{`
`@@ -922,7 +924,7 @@ bool ParChecker::AddExtraFiles(bool onlyMissing, bool externalDir, const char* d`
`922`	`924`	`}`
`923`	`925`	`else if (blockAdded)`
`924`	`926`	`{`
`925`		`- PrintMessage(Message::mkInfo, "Found %i missing blocks", wasBlocksMissing - (int)GetRepairer()->missingblockcount);`
	`927`	`+ PrintMessage(Message::mkInfo, "Found %u missing blocks", wasBlocksMissing - GetRepairer()->missingblockcount);`
`926`	`928`	`}`
`927`	`929`
`928`	`930`	`filesAdded \|= fileAdded \| blockAdded;`
`@@ -1011,7 +1013,7 @@ void ParChecker::SignalProgress(int progress)`
`1011`	`1013`	`else`
`1012`	`1014`	`{`
`1013`	`1015`	`// verifying individual files`
`1014`		`- totalFiles = GetRepairer()->sourcefiles.size() + m_extraFiles;`
	`1016`	`+ totalFiles = static_cast<int>(GetRepairer()->sourcefiles.size()) + m_extraFiles;`
`1015`	`1017`	`if (m_extraFiles > 0)`
`1016`	`1018`	`{`
`1017`	`1019`	`// during extra par scan don't count quickly verified files;`
`@@ -1041,6 +1043,8 @@ void ParChecker::SignalProgress(int progress)`
`1041`	`1043`
`1042`	`1044`	`debug("Current-progress: %i, Total-progress: %i", m_fileProgress, m_stageProgress);`
`1043`	`1045`
	`1046`	`+ m_stageProgress = std::clamp(m_stageProgress, 0, 1000);`
	`1047`	`+`
`1044`	`1048`	`UpdateProgress();`
`1045`	`1049`	`}`
`1046`	`1050`
`@@ -1115,8 +1119,8 @@ void ParChecker::CheckEmptyFiles()`
`1115`	`1119`	`bool ignore = Util::MatchFileExt(filenameObj.c_str(), g_Options->GetParIgnoreExt(), ",;");`
`1116`	`1120`	`m_hasDamagedFiles \|= !ignore;`
`1117`	`1121`
`1118`		`- int total = sourcefile->GetVerificationPacket() ? sourcefile->GetVerificationPacket()->BlockCount() : 0;`
`1119`		`- PrintMessage(Message::mkWarning, "File %s has %i bad block(s) of total %i block(s)%s",`
	`1122`	`+ uint32_t total = sourcefile->GetVerificationPacket() ? sourcefile->GetVerificationPacket()->BlockCount() : 0;`
	`1123`	`+ PrintMessage(Message::mkWarning, "File %s has %u bad block(s) of total %u block(s)%s",`
`1120`	`1124`	`filenameObj.c_str(), total, total, ignore ? ", ignoring" : "");`
`1121`	`1125`	`}`
`1122`	`1126`	`}`
`@@ -1151,7 +1155,7 @@ void ParChecker::SaveSourceList()`
`1151`	`1155`	`}`
`1152`	`1156`
`1153`	`1157`	`std::vector<Par2::DataBlock>::iterator it2 = sourcefile->SourceBlocks();`
`1154`		`- for (int i = 0; i < (int)sourcefile->BlockCount(); i++, it2++)`
	`1158`	`+ for (uint32_t i = 0; i < sourcefile->BlockCount(); ++i, ++it2)`
`1155`	`1159`	`{`
`1156`	`1160`	`Par2::DataBlock block = *it2;`
`1157`	`1161`	`Par2::DiskFile* sourceFile = block.GetDiskFile();`
`@@ -1293,14 +1297,14 @@ ParChecker::EFileStatus ParChecker::VerifyDataFile(Par2::DiskFile& diskFile, Par`
`1293`	`1297`	`return fileStatus;`
`1294`	`1298`	`}`
`1295`	`1299`
`1296`		`-bool ParChecker::VerifySuccessDataFile(Par2::DiskFile& diskFile, Par2::Par2RepairerSourceFile& sourceFile, uint32 downloadCrc)`
	`1300`	`+bool ParChecker::VerifySuccessDataFile(Par2::DiskFile&, Par2::Par2RepairerSourceFile& sourceFile, uint32 downloadCrc)`
`1297`	`1301`	`{`
`1298`	`1302`	`Par2::u64 blocksize = GetRepairer()->mainpacket->BlockSize();`
`1299`	`1303`	`Par2::VerificationPacket* packet = sourceFile.GetVerificationPacket();`
`1300`	`1304`
`1301`	`1305`	`// extend lDownloadCrc to block size`
`1302`	`1306`	`downloadCrc = Par2::CRCUpdateBlock(downloadCrc ^ 0xFFFFFFFF,`
`1303`		`- (size_t)(blocksize * packet->BlockCount() > sourceFile.GetTargetFile()->FileSize() ?`
	`1307`	`+ (blocksize * packet->BlockCount() > sourceFile.GetTargetFile()->FileSize() ?`
`1304`	`1308`	`blocksize * packet->BlockCount() - sourceFile.GetTargetFile()->FileSize() : 0)`
`1305`	`1309`	`) ^ 0xFFFFFFFF;`
`1306`	`1310`	`debug("Download-CRC: %.8x", downloadCrc);`
`@@ -1319,7 +1323,7 @@ bool ParChecker::VerifySuccessDataFile(Par2::DiskFile& diskFile, Par2::Par2Repai`
`1319`	`1323`	`return parCrc == downloadCrc;`
`1320`	`1324`	`}`
`1321`	`1325`
`1322`		`-bool ParChecker::VerifyPartialDataFile(Par2::DiskFile& diskFile, Par2::Par2RepairerSourceFile& sourceFile, SegmentList& segments, ValidBlocks& validBlocks)`
	`1326`	`+bool ParChecker::VerifyPartialDataFile(Par2::DiskFile&, Par2::Par2RepairerSourceFile& sourceFile, SegmentList& segments, ValidBlocks& validBlocks)`
`1323`	`1327`	`{`
`1324`	`1328`	`Par2::VerificationPacket* packet = sourceFile.GetVerificationPacket();`
`1325`	`1329`	`int64 blocksize = GetRepairer()->mainpacket->BlockSize();`