@@ -30,10 +30,7 @@ class XSFPlayer_2SF : public XSFPlayer

 	bool RecursiveLoad2SF(XSFFile *xSFToLoad, int level);

 	bool Load2SF(XSFFile *xSFToLoad);

 public:

-	XSFPlayer_2SF(const std::string &filename);

-#ifdef _WIN32

-	XSFPlayer_2SF(const std::wstring &filename);

-#endif

+	XSFPlayer_2SF(const std::filesystem::path &path);

 	~XSFPlayer_2SF() { this->Terminate(); }

 	bool Load();

 	void GenerateSamples(std::vector<std::uint8_t> &buf, unsigned offset, unsigned samples);

@@ -43,18 +40,11 @@ public:

 const char *XSFPlayer::WinampDescription = "2SF Decoder";

 const char *XSFPlayer::WinampExts = "2sf;mini2sf\0DS Sound Format files (*.2sf;*.mini2sf)\0";

-XSFPlayer *XSFPlayer::Create(const std::string &fn)

+XSFPlayer *XSFPlayer::Create(const std::filesystem::path &path)

 {

-	return new XSFPlayer_2SF(fn);

+	return new XSFPlayer_2SF(path);

 }

-#ifdef _WIN32

-XSFPlayer *XSFPlayer::Create(const std::wstring &fn)

-{

-	return new XSFPlayer_2SF(fn);

-}

-#endif

-

 volatile bool execute = false;

 static struct

@@ -149,11 +139,7 @@ bool XSFPlayer_2SF::RecursiveLoad2SF(XSFFile *xSFToLoad, int level)

 {

 	if (level <= 10 && xSFToLoad->GetTagExists("_lib"))

 	{

-#ifdef _WIN32

-		auto libxSF = std::make_unique<XSFFile>((std::filesystem::path(xSFToLoad->GetFilename()).parent_path() / xSFToLoad->GetTagValue("_lib")).wstring(), 4, 8);

-#else

-		auto libxSF = std::make_unique<XSFFile>((std::filesystem::path(xSFToLoad->GetFilename()).parent_path() / xSFToLoad->GetTagValue("_lib")).string(), 4, 8);

-#endif

+		auto libxSF = std::make_unique<XSFFile>(xSFToLoad->GetFilepath().parent_path() / xSFToLoad->GetTagValue("_lib"), 4, 8);

 		if (!this->RecursiveLoad2SF(libxSF.get(), level + 1))

 			return false;

 	}

@@ -170,11 +156,7 @@ bool XSFPlayer_2SF::RecursiveLoad2SF(XSFFile *xSFToLoad, int level)

 		if (xSFToLoad->GetTagExists(libTag))

 		{

 			found = true;

-#ifdef _WIN32

-			auto libxSF = std::make_unique<XSFFile>((std::filesystem::path(xSFToLoad->GetFilename()).parent_path() / xSFToLoad->GetTagValue(libTag)).wstring(), 4, 8);

-#else

-			auto libxSF = std::make_unique<XSFFile>((std::filesystem::path(xSFToLoad->GetFilename()).parent_path() / xSFToLoad->GetTagValue(libTag)).string(), 4, 8);

-#endif

+			auto libxSF = std::make_unique<XSFFile>(xSFToLoad->GetFilepath().parent_path() / xSFToLoad->GetTagValue(libTag), 4, 8);

 			if (!this->RecursiveLoad2SF(libxSF.get(), level + 1))

 				return false;

 		}

@@ -190,17 +172,10 @@ bool XSFPlayer_2SF::Load2SF(XSFFile *xSFToLoad)

 	return this->RecursiveLoad2SF(xSFToLoad, 1);

 }

-XSFPlayer_2SF::XSFPlayer_2SF(const std::string &filename) : XSFPlayer()

-{

-	this->xSF.reset(new XSFFile(filename, 4, 8));

-}

-

-#ifdef _WIN32

-XSFPlayer_2SF::XSFPlayer_2SF(const std::wstring &filename) : XSFPlayer()

+XSFPlayer_2SF::XSFPlayer_2SF(const std::filesystem::path &path) : XSFPlayer()

 {

-	this->xSF.reset(new XSFFile(filename, 4, 8));

+	this->xSF.reset(new XSFFile(path, 4, 8));

 }

-#endif

 bool XSFPlayer_2SF::Load()

 {

@@ -27,10 +27,7 @@

 class XSFPlayer_GSF : public XSFPlayer

 {

 public:

-	XSFPlayer_GSF(const std::string &filename);

-#ifdef _WIN32

-	XSFPlayer_GSF(const std::wstring &filename);

-#endif

+	XSFPlayer_GSF(const std::filesystem::path &path);

 	~XSFPlayer_GSF() { this->Terminate(); }

 	bool Load();

 	void GenerateSamples(std::vector<std::uint8_t> &buf, unsigned offset, unsigned samples);

@@ -40,18 +37,11 @@ public:

 const char *XSFPlayer::WinampDescription = "GSF Decoder";

 const char *XSFPlayer::WinampExts = "gsf;minigsf\0Game Boy Advance Sound Format files (*.gsf;*.minigsf)\0";

-XSFPlayer *XSFPlayer::Create(const std::string &fn)

+XSFPlayer *XSFPlayer::Create(const std::filesystem::path &path)

 {

-	return new XSFPlayer_GSF(fn);

+	return new XSFPlayer_GSF(path);

 }

-#ifdef _WIN32

-XSFPlayer *XSFPlayer::Create(const std::wstring &fn)

-{

-	return new XSFPlayer_GSF(fn);

-}

-#endif

-

 static struct

 {

 	std::vector<std::uint8_t> rom;

@@ -156,11 +146,7 @@ static bool RecursiveLoadGSF(XSFFile *xSF, int level)

 {

 	if (level <= 10 && xSF->GetTagExists("_lib"))

 	{

-#ifdef _WIN32

-		auto libxSF = std::make_unique<XSFFile>((std::filesystem::path(xSF->GetFilename()).parent_path() / xSF->GetTagValue("_lib")).wstring(), 8, 12);

-#else

-		auto libxSF = std::make_unique<XSFFile>((std::filesystem::path(xSF->GetFilename()).parent_path() / xSF->GetTagValue("_lib")).string(), 8, 12);

-#endif

+		auto libxSF = std::make_unique<XSFFile>(xSF->GetFilepath().parent_path() / xSF->GetTagValue("_lib"), 8, 12);

 		if (!RecursiveLoadGSF(libxSF.get(), level + 1))

 			return false;

 	}

@@ -177,11 +163,7 @@ static bool RecursiveLoadGSF(XSFFile *xSF, int level)

 		if (xSF->GetTagExists(libTag))

 		{

 			found = true;

-#ifdef _WIN32

-			auto libxSF = std::make_unique<XSFFile>((std::filesystem::path(xSF->GetFilename()).parent_path() / xSF->GetTagValue(libTag)).wstring(), 8, 12);

-#else

-			auto libxSF = std::make_unique<XSFFile>((std::filesystem::path(xSF->GetFilename()).parent_path() / xSF->GetTagValue(libTag)).string(), 8, 12);

-#endif

+			auto libxSF = std::make_unique<XSFFile>(xSF->GetFilepath().parent_path() / xSF->GetTagValue(libTag), 8, 12);

 			if (!RecursiveLoadGSF(libxSF.get(), level + 1))

 				return false;

 		}

@@ -198,17 +180,10 @@ static bool LoadGSF(XSFFile *xSF)

 	return RecursiveLoadGSF(xSF, 1);

 }

-XSFPlayer_GSF::XSFPlayer_GSF(const std::string &filename) : XSFPlayer()

-{

-	this->xSF.reset(new XSFFile(filename, 8, 12));

-}

-

-#ifdef _WIN32

-XSFPlayer_GSF::XSFPlayer_GSF(const std::wstring &filename) : XSFPlayer()

+XSFPlayer_GSF::XSFPlayer_GSF(const std::filesystem::path &path) : XSFPlayer()

 {

-	this->xSF.reset(new XSFFile(filename, 8, 12));

+	this->xSF.reset(new XSFFile(path, 8, 12));

 }

-#endif

 bool XSFPlayer_GSF::Load()

 {

new file mode 100644

Binary files /dev/null and b/src/in_ncsf/SSEQPlayer/.Channel.cpp.kate-swp differ

@@ -30,18 +30,11 @@ const char *XSFPlayer::WinampExts = "ncsf;minincsf\0DS Nitro Composer Sound Form

 extern XSFConfig *xSFConfig;

-XSFPlayer *XSFPlayer::Create(const std::string &fn)

+XSFPlayer *XSFPlayer::Create(const std::filesystem::path &path)

 {

-	return new XSFPlayer_NCSF(fn);

+	return new XSFPlayer_NCSF(path);

 }

-#ifdef _WIN32

-XSFPlayer *XSFPlayer::Create(const std::wstring &fn)

-{

-	return new XSFPlayer_NCSF(fn);

-}

-#endif

-

 void XSFPlayer_NCSF::MapNCSFSection(const std::vector<std::uint8_t> &section)

 {

 	std::uint32_t size = Get32BitsLE(&section[8]), finalSize = size;

@@ -72,11 +65,7 @@ bool XSFPlayer_NCSF::RecursiveLoadNCSF(XSFFile *xSFToLoad, int level)

 {

 	if (level <= 10 && xSFToLoad->GetTagExists("_lib"))

 	{

-#ifdef _WIN32

-		auto libxSF = std::make_unique<XSFFile>((std::filesystem::path(xSFToLoad->GetFilename()).parent_path() / xSFToLoad->GetTagValue("_lib")).wstring(), 8, 12);

-#else

-		auto libxSF = std::make_unique<XSFFile>((std::filesystem::path(xSFToLoad->GetFilename()).parent_path() / xSFToLoad->GetTagValue("_lib")).string(), 8, 12);

-#endif

+		auto libxSF = std::make_unique<XSFFile>(xSFToLoad->GetFilepath().parent_path() / xSFToLoad->GetTagValue("_lib"), 8, 12);

 		if (!this->RecursiveLoadNCSF(libxSF.get(), level + 1))

 			return false;

 	}

@@ -93,11 +82,7 @@ bool XSFPlayer_NCSF::RecursiveLoadNCSF(XSFFile *xSFToLoad, int level)

 		if (xSFToLoad->GetTagExists(libTag))

 		{

 			found = true;

-#ifdef _WIN32

-			auto libxSF = std::make_unique<XSFFile>((std::filesystem::path(xSFToLoad->GetFilename()).parent_path() / xSFToLoad->GetTagValue(libTag)).wstring(), 8, 12);

-#else

-			auto libxSF = std::make_unique<XSFFile>((std::filesystem::path(xSFToLoad->GetFilename()).parent_path() / xSFToLoad->GetTagValue(libTag)).string(), 8, 12);

-#endif

+			auto libxSF = std::make_unique<XSFFile>(xSFToLoad->GetFilepath().parent_path() / xSFToLoad->GetTagValue(libTag), 8, 12);

 			if (!this->RecursiveLoadNCSF(libxSF.get(), level + 1))

 				return false;

 		}

@@ -111,20 +96,12 @@ bool XSFPlayer_NCSF::LoadNCSF()

 	return this->RecursiveLoadNCSF(this->xSF.get(), 1);

 }

-XSFPlayer_NCSF::XSFPlayer_NCSF(const std::string &filename) : XSFPlayer(), sseq(0), sdatData(), sdat(), player(), secondsPerSample(0), secondsIntoPlayback(0), secondsUntilNextClock(0), mutes()

+XSFPlayer_NCSF::XSFPlayer_NCSF(const std::filesystem::path &path) : XSFPlayer(), sseq(0), sdatData(), sdat(), player(), secondsPerSample(0), secondsIntoPlayback(0), secondsUntilNextClock(0), mutes()

 {

 	this->uses32BitSamplesClampedTo16Bit = true;

-	this->xSF.reset(new XSFFile(filename, 8, 12));

+	this->xSF.reset(new XSFFile(path, 8, 12));

 }

-#ifdef _WIN32

-XSFPlayer_NCSF::XSFPlayer_NCSF(const std::wstring &filename) : XSFPlayer(), sseq(0), sdatData(), sdat(), player(), secondsPerSample(0), secondsIntoPlayback(0), secondsUntilNextClock(0), mutes()

-{

-	this->uses32BitSamplesClampedTo16Bit = true;

-	this->xSF.reset(new XSFFile(filename, 8, 12));

-}

-#endif

-

 #ifdef _DEBUG

 static HANDLE soundViewThreadHandle = INVALID_HANDLE_VALUE;

 static bool killSoundViewThread;

@@ -11,6 +11,7 @@

 #pragma once

 #include <bitset>

+#include <filesystem>

 #include <memory>

 #include <string>

 #include <vector>

@@ -36,10 +37,7 @@ class XSFPlayer_NCSF : public XSFPlayer

 	bool RecursiveLoadNCSF(XSFFile *xSFToLoad, int level);

 	bool LoadNCSF();

 public:

-	XSFPlayer_NCSF(const std::string &filename);

-#ifdef _WIN32

-	XSFPlayer_NCSF(const std::wstring &filename);

-#endif

+	XSFPlayer_NCSF(const std::filesystem::path &path);

 	~XSFPlayer_NCSF();

 	bool Load();

 	void GenerateSamples(std::vector<std::uint8_t> &buf, unsigned offset, unsigned samples);

@@ -37,10 +37,7 @@

 class XSFPlayer_SNSF : public XSFPlayer

 {

 public:

-	XSFPlayer_SNSF(const std::string &filename);

-#ifdef _WIN32

-	XSFPlayer_SNSF(const std::wstring &filename);

-#endif

+	XSFPlayer_SNSF(const std::filesystem::path &path);

 	~XSFPlayer_SNSF() { this->Terminate(); }

 	bool Load();

 	void GenerateSamples(std::vector<std::uint8_t> &buf, unsigned offset, unsigned samples);

@@ -52,18 +49,11 @@ const char *XSFPlayer::WinampExts = "snsf;minisnsf\0SNES Sound Format files (*.s

 extern XSFConfig *xSFConfig;

-XSFPlayer *XSFPlayer::Create(const std::string &fn)

+XSFPlayer *XSFPlayer::Create(const std::filesystem::path &path)

 {

-	return new XSFPlayer_SNSF(fn);

+	return new XSFPlayer_SNSF(path);

 }

-#ifdef _WIN32

-XSFPlayer *XSFPlayer::Create(const std::wstring &fn)

-{

-	return new XSFPlayer_SNSF(fn);

-}

-#endif

-

 static struct

 {

 	std::vector<std::uint8_t> rom, sram;

@@ -172,11 +162,7 @@ static bool RecursiveLoadSNSF(XSFFile *xSF, int level)

 {

 	if (level <= 10 && xSF->GetTagExists("_lib"))

 	{

-#ifdef _WIN32

-		auto libxSF = std::make_unique<XSFFile>((std::filesystem::path(xSF->GetFilename()).parent_path() / xSF->GetTagValue("_lib")).wstring(), 4, 8);

-#else

-		auto libxSF = std::make_unique<XSFFile>((std::filesystem::path(xSF->GetFilename()).parent_path() / xSF->GetTagValue("_lib")).string(), 4, 8);

-#endif

+		auto libxSF = std::make_unique<XSFFile>(xSF->GetFilepath().parent_path() / xSF->GetTagValue("_lib"), 4, 8);

 		if (!RecursiveLoadSNSF(libxSF.get(), level + 1))

 			return false;

 	}

@@ -193,11 +179,7 @@ static bool RecursiveLoadSNSF(XSFFile *xSF, int level)

 		if (xSF->GetTagExists(libTag))

 		{

 			found = true;

-#ifdef _WIN32

-			auto libxSF = std::make_unique<XSFFile>((std::filesystem::path(xSF->GetFilename()).parent_path() / xSF->GetTagValue(libTag)).wstring(), 4, 8);

-#else

-			auto libxSF = std::make_unique<XSFFile>((std::filesystem::path(xSF->GetFilename()).parent_path() / xSF->GetTagValue(libTag)).string(), 4, 8);

-#endif

+			auto libxSF = std::make_unique<XSFFile>(xSF->GetFilepath().parent_path() / xSF->GetTagValue(libTag), 4, 8);

 			if (!RecursiveLoadSNSF(libxSF.get(), level + 1))

 				return false;

 		}

@@ -216,17 +198,10 @@ static bool LoadSNSF(XSFFile *xSF)

 	return RecursiveLoadSNSF(xSF, 1);

 }

-XSFPlayer_SNSF::XSFPlayer_SNSF(const std::string &filename) : XSFPlayer()

-{

-	this->xSF.reset(new XSFFile(filename, 4, 8));

-}

-

-#ifdef _WIN32

-XSFPlayer_SNSF::XSFPlayer_SNSF(const std::wstring &filename) : XSFPlayer()

+XSFPlayer_SNSF::XSFPlayer_SNSF(const std::filesystem::path &path) : XSFPlayer()

 {

-	this->xSF.reset(new XSFFile(filename, 4, 8));

+	this->xSF.reset(new XSFFile(path, 4, 8));

 }

-#endif

 bool XSFPlayer_SNSF::Load()

 {

@@ -287,7 +287,7 @@ INT_PTR CALLBACK XSFConfig::InfoDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wPara

 			EndDialog(hwndDlg, IDCANCEL);

 			break;

 		case WM_INITDIALOG:

-			SetWindowTextW(hwndDlg, ConvertFuncs::StringToWString(xSFFileInInfo->GetFilename()).c_str());

+			SetWindowTextW(hwndDlg, xSFFileInInfo->GetFilepath().wstring().c_str());

 			SetWindowTextW(GetDlgItem(hwndDlg, idInfoTitle), ConvertFuncs::StringToWString(xSFFileInInfo->GetTagValue("title")).c_str());

 			SetWindowTextW(GetDlgItem(hwndDlg, idInfoArtist), ConvertFuncs::StringToWString(xSFFileInInfo->GetTagValue("artist")).c_str());

 			SetWindowTextW(GetDlgItem(hwndDlg, idInfoGame), ConvertFuncs::StringToWString(xSFFileInInfo->GetTagValue("game")).c_str());

@@ -17,9 +17,6 @@

 #include "XSFCommon.h"

 #include "XSFFile.h"

 #include "convert.h"

-#if defined(_WIN32) && !defined(_MSC_VER)

-# include "fstream_wfopen.h"

-#endif

 #include "zlib.h"

 static inline void Set32BitsLE(std::uint32_t input, std::uint8_t *output)

@@ -61,65 +58,33 @@ static inline std::string TrimWhitespace(const std::string &orig)

 	return LeftTrimWhitespace(RightTrimWhitespace(orig));

 }

-XSFFile::XSFFile() : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), fileName("")

+XSFFile::XSFFile() : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), filePath()

 {

 }

-XSFFile::XSFFile(const std::string &filename) : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), fileName(filename)

+XSFFile::XSFFile(const std::filesystem::path &path) : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), filePath(path)

 {

-	this->ReadXSF(filename, 0, 0, true);

+	this->ReadXSF(path, 0, 0, true);

 }

-XSFFile::XSFFile(const std::string &filename, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize) : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), fileName(filename)

+XSFFile::XSFFile(const std::filesystem::path &path, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize) : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), filePath(path)

 {

-	this->ReadXSF(filename, programSizeOffset, programHeaderSize);

+	this->ReadXSF(path, programSizeOffset, programHeaderSize);

 }

-#ifdef _WIN32

-XSFFile::XSFFile(const std::wstring &filename) : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), fileName(ConvertFuncs::WStringToString(filename))

+void XSFFile::ReadXSF(const std::filesystem::path &path, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize, bool readTagsOnly)

 {

-	this->ReadXSF(filename, 0, 0, true);

-}

-

-XSFFile::XSFFile(const std::wstring &filename, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize) : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), fileName(ConvertFuncs::WStringToString(filename))

-{

-	this->ReadXSF(filename, programSizeOffset, programHeaderSize);

-}

-#endif

-

-void XSFFile::ReadXSF(const std::string &filename, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize, bool readTagsOnly)

-{

-	if (!std::filesystem::is_regular_file(filename))

-		throw std::logic_error("File " + filename + " does not exist.");

-

-	std::ifstream xSF;

-	xSF.exceptions(std::ifstream::failbit | std::ifstream::badbit);

-	xSF.open(filename.c_str(), std::ifstream::in | std::ifstream::binary);

-

-	this->ReadXSF(xSF, programSizeOffset, programHeaderSize, readTagsOnly);

-

-	xSF.close();

-}

-

-#ifdef _WIN32

-void XSFFile::ReadXSF(const std::wstring &filename, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize, bool readTagsOnly)

-{

-	if (!std::filesystem::is_regular_file(filename))

-		throw std::logic_error("File " + ConvertFuncs::WStringToString(filename) + " does not exist.");

+	if (!std::filesystem::is_regular_file(path))

+		throw std::logic_error("File " + path.string() + " does not exist.");

-#if defined(_WIN32) && !defined(_MSC_VER)

-	ifstream_wfopen xSF;

-#else

 	std::ifstream xSF;

-#endif

 	xSF.exceptions(std::ifstream::failbit | std::ifstream::badbit);

-	xSF.open(filename.c_str(), std::ifstream::in | std::ifstream::binary);

+	xSF.open(path, std::ifstream::in | std::ifstream::binary);

 	this->ReadXSF(xSF, programSizeOffset, programHeaderSize, readTagsOnly);

 	xSF.close();

 }

-#endif

 void XSFFile::ReadXSF(std::ifstream &xSF, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize, bool readTagsOnly)

 {

@@ -462,29 +427,21 @@ std::string XSFFile::GetFormattedTitle(const std::string &format) const

 	return formattedTitle;

 }

-std::string XSFFile::GetFilename() const

+std::filesystem::path XSFFile::GetFilepath() const

 {

-	return this->fileName;

+	return this->filePath;

 }

-std::string XSFFile::GetFilenameWithoutPath() const

+std::filesystem::path XSFFile::GetFilenameWithoutPath() const

 {

-	return std::filesystem::path(this->fileName).filename().string();

+	return this->filePath.filename();

 }

 void XSFFile::SaveFile() const

 {

-#if defined(_WIN32) && !defined(_MSC_VER)

-	ofstream_wfopen xSF;

-#else

 	std::ofstream xSF;

-#endif

 	xSF.exceptions(std::ofstream::failbit);

-#ifdef _WIN32

-	xSF.open(ConvertFuncs::StringToWString(this->fileName).c_str(), std::ofstream::out | std::ofstream::binary);

-#else

-	xSF.open(this->fileName.c_str(), std::ofstream::out | std::ofstream::binary);

-#endif

+	xSF.open(this->filePath, std::ofstream::out | std::ofstream::binary);

 	xSF.write(reinterpret_cast<const char *>(&this->rawData[0]), this->rawData.size());

@@ -7,6 +7,7 @@

 #pragma once

+#include <filesystem>

 #include <fstream>

 #include <string>

 #include <vector>

@@ -31,26 +32,20 @@ enum class PeakType

 class XSFFile

 {

+private:

+	void ReadXSF(const std::filesystem::path &path, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize, bool readTagsOnly = false);

+	void ReadXSF(std::ifstream &xSF, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize, bool readTagsOnly = false);

 protected:

 	std::uint8_t xSFType;

 	bool hasFile;

 	std::vector<std::uint8_t> rawData, reservedSection, programSection;

 	TagList tags;

-	std::string fileName;

-	void ReadXSF(const std::string &filename, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize, bool readTagsOnly = false);

-#ifdef _WIN32

-	void ReadXSF(const std::wstring &filename, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize, bool readTagsOnly = false);

-#endif

-	void ReadXSF(std::ifstream &xSF, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize, bool readTagsOnly = false);

+	std::filesystem::path filePath; readTagsOnly = false);

 	std::string FormattedTitleOptionalBlock(const std::string &block, bool &hadReplacement, unsigned level) const;

 public:

 	XSFFile();

-	XSFFile(const std::string &filename);

-	XSFFile(const std::string &filename, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize);

-#ifdef _WIN32

-	XSFFile(const std::wstring &filename);

-	XSFFile(const std::wstring &filename, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize);

-#endif

+	XSFFile(const std::filesystem::path &path);

+	XSFFile(const std::filesystem::path &path, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize);

 	bool IsValidType(std::uint8_t type) const;

 	void Clear();

 	bool HasFile() const;

@@ -72,7 +67,7 @@ public:

 	unsigned long GetFadeMS(unsigned long defaultFade) const;

 	double GetVolume(VolumeType preferredVolumeType, PeakType preferredPeakType) const;

 	std::string GetFormattedTitle(const std::string &format) const;

-	std::string GetFilename() const;

-	std::string GetFilenameWithoutPath() const;

+	std::filesystem::path GetFilepath() const;

+	std::filesystem::path GetFilenameWithoutPath() const;

 	void SaveFile() const;

 };

@@ -7,6 +7,7 @@

 #pragma once

+#include <filesystem>

 #include <memory>

 #include <string>

 #include <vector>

@@ -37,10 +38,7 @@ public:

 	// These are not defined in XSFPlayer.cpp, they should be defined in your own player's source. The Create functions should return a pointer to your player's class.

 	static const char *WinampDescription;

 	static const char *WinampExts;

-	static XSFPlayer *Create(const std::string &fn);

-#ifdef _WIN32

-	static XSFPlayer *Create(const std::wstring &fn);

-#endif

+	static XSFPlayer *Create(const std::filesystem::path &path);

 	virtual ~XSFPlayer() { }

 	XSFPlayer &operator=(const XSFPlayer &xSFPlayer);

deleted file mode 100644

@@ -1,763 +0,0 @@

-// This comes from llvm's libcxx project. I've copied the code from there (with heavy modifications) for use with MinGW to support opening Windows "Unicode" filenames.

-

-#if defined(_WIN32) && !defined(_MSC_VER)

-#pragma once

-

-#include <streambuf>

-#include <locale>

-#include <memory>

-#include <fstream>

-

-class filebuf_wfopen : public std::filebuf

-{

-public:

-	typedef typename traits_type::state_type state_type;

-

-	// 27.9.1.2 Constructors/destructor:

-	filebuf_wfopen() : __extbuf_(nullptr), __extbufnext_(nullptr), __extbufend_(nullptr), __ebs_(0),

-		__intbuf_(nullptr), __ibs_(0), __file_(nullptr), __cv_(nullptr), __st_(), __st_last_(),

-		__om_(static_cast<std::ios_base::openmode>(0)), __cm_(static_cast<std::ios_base::openmode>(0)),

-		__owns_eb_(false), __owns_ib_(false), __always_noconv_(false)

-	{

-		if (std::has_facet<std::codecvt<char, char, state_type>>(this->getloc()))

-		{

-			this->__cv_ = &std::use_facet<std::codecvt<char, char, state_type>>(this->getloc());

-			this->__always_noconv_ = this->__cv_->always_noconv();

-		}

-		this->setbuf(nullptr, 4096);

-	}

-

-	virtual ~filebuf_wfopen()

-	{

-		try

-		{

-			this->close();

-		}

-		catch (...)

-		{

-		}

-		if (this->__owns_eb_)

-			delete[] this->__extbuf_;

-		if (this->__owns_ib_)

-			delete[] this->__intbuf_;

-	}

-

-	// 27.9.1.4 Members:

-	bool is_open() const

-	{

-		return !!this->__file_;

-	}

-	filebuf_wfopen *open(const char *__s, std::ios_base::openmode __mode)

-	{

-		filebuf_wfopen *__rt = nullptr;

-		if (!this->__file_)

-		{

-			__rt = this;

-			const char *__mdstr = nullptr;

-			switch (__mode & ~std::ios_base::ate)

-			{

-				case std::ios_base::out:

-				case std::ios_base::out | std::ios_base::trunc:

-					__mdstr = "w";

-					break;

-				case std::ios_base::out | std::ios_base::app:

-				case std::ios_base::app:

-					__mdstr = "a";

-					break;

-				case std::ios_base::in:

-					__mdstr = "r";

-					break;

-				case std::ios_base::in | std::ios_base::out:

-					__mdstr = "r+";

-					break;

-				case std::ios_base::in | std::ios_base::out | std::ios_base::trunc:

-					__mdstr = "w+";

-					break;

-				case std::ios_base::in | std::ios_base::out | std::ios_base::app:

-				case std::ios_base::in | std::ios_base::app:

-					__mdstr = "a+";

-					break;

-				case std::ios_base::out | std::ios_base::binary:

-				case std::ios_base::out | std::ios_base::trunc | std::ios_base::binary:

-					__mdstr = "wb";

-					break;

-				case std::ios_base::out | std::ios_base::app | std::ios_base::binary:

-				case std::ios_base::app | std::ios_base::binary:

-					__mdstr = "ab";

-					break;

-				case std::ios_base::in | std::ios_base::binary:

-					__mdstr = "rb";

-					break;

-				case std::ios_base::in | std::ios_base::out | std::ios_base::binary:

-					__mdstr = "r+b";

-					break;

-				case std::ios_base::in | std::ios_base::out | std::ios_base::trunc | std::ios_base::binary:

-					__mdstr = "w+b";

-					break;

-				case std::ios_base::in | std::ios_base::out | std::ios_base::app | std::ios_base::binary:

-				case std::ios_base::in | std::ios_base::app | std::ios_base::binary:

-					__mdstr = "a+b";

-					break;

-				default:

-					__rt = nullptr;

-			}

-			if (__rt)

-			{

-				this->__file_ = fopen(__s, __mdstr);

-				if (this->__file_)

-				{

-					this->__om_ = __mode;

-					if ((__mode & std::ios_base::ate) && fseek(this->__file_, 0, SEEK_END))

-					{

-						fclose(this->__file_);

-						this->__file_ = nullptr;

-						__rt = nullptr;

-					}

-				}

-				else

-					__rt = nullptr;

-			}

-		}

-		return __rt;

-	}

-	filebuf_wfopen *open(const std::string &__s, std::ios_base::openmode __mode)

-	{

-		return this->open(__s.c_str(), __mode);

-	}

-	filebuf_wfopen *open(const wchar_t *__s, std::ios_base::openmode __mode)

-	{

-		filebuf_wfopen *__rt = nullptr;

-		if (!this->__file_)

-		{

-			__rt = this;

-			const wchar_t *__mdstr = nullptr;

-			switch (__mode & ~std::ios_base::ate)

-			{

-				case std::ios_base::out:

-				case std::ios_base::out | std::ios_base::trunc:

-					__mdstr = L"w";

-					break;

-				case std::ios_base::out | std::ios_base::app:

-				case std::ios_base::app:

-					__mdstr = L"a";

-					break;

-				case std::ios_base::in:

-					__mdstr = L"r";

-					break;

-				case std::ios_base::in | std::ios_base::out:

-					__mdstr = L"r+";

-					break;

-				case std::ios_base::in | std::ios_base::out | std::ios_base::trunc:

-					__mdstr = L"w+";

-					break;

-				case std::ios_base::in | std::ios_base::out | std::ios_base::app:

-				case std::ios_base::in | std::ios_base::app:

-					__mdstr = L"a+";

-					break;

-				case std::ios_base::out | std::ios_base::binary:

-				case std::ios_base::out | std::ios_base::trunc | std::ios_base::binary:

-					__mdstr = L"wb";

-					break;

-				case std::ios_base::out | std::ios_base::app | std::ios_base::binary:

-				case std::ios_base::app | std::ios_base::binary:

-					__mdstr = L"ab";

-					break;

-				case std::ios_base::in | std::ios_base::binary:

-					__mdstr = L"rb";

-					break;

-				case std::ios_base::in | std::ios_base::out | std::ios_base::binary:

-					__mdstr = L"r+b";

-					break;

-				case std::ios_base::in | std::ios_base::out | std::ios_base::trunc | std::ios_base::binary:

-					__mdstr = L"w+b";

-					break;

-				case std::ios_base::in | std::ios_base::out | std::ios_base::app | std::ios_base::binary:

-				case std::ios_base::in | std::ios_base::app | std::ios_base::binary:

-					__mdstr = L"a+b";

-					break;

-				default:

-					__rt = nullptr;

-			}

-			if (__rt)

-			{

-				this->__file_ = _wfopen(__s, __mdstr);

-				if (this->__file_)

-				{

-					this->__om_ = __mode;

-					if ((__mode & std::ios_base::ate) && fseek(this->__file_, 0, SEEK_END))

-					{

-						fclose(this->__file_);

-						this->__file_ = nullptr;

-						__rt = nullptr;

-					}

-				}

-				else

-					__rt = nullptr;

-			}

-		}

-		return __rt;

-	}

-	filebuf_wfopen *open(const std::wstring &__s, std::ios_base::openmode __mode)

-	{

-		return this->open(__s.c_str(), __mode);

-	}

-	filebuf_wfopen *close()

-	{

-		filebuf_wfopen *__rt = nullptr;

-		if (this->__file_)

-		{

-			__rt = this;

-			std::unique_ptr<FILE, int (*)(FILE *)> __h(this->__file_, fclose);

-			if (this->sync())

-				__rt = nullptr;

-			if (!fclose(__h.release()))

-				this->__file_ = nullptr;

-			else

-				__rt = nullptr;

-		}

-		return __rt;

-	}

-

-protected:

-	// 27.9.1.5 Overridden virtual functions:

-	virtual int_type underflow()

-	{

-		if (!this->__file_)

-			return traits_type::eof();

-		bool __initial = this->__read_mode();

-		char __1buf;

-		if (!this->gptr())

-			this->setg(&__1buf, &__1buf + 1, &__1buf + 1);

-		const size_t __unget_sz = __initial ? 0 : std::min<size_t>((this->egptr() - this->eback()) / 2, 4);

-		int_type __c = traits_type::eof();

-		if (this->gptr() == this->egptr())

-		{

-			memmove(this->eback(), this->egptr() - __unget_sz, __unget_sz);

-			if (this->__always_noconv_)

-			{

-				size_t __nmemb = static_cast<size_t>(this->egptr() - this->eback() - __unget_sz);

-				__nmemb = fread(this->eback() + __unget_sz, 1, __nmemb, this->__file_);

-				if (__nmemb)

-				{

-					this->setg(this->eback(), this->eback() + __unget_sz, this->eback() + __unget_sz + __nmemb);

-					__c = traits_type::to_int_type(*this->gptr());

-				}

-			}

-			else

-			{

-				memmove(this->__extbuf_, this->__extbufnext_, this->__extbufend_ - this->__extbufnext_);

-				this->__extbufnext_ = this->__extbuf_ + (this->__extbufend_ - this->__extbufnext_);

-				this->__extbufend_ = this->__extbuf_ +

-					(this->__extbuf_ == this->__extbuf_min_ ? sizeof(this->__extbuf_min_) : this->__ebs_);

-				size_t __nmemb = std::min<size_t>(this->__ibs_ - __unget_sz,

-					this->__extbufend_ - this->__extbufnext_);

-				std::codecvt_base::result __r;

-				this->__st_last_ = this->__st_;

-				size_t __nr = fread(const_cast<char *>(this->__extbufnext_), 1, __nmemb, this->__file_);

-				if (__nr)

-				{

-					if (!this->__cv_)

-						throw std::bad_cast();

-					this->__extbufend_ = this->__extbufnext_ + __nr;

-					char *__inext;

-					__r = this->__cv_->in(this->__st_, this->__extbuf_, this->__extbufend_, this->__extbufnext_,

-						this->eback() + __unget_sz, this->eback() + this->__ibs_, __inext);

-					if (__r == std::codecvt_base::noconv)

-					{

-						this->setg(this->__extbuf_, this->__extbuf_, const_cast<char *>(this->__extbufend_));

-						__c = traits_type::to_int_type(*this->gptr());

-					}

-					else if (__inext != this->eback() + __unget_sz)

-					{

-						this->setg(this->eback(), this->eback() + __unget_sz, __inext);

-						__c = traits_type::to_int_type(*this->gptr());

-					}

-				}

-			}

-		}

-		else

-			__c = traits_type::to_int_type(*this->gptr());

-		if (this->eback() == &__1buf)

-			this->setg(nullptr, nullptr, nullptr);

-		return __c;

-	}

-	virtual int_type pbackfail(int_type __c = traits_type::eof())

-	{

-		if (this->__file_ && this->eback() < this->gptr())

-		{

-			if (traits_type::eq_int_type(__c, traits_type::eof()))

-			{

-				this->gbump(-1);

-				return traits_type::not_eof(__c);

-			}

-			if ((this->__om_ & std::ios_base::out) ||

-				traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1]))

-			{

-				this->gbump(-1);

-				*this->gptr() = traits_type::to_char_type(__c);

-				return __c;

-			}

-		}

-		return traits_type::eof();

-	}

-	virtual int_type overflow (int_type __c = traits_type::eof())

-	{

-		if (!this->__file_)

-			return traits_type::eof();

-		this->__write_mode();

-		char __1buf;

-		char *__pb_save = this->pbase();

-		char *__epb_save = this->epptr();

-		if (!traits_type::eq_int_type(__c, traits_type::eof()))

-		{

-			if (!this->pptr())

-				this->setp(&__1buf, &__1buf + 1);

-			*this->pptr() = traits_type::to_char_type(__c);

-			this->pbump(1);

-		}

-		if (this->pptr() != this->pbase())

-		{

-			if (this->__always_noconv_)

-			{

-				size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase());

-				if (fwrite(this->pbase(), 1, __nmemb, __file_) != __nmemb)

-					return traits_type::eof();

-			}

-			else

-			{

-				char *__extbe = this->__extbuf_;

-				std::codecvt_base::result __r;

-				do

-				{

-					if (!this->__cv_)

-						throw std::bad_cast();

-					const char *__e;

-					__r = this->__cv_->out(this->__st_, this->pbase(), this->pptr(), __e, this->__extbuf_,

-						this->__extbuf_ + this->__ebs_, __extbe);

-					if (__e == this->pbase())

-						return traits_type::eof();

-					if (__r == std::codecvt_base::noconv)

-					{

-						size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase());

-						if (fwrite(this->pbase(), 1, __nmemb, this->__file_) != __nmemb)

-							return traits_type::eof();