├── .gitignore ├── common ├── common.props ├── SSEQ.h ├── NDSStdHeader.h ├── SWAV.h ├── FATSection.h ├── SWAR.h ├── windowsh_wrapper.h ├── TagList.h ├── SYMBSection.h ├── NCSF.h ├── SSEQ.cpp ├── INFOSection.h ├── eqstr.h ├── ltstr.h ├── NDSStdHeader.cpp ├── SBNK.h ├── FATSection.cpp ├── SDAT.h ├── TagList.cpp ├── TimerPlayer.h ├── INFOEntry.h ├── TimerTrack.h ├── SWAR.cpp ├── SWAV.cpp ├── common.vcxproj.filters ├── INFOSection.cpp ├── SYMBSection.cpp ├── TimerChannel.h ├── common.vcxproj ├── INFOEntry.cpp ├── SBNK.cpp ├── TimerPlayer.cpp ├── NCSF.cpp ├── common.h └── win_dirent.h ├── NDStoNCSF ├── NDStoNCSF.vcxproj.filters └── NDStoNCSF.vcxproj ├── SDATStrip ├── SDATStrip.vcxproj.filters ├── SDATStrip.vcxproj └── SDATStrip.cpp ├── SDATtoNCSF ├── SDATtoNCSF.vcxproj.filters ├── SDATtoNCSF.vcxproj └── SDATtoNCSF.cpp ├── 2SFTagsToNCSF ├── 2SFTagsToNCSF.vcxproj.filters ├── 2SFTagsToNCSF.vcxproj └── 2SFTagsToNCSF.cpp ├── 2SFtoNCSF ├── 2SFtoNCSF.vcxproj.filters ├── 2SFtoNCSF.vcxproj └── 2SFtoNCSF.cpp ├── SDATStuff.sln ├── GNUmakefile └── README.txt /.gitignore: -------------------------------------------------------------------------------- 1 | Debug 2 | Release 3 | *.suo 4 | *.user -------------------------------------------------------------------------------- /common/common.props: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | ZLIBFIXME 6 | 7 | 8 | 9 | 10 | 11 | $(zlibRootDir) 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /common/SSEQ.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - SSEQ (Sequence) structure 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-12-08 5 | * 6 | * Nintendo DS Nitro Composer (SDAT) Specification document found at 7 | * http://www.feshrine.net/hacking/doc/nds-sdat.html 8 | */ 9 | 10 | #pragma once 11 | 12 | #include "INFOEntry.h" 13 | #include "common.h" 14 | 15 | struct SSEQ 16 | { 17 | std::string filename, origFilename; 18 | std::vector data; 19 | 20 | int32_t entryNumber; 21 | 22 | SSEQ(const std::string &fn = "", const std::string &origFn = ""); 23 | 24 | void Read(PseudoReadFile &file); 25 | }; 26 | -------------------------------------------------------------------------------- /common/NDSStdHeader.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - Nintendo DS Standard Header structure 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-10-15 5 | * 6 | * Nintendo DS Nitro Composer (SDAT) Specification document found at 7 | * http://www.feshrine.net/hacking/doc/nds-sdat.html 8 | */ 9 | 10 | #pragma once 11 | 12 | #include "common.h" 13 | 14 | struct NDSStdHeader 15 | { 16 | int8_t type[4]; 17 | uint32_t magic; 18 | uint32_t fileSize; 19 | uint16_t size; 20 | uint16_t blocks; 21 | 22 | NDSStdHeader(); 23 | 24 | void Read(PseudoReadFile &file); 25 | void Verify(const std::string &typeToCheck, uint32_t magicToCheck) const; 26 | void Write(PseudoWrite &file) const; 27 | }; 28 | -------------------------------------------------------------------------------- /NDStoNCSF/NDStoNCSF.vcxproj.filters: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hpp;hxx;hm;inl;inc;xsd 11 | 12 | 13 | 14 | 15 | Source Files 16 | 17 | 18 | -------------------------------------------------------------------------------- /SDATStrip/SDATStrip.vcxproj.filters: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hpp;hxx;hm;inl;inc;xsd 11 | 12 | 13 | 14 | 15 | Source Files 16 | 17 | 18 | -------------------------------------------------------------------------------- /SDATtoNCSF/SDATtoNCSF.vcxproj.filters: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hpp;hxx;hm;inl;inc;xsd 11 | 12 | 13 | 14 | 15 | Source Files 16 | 17 | 18 | -------------------------------------------------------------------------------- /2SFTagsToNCSF/2SFTagsToNCSF.vcxproj.filters: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hpp;hxx;hm;inl;inc;xsd 11 | 12 | 13 | 14 | 15 | Source Files 16 | 17 | 18 | -------------------------------------------------------------------------------- /common/SWAV.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - SWAV (Waveform/Sample) structure 3 | * By Naram Qashat (CyberBotX) 4 | * Last modification on 2014-12-08 5 | * 6 | * Nintendo DS Nitro Composer (SDAT) Specification document found at 7 | * http://www.feshrine.net/hacking/doc/nds-sdat.html 8 | */ 9 | 10 | #pragma once 11 | 12 | #include "common.h" 13 | 14 | struct SWAV 15 | { 16 | uint8_t waveType; 17 | uint8_t loop; 18 | uint16_t sampleRate; 19 | uint16_t time; 20 | uint16_t origLoopOffset; 21 | uint32_t loopOffset; 22 | uint32_t origNonLoopLength; 23 | uint32_t nonLoopLength; 24 | std::vector origData; 25 | std::vector data; 26 | 27 | SWAV(); 28 | 29 | void Read(PseudoReadFile &file); 30 | void DecodeADPCM(uint32_t len); 31 | uint32_t Size() const; 32 | void Write(PseudoWrite &file) const; 33 | }; 34 | -------------------------------------------------------------------------------- /common/FATSection.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - FAT (File Allocation Table) Section structures 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-10-15 5 | * 6 | * Nintendo DS Nitro Composer (SDAT) Specification document found at 7 | * http://www.feshrine.net/hacking/doc/nds-sdat.html 8 | */ 9 | 10 | #pragma once 11 | 12 | #include "common.h" 13 | 14 | struct FATRecord 15 | { 16 | uint32_t offset; 17 | uint32_t size; 18 | 19 | FATRecord(); 20 | 21 | void Read(PseudoReadFile &file); 22 | void Write(PseudoWrite &file) const; 23 | }; 24 | 25 | struct FATSection 26 | { 27 | int8_t type[4]; 28 | uint32_t size; 29 | uint32_t count; 30 | std::vector records; 31 | 32 | FATSection(); 33 | 34 | void Read(PseudoReadFile &file); 35 | uint32_t Size() const; 36 | void Write(PseudoWrite &file) const; 37 | }; 38 | -------------------------------------------------------------------------------- /common/SWAR.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - SWAR (Wave Archive) structures 3 | * By Naram Qashat (CyberBotX) 4 | * Last modification on 2014-12-08 5 | * 6 | * Nintendo DS Nitro Composer (SDAT) Specification document found at 7 | * http://www.feshrine.net/hacking/doc/nds-sdat.html 8 | */ 9 | 10 | #pragma once 11 | 12 | #include 13 | #include "NDSStdHeader.h" 14 | #include "SWAV.h" 15 | #include "INFOEntry.h" 16 | #include "common.h" 17 | 18 | struct SWAR 19 | { 20 | typedef std::map> SWAVs; 21 | 22 | std::string filename; 23 | NDSStdHeader header; 24 | SWAVs swavs; 25 | 26 | int32_t entryNumber; 27 | 28 | SWAR(const std::string &fn = ""); 29 | SWAR(const SWAR &swar); 30 | SWAR &operator=(const SWAR &swar); 31 | 32 | void Read(PseudoReadFile &file); 33 | uint32_t Size() const; 34 | void Write(PseudoWrite &file) const; 35 | }; 36 | -------------------------------------------------------------------------------- /common/windowsh_wrapper.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Wrapper for windows.h, found at: 3 | * http://learnwinapi.wordpress.com/2011/12/13/lesson-2-the-api-is-based-on-unicode/ 4 | */ 5 | 6 | #pragma once 7 | 8 | #ifdef _MBCS 9 | # error "_MBCS (multi-byte character set) is defined, but only Unicode is supported" 10 | #endif 11 | #undef _UNICODE 12 | #define _UNICODE // For [tchar.h] 13 | #undef UNICODE 14 | #define UNICODE // For [windows.h] 15 | 16 | #undef NOMINMAX 17 | #define NOMINMAX // C++ standard library compatibility 18 | #undef STRICT 19 | #define STRICT // C++ type-checking compatibility 20 | 21 | #ifndef _WIN32_WINNT 22 | # define _WIN32_WINNT _WIN32_WINNT_WIN2K 23 | #endif 24 | #ifdef _MSC_VER // Visual C++ only (the SDK is Visual C++ specific). 25 | # include // E.g. g++ 4.4.1 does not support this file/scheme. 26 | #endif 27 | 28 | #undef WIN32_LEAN_AND_MEAN 29 | #define WIN32_LEAN_AND_MEAN 30 | #include 31 | -------------------------------------------------------------------------------- /2SFtoNCSF/2SFtoNCSF.vcxproj.filters: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hpp;hxx;hm;inl;inc;xsd 11 | 12 | 13 | {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} 14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms 15 | 16 | 17 | 18 | 19 | Source Files 20 | 21 | 22 | -------------------------------------------------------------------------------- /common/TagList.h: -------------------------------------------------------------------------------- 1 | /* 2 | * xSF Tag List 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-10-15 5 | * 6 | * Storage of tags from PSF-style files, specifications found at 7 | * http://wiki.neillcorlett.com/PSFTagFormat 8 | */ 9 | 10 | #pragma once 11 | 12 | #include 13 | #include 14 | #include "eqstr.h" 15 | #include "ltstr.h" 16 | 17 | class TagList 18 | { 19 | public: 20 | typedef std::map Tags; 21 | typedef std::vector TagsList; 22 | private: 23 | static eq_str eqstr; 24 | 25 | Tags tags; 26 | TagsList tagsOrder; 27 | public: 28 | TagList() : tags(), tagsOrder() { } 29 | const TagsList &GetKeys() const; 30 | TagsList GetTags() const; 31 | bool Empty() const; 32 | bool Exists(const std::string &name) const; 33 | std::string operator[](const std::string &name) const; 34 | std::string &operator[](const std::string &name); 35 | void CopyOverwriteExistingOnly(const TagList ©); 36 | void Remove(const std::string &name); 37 | void Clear(); 38 | }; 39 | -------------------------------------------------------------------------------- /common/SYMBSection.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - SYMB (Symbol/Filename) Section structures 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-10-25 5 | * 6 | * Nintendo DS Nitro Composer (SDAT) Specification document found at 7 | * http://www.feshrine.net/hacking/doc/nds-sdat.html 8 | */ 9 | 10 | #pragma once 11 | 12 | #include "common.h" 13 | 14 | struct SYMBRecord 15 | { 16 | uint32_t count; 17 | std::vector entryOffsets; 18 | std::vector entries; 19 | 20 | SYMBRecord(); 21 | 22 | void Read(PseudoReadFile &file, uint32_t startOffset); 23 | uint32_t Size() const; 24 | void FixOffsets(uint32_t startOffset); 25 | void WriteHeader(PseudoWrite &file) const; 26 | void WriteData(PseudoWrite &file) const; 27 | }; 28 | 29 | struct SYMBSection 30 | { 31 | int8_t type[4]; 32 | uint32_t size; 33 | uint32_t recordOffsets[8]; 34 | SYMBRecord SEQrecord; 35 | SYMBRecord BANKrecord; 36 | SYMBRecord WAVEARCrecord; 37 | SYMBRecord PLAYERrecord; 38 | 39 | SYMBSection(); 40 | 41 | void Read(PseudoReadFile &file); 42 | uint32_t Size() const; 43 | void FixOffsets(); 44 | void Write(PseudoWrite &file) const; 45 | }; 46 | -------------------------------------------------------------------------------- /common/NCSF.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Common NCSF functions 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-10-15 5 | */ 6 | 7 | #pragma once 8 | 9 | #include 10 | #include 11 | #include "TagList.h" 12 | #include "SDAT.h" 13 | #include "common.h" 14 | 15 | typedef std::vector Files; 16 | 17 | void MakeNCSF(const std::string &filename, const std::vector &reservedSectionData, const std::vector &programSectionData, 18 | const std::vector &tags = std::vector()); 19 | void CheckForValidPSF(PseudoReadFile &file, uint8_t versionByte); 20 | std::vector GetProgramSectionFromPSF(PseudoReadFile &file, uint8_t versionByte, uint32_t programHeaderSize, uint32_t programSizeOffset, bool addHeaderSize = false); 21 | TagList GetTagsFromPSF(PseudoReadFile &file, uint8_t versionByte); 22 | Files GetFilesInDirectory(const std::string &path, const std::vector &extensions = std::vector()); 23 | void RemoveFiles(const Files &files); 24 | void GetTime(const std::string &filename, const SDAT *sdat, const SSEQ *sseq, TagList &tags, bool verbose, uint32_t numberOfLoops, uint32_t fadeLoop, uint32_t fadeOneShot); 25 | -------------------------------------------------------------------------------- /common/SSEQ.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - SSEQ (Sequence) structure 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-12-08 5 | * 6 | * Nintendo DS Nitro Composer (SDAT) Specification document found at 7 | * http://www.feshrine.net/hacking/doc/nds-sdat.html 8 | */ 9 | 10 | #include "SSEQ.h" 11 | #include "NDSStdHeader.h" 12 | #include "SDAT.h" 13 | 14 | SSEQ::SSEQ(const std::string &fn, const std::string &origFn) : filename(fn), origFilename(origFn), data(), entryNumber(-1) 15 | { 16 | } 17 | 18 | void SSEQ::Read(PseudoReadFile &file) 19 | { 20 | uint32_t startOfSSEQ = file.pos; 21 | NDSStdHeader header; 22 | header.Read(file); 23 | try 24 | { 25 | header.Verify("SSEQ", 0x0100FEFF); 26 | } 27 | catch (const std::exception &) 28 | { 29 | if (SDAT::failOnMissingFiles) 30 | throw; 31 | else 32 | return; 33 | } 34 | int8_t type[4]; 35 | file.ReadLE(type); 36 | if (!VerifyHeader(type, "DATA")) 37 | throw std::runtime_error("SSEQ DATA structure invalid"); 38 | uint32_t size = file.ReadLE(); 39 | uint32_t dataOffset = file.ReadLE(); 40 | this->data.resize(size - 12, 0); 41 | file.pos = startOfSSEQ + dataOffset; 42 | file.ReadLE(this->data); 43 | } 44 | -------------------------------------------------------------------------------- /common/INFOSection.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - INFO Section structures 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-10-25 5 | * 6 | * Nintendo DS Nitro Composer (SDAT) Specification document found at 7 | * http://www.feshrine.net/hacking/doc/nds-sdat.html 8 | */ 9 | 10 | #pragma once 11 | 12 | #include "INFOEntry.h" 13 | 14 | template struct INFORecord 15 | { 16 | uint32_t count, actualCount; 17 | std::vector entryOffsets; 18 | std::vector entries; 19 | 20 | INFORecord(); 21 | 22 | void Read(PseudoReadFile &file, uint32_t startOffset); 23 | uint32_t Size() const; 24 | void FixOffsets(uint32_t startOffset); 25 | void WriteHeader(PseudoWrite &file) const; 26 | void WriteData(PseudoWrite &file) const; 27 | }; 28 | 29 | struct INFOSection 30 | { 31 | int8_t type[4]; 32 | uint32_t size; 33 | uint32_t recordOffsets[8]; 34 | INFORecord SEQrecord; 35 | INFORecord BANKrecord; 36 | INFORecord WAVEARCrecord; 37 | INFORecord PLAYERrecord; 38 | 39 | INFOSection(); 40 | 41 | void Read(PseudoReadFile &file); 42 | uint32_t Size() const; 43 | void FixOffsets(); 44 | void Write(PseudoWrite &file) const; 45 | }; 46 | -------------------------------------------------------------------------------- /common/eqstr.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Case-insensitive string equality 3 | * Last modification on 2014-10-15 4 | * 5 | * Based on "How to do case-insensitive string comparison" 6 | * By Matt Austern 7 | * http://lafstern.org/matt/col2_new.pdf 8 | */ 9 | 10 | #pragma once 11 | 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | 18 | struct eq_str : std::binary_function 19 | { 20 | struct eq_char : std::binary_function 21 | { 22 | const char *tab; 23 | eq_char(const char *t) : tab(t) { } 24 | bool operator()(char x, char y) const { return this->tab[x - CHAR_MIN] == this->tab[y - CHAR_MIN]; } 25 | }; 26 | 27 | char tab[CHAR_MAX - CHAR_MIN + 1]; 28 | 29 | eq_str(const std::locale &L = std::locale::classic()) 30 | { 31 | for (int i = CHAR_MIN; i <= CHAR_MAX; ++i) 32 | this->tab[i - CHAR_MIN] = static_cast(i); 33 | std::use_facet>(L).toupper(this->tab, this->tab + (CHAR_MAX - CHAR_MIN + 1)); 34 | } 35 | 36 | bool operator()(const std::string &x, const std::string &y) const 37 | { 38 | return x.length() == y.length() && std::equal(x.begin(), x.end(), y.begin(), eq_char(this->tab)); 39 | } 40 | }; 41 | -------------------------------------------------------------------------------- /common/ltstr.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Case-insensitive string comparison 3 | * Last modification on 2014-10-15 4 | * 5 | * Based on "How to do case-insensitive string comparison" 6 | * By Matt Austern 7 | * http://lafstern.org/matt/col2_new.pdf 8 | */ 9 | 10 | #pragma once 11 | 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | 18 | struct lt_str : std::binary_function 19 | { 20 | struct lt_char : std::binary_function 21 | { 22 | const char *tab; 23 | lt_char(const char *t) : tab(t) { } 24 | bool operator()(char x, char y) const { return this->tab[x - CHAR_MIN] < this->tab[y - CHAR_MIN]; } 25 | }; 26 | 27 | char tab[CHAR_MAX - CHAR_MIN + 1]; 28 | 29 | lt_str(const std::locale &L = std::locale::classic()) 30 | { 31 | for (int i = CHAR_MIN; i <= CHAR_MAX; ++i) 32 | this->tab[i - CHAR_MIN] = static_cast(i); 33 | std::use_facet>(L).toupper(this->tab, this->tab + (CHAR_MAX - CHAR_MIN + 1)); 34 | } 35 | 36 | bool operator()(const std::string &x, const std::string &y) const 37 | { 38 | return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end(), lt_char(this->tab)); 39 | } 40 | }; 41 | -------------------------------------------------------------------------------- /common/NDSStdHeader.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - Nintendo DS Standard Header structure 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2013-03-25 5 | * 6 | * Nintendo DS Nitro Composer (SDAT) Specification document found at 7 | * http://www.feshrine.net/hacking/doc/nds-sdat.html 8 | */ 9 | 10 | #include "NDSStdHeader.h" 11 | 12 | NDSStdHeader::NDSStdHeader() : magic(0), fileSize(0), size(0), blocks(0) 13 | { 14 | memset(this->type, 0, sizeof(this->type)); 15 | } 16 | 17 | void NDSStdHeader::Read(PseudoReadFile &file) 18 | { 19 | file.ReadLE(this->type); 20 | this->magic = file.ReadLE(); 21 | this->fileSize = file.ReadLE(); 22 | this->size = file.ReadLE(); 23 | this->blocks = file.ReadLE(); // # of blocks 24 | } 25 | 26 | void NDSStdHeader::Verify(const std::string &typeToCheck, uint32_t magicToCheck) const 27 | { 28 | if (!VerifyHeader(this->type, typeToCheck) || this->magic != magicToCheck) 29 | throw std::runtime_error("NDS Standard Header for " + typeToCheck + " invalid"); 30 | } 31 | 32 | void NDSStdHeader::Write(PseudoWrite &file) const 33 | { 34 | file.WriteLE(this->type); 35 | file.WriteLE(this->magic); 36 | file.WriteLE(this->fileSize); 37 | file.WriteLE(this->size); 38 | file.WriteLE(this->blocks); 39 | } 40 | -------------------------------------------------------------------------------- /common/SBNK.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - SBNK (Sound Bank) structures 3 | * By Naram Qashat (CyberBotX) 4 | * Last modification on 2014-12-08 5 | * 6 | * Nintendo DS Nitro Composer (SDAT) Specification document found at 7 | * http://www.feshrine.net/hacking/doc/nds-sdat.html 8 | */ 9 | 10 | #pragma once 11 | 12 | #include "NDSStdHeader.h" 13 | #include "INFOEntry.h" 14 | #include "common.h" 15 | 16 | struct SBNKInstrumentRange 17 | { 18 | uint8_t lowNote; 19 | uint8_t highNote; 20 | uint16_t record; 21 | uint16_t swav; 22 | uint16_t swar; 23 | uint8_t noteNumber; 24 | uint8_t attackRate; 25 | uint8_t decayRate; 26 | uint8_t sustainLevel; 27 | uint8_t releaseRate; 28 | uint8_t pan; 29 | 30 | SBNKInstrumentRange(uint8_t lowerNote, uint8_t upperNote, int recordType); 31 | 32 | void Read(PseudoReadFile &file); 33 | void Write(PseudoWrite &file) const; 34 | }; 35 | 36 | struct SBNKInstrument 37 | { 38 | uint8_t record; 39 | uint16_t offset; 40 | uint8_t unknown; 41 | std::vector ranges; 42 | 43 | SBNKInstrument(); 44 | 45 | void Read(PseudoReadFile &file, uint32_t startOffset); 46 | uint32_t Size() const; 47 | uint16_t FixOffset(uint16_t newOffset); 48 | void WriteHeader(PseudoWrite &file) const; 49 | void WriteData(PseudoWrite &file) const; 50 | }; 51 | 52 | struct SBNK 53 | { 54 | std::string filename; 55 | NDSStdHeader header; 56 | uint32_t count; 57 | std::vector instruments; 58 | 59 | int32_t entryNumber; 60 | 61 | SBNK(const std::string &fn = ""); 62 | 63 | void Read(PseudoReadFile &file); 64 | uint32_t Size() const; 65 | uint32_t DataSize() const; 66 | void FixOffsets(); 67 | void Write(PseudoWrite &file) const; 68 | }; 69 | -------------------------------------------------------------------------------- /common/FATSection.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - FAT (File Allocation Table) Section structures 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2013-03-25 5 | * 6 | * Nintendo DS Nitro Composer (SDAT) Specification document found at 7 | * http://www.feshrine.net/hacking/doc/nds-sdat.html 8 | */ 9 | 10 | #include "FATSection.h" 11 | 12 | FATRecord::FATRecord() : offset(0), size(0) 13 | { 14 | } 15 | 16 | void FATRecord::Read(PseudoReadFile &file) 17 | { 18 | this->offset = file.ReadLE(); 19 | this->size = file.ReadLE(); 20 | uint32_t reserved[2]; 21 | file.ReadLE(reserved); 22 | } 23 | 24 | void FATRecord::Write(PseudoWrite &file) const 25 | { 26 | file.WriteLE(this->offset); 27 | file.WriteLE(this->size); 28 | uint32_t reserved[2] = { }; 29 | file.WriteLE(reserved); 30 | } 31 | 32 | FATSection::FATSection() : size(0), count(0), records() 33 | { 34 | memcpy(this->type, "FAT ", sizeof(this->type)); 35 | } 36 | 37 | void FATSection::Read(PseudoReadFile &file) 38 | { 39 | file.ReadLE(this->type); 40 | if (!VerifyHeader(this->type, "FAT ")) 41 | throw std::runtime_error("SDAT FAT Section invalid"); 42 | this->size = file.ReadLE(); 43 | this->count = file.ReadLE(); 44 | this->records.resize(this->count); 45 | for (uint32_t i = 0; i < this->count; ++i) 46 | this->records[i].Read(file); 47 | } 48 | 49 | uint32_t FATSection::Size() const 50 | { 51 | return 12 + 16 * this->count; // type + size + count + records * 16 (size of each record) 52 | } 53 | 54 | void FATSection::Write(PseudoWrite &file) const 55 | { 56 | file.WriteLE(this->type); 57 | file.WriteLE(this->size); 58 | file.WriteLE(this->count); 59 | for (uint32_t i = 0; i < this->count; ++i) 60 | this->records[i].Write(file); 61 | } 62 | -------------------------------------------------------------------------------- /common/SDAT.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - SDAT structure 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-12-08 5 | * 6 | * Nintendo DS Nitro Composer (SDAT) Specification document found at 7 | * http://www.feshrine.net/hacking/doc/nds-sdat.html 8 | */ 9 | 10 | #pragma once 11 | 12 | #include "NDSStdHeader.h" 13 | #include "SYMBSection.h" 14 | #include "INFOSection.h" 15 | #include "FATSection.h" 16 | #include "SSEQ.h" 17 | #include "SBNK.h" 18 | #include "SWAR.h" 19 | #include "common.h" 20 | 21 | struct SDAT 22 | { 23 | typedef std::vector> SSEQList; 24 | typedef std::vector> SBNKList; 25 | typedef std::vector> SWARList; 26 | 27 | static bool failOnMissingFiles; 28 | 29 | std::string filename; 30 | NDSStdHeader header; 31 | uint32_t SYMBOffset; 32 | uint32_t SYMBSize; 33 | uint32_t INFOOffset; 34 | uint32_t INFOSize; 35 | uint32_t FATOffset; 36 | uint32_t FATSize; 37 | uint32_t FILEOffset; 38 | uint32_t FILESize; 39 | 40 | SYMBSection symbSection; 41 | INFOSection infoSection; 42 | FATSection fatSection; 43 | 44 | bool symbSectionNeedsCleanup; 45 | uint16_t count; 46 | 47 | SSEQList SSEQs; 48 | SBNKList SBNKs; 49 | SWARList SWARs; 50 | 51 | SDAT(); 52 | SDAT(const SDAT &sdat); 53 | SDAT &operator=(const SDAT &sdat); 54 | 55 | void Read(const std::string &fn, PseudoReadFile &file, bool shouldFailOnMissingFiles = true); 56 | void Write(PseudoWrite &file) const; 57 | 58 | SDAT MakeFromSSEQ(uint16_t SSEQNumber) const; 59 | 60 | SDAT &operator+=(const SDAT &other); 61 | void Strip(const IncOrExc &includesAndExcludes, bool verbose, bool removeExcluded = true); 62 | void StripBanksAndWaveArcs(); 63 | void FixOffsetsAndSizes(); 64 | 65 | SSEQList::iterator GetNonConstSSEQ(const SSEQ *sseq); 66 | SBNKList::iterator GetNonConstSBNK(const SBNK *sbnk); 67 | SWARList::iterator GetNonConstSWAR(const SWAR *swar); 68 | }; 69 | -------------------------------------------------------------------------------- /common/TagList.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * xSF Tag List 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-11-12 5 | * 6 | * Storage of tags from PSF-style files, specifications found at 7 | * http://wiki.neillcorlett.com/PSFTagFormat 8 | */ 9 | 10 | #include 11 | #include "TagList.h" 12 | 13 | eq_str TagList::eqstr; 14 | 15 | auto TagList::GetKeys() const -> const TagsList & 16 | { 17 | return this->tagsOrder; 18 | } 19 | 20 | auto TagList::GetTags() const -> TagsList 21 | { 22 | TagsList allTags; 23 | std::for_each(this->tagsOrder.begin(), this->tagsOrder.end(), [&](const std::string &tag) 24 | { 25 | allTags.push_back(tag + "=" + this->tags.find(tag)->second); 26 | }); 27 | return allTags; 28 | } 29 | 30 | bool TagList::Empty() const 31 | { 32 | return this->tags.empty(); 33 | } 34 | 35 | bool TagList::Exists(const std::string &name) const 36 | { 37 | return std::find_if(this->tagsOrder.begin(), this->tagsOrder.end(), std::bind2nd(TagList::eqstr, name)) != this->tagsOrder.end(); 38 | } 39 | 40 | std::string TagList::operator[](const std::string &name) const 41 | { 42 | auto tag = this->tags.find(name); 43 | if (tag == this->tags.end()) 44 | return ""; 45 | return tag->second; 46 | } 47 | 48 | std::string &TagList::operator[](const std::string &name) 49 | { 50 | auto tag = std::find_if(this->tagsOrder.begin(), this->tagsOrder.end(), std::bind2nd(TagList::eqstr, name)); 51 | if (tag == this->tagsOrder.end()) 52 | { 53 | this->tagsOrder.push_back(name); 54 | this->tags[name] = ""; 55 | } 56 | return this->tags[name]; 57 | } 58 | 59 | void TagList::CopyOverwriteExistingOnly(const TagList ©) 60 | { 61 | std::for_each(copy.tagsOrder.begin(), copy.tagsOrder.end(), [&](const std::string &tag) { (*this)[tag] = copy[tag]; }); 62 | } 63 | 64 | void TagList::Remove(const std::string &name) 65 | { 66 | auto tagOrder = std::find_if(this->tagsOrder.begin(), this->tagsOrder.end(), std::bind2nd(TagList::eqstr, name)); 67 | if (tagOrder != this->tagsOrder.end()) 68 | this->tagsOrder.erase(tagOrder); 69 | if (this->tags.count(name)) 70 | this->tags.erase(name); 71 | } 72 | 73 | void TagList::Clear() 74 | { 75 | this->tagsOrder.clear(); 76 | this->tags.clear(); 77 | } 78 | -------------------------------------------------------------------------------- /common/TimerPlayer.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - Timer Player structure 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-12-08 5 | * 6 | * Adapted from source code of FeOS Sound System 7 | * By fincs 8 | * https://github.com/fincs/FSS 9 | * 10 | * This has been modified in order to be able to provide timing for an SSEQ. 11 | */ 12 | 13 | #pragma once 14 | 15 | #include 16 | #include "TimerTrack.h" 17 | #include "TimerChannel.h" 18 | #include "SSEQ.h" 19 | #include "SBNK.h" 20 | #include "SWAR.h" 21 | #ifdef _WIN32 22 | # include "windowsh_wrapper.h" 23 | #else 24 | # include 25 | # include 26 | # include 27 | #endif 28 | 29 | enum TimeType 30 | { 31 | LOOP, 32 | END 33 | }; 34 | 35 | struct Time 36 | { 37 | double time; 38 | TimeType type; 39 | 40 | Time(double tim = 0.0, TimeType typ = LOOP) : time(tim), type(typ) 41 | { 42 | } 43 | }; 44 | 45 | const int TRACKCOUNT = 16; 46 | const int MAXTRACKS = 32; 47 | 48 | enum { TYPE_PCM, TYPE_PSG, TYPE_NOISE }; 49 | 50 | struct TimerPlayer 51 | { 52 | uint8_t prio, nTracks; 53 | uint16_t tempo, tempoCount, tempoRate; 54 | int16_t masterVol, sseqVol; 55 | 56 | TimerTrack tracks[MAXTRACKS]; 57 | std::vector trackTimes[MAXTRACKS]; 58 | double trailingSilenceSeconds; 59 | TimerChannel channels[16]; 60 | int16_t variables[32]; 61 | 62 | const SSEQ *sseq; 63 | const SBNK *sbnk; 64 | const SWAR *swar[4]; 65 | 66 | double seconds; 67 | 68 | #ifdef _WIN32 69 | HANDLE mutex, thread; 70 | #else 71 | pthread_mutex_t mutex; 72 | pthread_t thread; 73 | #endif 74 | uint32_t maxSeconds, loops; 75 | bool doLength, doNotes; 76 | Time length; 77 | 78 | TimerPlayer(); 79 | 80 | #ifdef _WIN32 81 | ~TimerPlayer() 82 | { 83 | CloseHandle(this->mutex); 84 | } 85 | #endif 86 | 87 | void Setup(const SSEQ *sseqToPlay, const std::string &filename); 88 | int ChannelAlloc(int type, int priority); 89 | void Run(); 90 | void UpdateTracks(); 91 | Time Length(); 92 | void LockMutex(); 93 | void UnlockMutex(); 94 | void GetLength(); 95 | 96 | #ifdef _WIN32 97 | static DWORD WINAPI GetLengthThread(void *handle); 98 | #else 99 | static void *GetLengthThread(void *handle); 100 | #endif 101 | void StartLengthThread(); 102 | void WaitForThread(); 103 | }; 104 | -------------------------------------------------------------------------------- /common/INFOEntry.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - INFO Entry structures 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-10-25 5 | * 6 | * Nintendo DS Nitro Composer (SDAT) Specification document found at 7 | * http://www.feshrine.net/hacking/doc/nds-sdat.html 8 | */ 9 | 10 | #pragma once 11 | 12 | #include "common.h" 13 | 14 | struct SSEQ; 15 | struct SBNK; 16 | struct SWAR; 17 | 18 | struct INFOEntry 19 | { 20 | std::vector fileData; 21 | std::string origFilename; 22 | std::string sdatNumber; 23 | 24 | INFOEntry(); 25 | INFOEntry(const INFOEntry &entry); 26 | INFOEntry &operator=(const INFOEntry &entry); 27 | 28 | virtual ~INFOEntry() 29 | { 30 | } 31 | 32 | virtual void Read(PseudoReadFile &file) = 0; 33 | virtual uint32_t Size() const = 0; 34 | virtual void Write(PseudoWrite &file) const = 0; 35 | 36 | std::string FullFilename(bool multipleSDATs) const; 37 | }; 38 | 39 | struct INFOEntrySEQ : INFOEntry 40 | { 41 | uint16_t fileID; 42 | uint16_t unknown; 43 | uint16_t bank; 44 | uint8_t vol; 45 | uint8_t cpr; 46 | uint8_t ppr; 47 | uint8_t ply; 48 | uint8_t unknown2[2]; 49 | const SSEQ *sseq; 50 | 51 | INFOEntrySEQ(); 52 | INFOEntrySEQ(const INFOEntrySEQ &entry); 53 | INFOEntrySEQ &operator=(const INFOEntrySEQ &entry); 54 | 55 | void Read(PseudoReadFile &file); 56 | uint32_t Size() const; 57 | void Write(PseudoWrite &file) const; 58 | }; 59 | 60 | struct INFOEntryBANK : INFOEntry 61 | { 62 | uint16_t fileID; 63 | uint16_t unknown; 64 | uint16_t waveArc[4]; 65 | const SBNK *sbnk; 66 | 67 | INFOEntryBANK(); 68 | INFOEntryBANK(const INFOEntryBANK &entry); 69 | INFOEntryBANK &operator=(const INFOEntryBANK &entry); 70 | 71 | void Read(PseudoReadFile &file); 72 | uint32_t Size() const; 73 | void Write(PseudoWrite &file) const; 74 | }; 75 | 76 | struct INFOEntryWAVEARC : INFOEntry 77 | { 78 | uint16_t fileID; 79 | uint16_t unknown; 80 | const SWAR *swar; 81 | 82 | INFOEntryWAVEARC(); 83 | INFOEntryWAVEARC(const INFOEntryWAVEARC &entry); 84 | INFOEntryWAVEARC &operator=(const INFOEntryWAVEARC &entry); 85 | 86 | void Read(PseudoReadFile &file); 87 | uint32_t Size() const; 88 | void Write(PseudoWrite &file) const; 89 | }; 90 | 91 | struct INFOEntryPLAYER : INFOEntry 92 | { 93 | uint16_t maxSeqs; 94 | uint16_t channelMask; 95 | uint32_t heapSize; 96 | 97 | INFOEntryPLAYER(); 98 | INFOEntryPLAYER(const INFOEntryPLAYER &entry); 99 | INFOEntryPLAYER &operator=(const INFOEntryPLAYER &entry); 100 | 101 | void Read(PseudoReadFile &file); 102 | uint32_t Size() const; 103 | void Write(PseudoWrite &file) const; 104 | }; 105 | -------------------------------------------------------------------------------- /common/TimerTrack.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - Timer Track 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-11-12 5 | * 6 | * Adapted from source code of FeOS Sound System 7 | * By fincs 8 | * https://github.com/fincs/FSS 9 | * 10 | * This has been modified in order to be able to provide timing for an SSEQ. 11 | */ 12 | 13 | #pragma once 14 | 15 | #include 16 | #include 17 | #include "SSEQ.h" 18 | #include "common.h" 19 | 20 | const int TRACKSTACKSIZE = 3; 21 | 22 | enum { TS_NOTEWAIT, TS_PORTABIT, TS_TIEBIT, TS_END, TS_BITS }; 23 | 24 | enum { TUF_VOL, TUF_PAN, TUF_TIMER, TUF_MOD, TUF_LEN, TUF_BITS }; 25 | 26 | struct TimerPlayer; 27 | 28 | enum StackType 29 | { 30 | STACKTYPE_CALL, 31 | STACKTYPE_LOOP 32 | }; 33 | 34 | struct StackValue 35 | { 36 | StackType type; 37 | uint32_t destPos; 38 | 39 | StackValue() : type(STACKTYPE_CALL), destPos(0) { } 40 | StackValue(StackType newType, uint32_t newDestPos) : type(newType), destPos(newDestPos) { } 41 | }; 42 | 43 | struct Override 44 | { 45 | bool overriding; 46 | int cmd; 47 | int value; 48 | int extraValue; 49 | 50 | Override() : overriding(false) { } 51 | bool operator()() const { return this->overriding; } 52 | bool &operator()() { return this->overriding; } 53 | int val(std::function reader, bool returnExtra = false) 54 | { 55 | if (this->overriding) 56 | return returnExtra ? this->extraValue : this->value; 57 | else 58 | return reader(); 59 | } 60 | }; 61 | 62 | struct TimerTrack 63 | { 64 | int8_t trackId; 65 | 66 | std::bitset state; 67 | uint8_t prio; 68 | TimerPlayer *ply; 69 | 70 | uint32_t startPos; 71 | PseudoReadFile file; 72 | StackValue stack[TRACKSTACKSIZE]; 73 | uint8_t stackPos, loopCount[TRACKSTACKSIZE]; 74 | Override overriding; 75 | bool lastComparisonResult; 76 | 77 | int wait; 78 | uint16_t patch; 79 | uint8_t portaKey, portaTime; 80 | int16_t sweepPitch; 81 | uint8_t vol, expr; 82 | int8_t pan; 83 | uint8_t pitchBendRange; 84 | int8_t pitchBend, transpose; 85 | 86 | uint8_t a, d, s, r; 87 | 88 | uint8_t modType, modSpeed, modDepth, modRange; 89 | uint16_t modDelay; 90 | 91 | std::bitset updateFlags; 92 | 93 | bool hitLoop, hitEnd; 94 | 95 | TimerTrack(); 96 | 97 | void ClearState(); 98 | void Init(uint8_t handle, TimerPlayer *player, const PseudoReadFile &source); 99 | int NoteOn(int key, int vel, int len); 100 | int NoteOnTie(int key, int vel); 101 | void ReleaseAllNotes(); 102 | void Run(); 103 | static std::pair, std::vector> GetPatches(const SSEQ *sseq); 104 | static std::pair, std::vector> GetPatches(const std::vector &data); 105 | 106 | int Read8(); 107 | int Read16(); 108 | int Read24(); 109 | int ReadVL(); 110 | 111 | std::function read8, read16, read24, readvl; 112 | }; 113 | -------------------------------------------------------------------------------- /common/SWAR.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SSEQ Player - SDAT SWAR (Wave Archive) structures 3 | * By Naram Qashat (CyberBotX) 4 | * Last modification on 2014-12-08 5 | * 6 | * Nintendo DS Nitro Composer (SDAT) Specification document found at 7 | * http://www.feshrine.net/hacking/doc/nds-sdat.html 8 | */ 9 | 10 | #include "SWAR.h" 11 | #include "SDAT.h" 12 | 13 | SWAR::SWAR(const std::string &fn) : filename(fn), header(), swavs(), entryNumber(-1) 14 | { 15 | } 16 | 17 | SWAR::SWAR(const SWAR &swar) : filename(swar.filename), header(swar.header), swavs(), entryNumber(swar.entryNumber) 18 | { 19 | std::for_each(swar.swavs.begin(), swar.swavs.end(), [&](const SWAVs::value_type &swav) 20 | { 21 | this->swavs[swav.first].reset(new SWAV(*swav.second.get())); 22 | }); 23 | } 24 | 25 | SWAR &SWAR::operator=(const SWAR &swar) 26 | { 27 | if (this != &swar) 28 | { 29 | this->filename = swar.filename; 30 | this->header = swar.header; 31 | std::for_each(swar.swavs.begin(), swar.swavs.end(), [&](const SWAVs::value_type &swav) 32 | { 33 | this->swavs[swav.first].reset(new SWAV(*swav.second.get())); 34 | }); 35 | 36 | this->entryNumber = swar.entryNumber; 37 | } 38 | return *this; 39 | } 40 | 41 | void SWAR::Read(PseudoReadFile &file) 42 | { 43 | uint32_t startOfSWAR = file.pos; 44 | this->header.Read(file); 45 | try 46 | { 47 | this->header.Verify("SWAR", 0x0100FEFF); 48 | } 49 | catch (const std::exception &) 50 | { 51 | if (SDAT::failOnMissingFiles) 52 | throw; 53 | else 54 | return; 55 | } 56 | int8_t type[4]; 57 | file.ReadLE(type); 58 | if (!VerifyHeader(type, "DATA")) 59 | throw std::runtime_error("SWAR DATA structure invalid"); 60 | file.ReadLE(); // size 61 | uint32_t reserved[8]; 62 | file.ReadLE(reserved); 63 | uint32_t count = file.ReadLE(); 64 | auto offsets = std::vector(count); 65 | file.ReadLE(offsets); 66 | for (uint32_t i = 0; i < count; ++i) 67 | if (offsets[i]) 68 | { 69 | file.pos = startOfSWAR + offsets[i]; 70 | this->swavs[i].reset(new SWAV()); 71 | this->swavs[i]->Read(file); 72 | } 73 | } 74 | 75 | uint32_t SWAR::Size() const 76 | { 77 | uint32_t size = 60 + 4 * this->swavs.size(); // Header + DATA + size + 8 32-bit reserved bytes + count + offsets 78 | std::for_each(this->swavs.begin(), this->swavs.end(), [&](const SWAVs::value_type &swav) 79 | { 80 | size += swav.second->Size(); 81 | }); 82 | return size; 83 | } 84 | 85 | void SWAR::Write(PseudoWrite &file) const 86 | { 87 | this->header.Write(file); 88 | file.WriteLE("DATA", 4); 89 | file.WriteLE(this->header.fileSize - 16); 90 | uint32_t reserved[8] = { }; 91 | file.WriteLE(reserved); 92 | uint32_t count = this->swavs.size(); 93 | file.WriteLE(count); 94 | uint32_t offset = 0x3C + 4 * count; 95 | std::for_each(this->swavs.begin(), this->swavs.end(), [&](const SWAVs::value_type &swav) 96 | { 97 | file.WriteLE(offset); 98 | offset += swav.second->Size(); 99 | }); 100 | std::for_each(this->swavs.begin(), this->swavs.end(), [&](const SWAVs::value_type &swav) 101 | { 102 | swav.second->Write(file); 103 | }); 104 | } 105 | -------------------------------------------------------------------------------- /SDATStuff.sln: -------------------------------------------------------------------------------- 1 | 2 | Microsoft Visual Studio Solution File, Format Version 11.00 3 | # Visual C++ Express 2010 4 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "common", "common\common.vcxproj", "{51D9DA16-25BB-43CD-B340-934B5CF8E5F2}" 5 | EndProject 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SDATStrip", "SDATStrip\SDATStrip.vcxproj", "{642DA5E2-87BC-468D-8148-45F3C1757FF3}" 7 | EndProject 8 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SDATtoNCSF", "SDATtoNCSF\SDATtoNCSF.vcxproj", "{480AAF0F-0749-4C3D-A6DE-3CF632AB1B0B}" 9 | EndProject 10 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "NDStoNCSF", "NDStoNCSF\NDStoNCSF.vcxproj", "{22504693-3E5E-4595-A3A0-34CB82F66495}" 11 | EndProject 12 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "2SFTagsToNCSF", "2SFTagsToNCSF\2SFTagsToNCSF.vcxproj", "{D09C8931-0A54-4328-8093-4B083C36860C}" 13 | EndProject 14 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "2SFtoNCSF", "2SFtoNCSF\2SFtoNCSF.vcxproj", "{E0A4E2AC-4DD5-4721-9E0D-07221218DA68}" 15 | EndProject 16 | Global 17 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 18 | Debug|Win32 = Debug|Win32 19 | Release|Win32 = Release|Win32 20 | EndGlobalSection 21 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 22 | {51D9DA16-25BB-43CD-B340-934B5CF8E5F2}.Debug|Win32.ActiveCfg = Debug|Win32 23 | {51D9DA16-25BB-43CD-B340-934B5CF8E5F2}.Debug|Win32.Build.0 = Debug|Win32 24 | {51D9DA16-25BB-43CD-B340-934B5CF8E5F2}.Release|Win32.ActiveCfg = Release|Win32 25 | {51D9DA16-25BB-43CD-B340-934B5CF8E5F2}.Release|Win32.Build.0 = Release|Win32 26 | {642DA5E2-87BC-468D-8148-45F3C1757FF3}.Debug|Win32.ActiveCfg = Debug|Win32 27 | {642DA5E2-87BC-468D-8148-45F3C1757FF3}.Debug|Win32.Build.0 = Debug|Win32 28 | {642DA5E2-87BC-468D-8148-45F3C1757FF3}.Release|Win32.ActiveCfg = Release|Win32 29 | {642DA5E2-87BC-468D-8148-45F3C1757FF3}.Release|Win32.Build.0 = Release|Win32 30 | {480AAF0F-0749-4C3D-A6DE-3CF632AB1B0B}.Debug|Win32.ActiveCfg = Debug|Win32 31 | {480AAF0F-0749-4C3D-A6DE-3CF632AB1B0B}.Debug|Win32.Build.0 = Debug|Win32 32 | {480AAF0F-0749-4C3D-A6DE-3CF632AB1B0B}.Release|Win32.ActiveCfg = Release|Win32 33 | {480AAF0F-0749-4C3D-A6DE-3CF632AB1B0B}.Release|Win32.Build.0 = Release|Win32 34 | {22504693-3E5E-4595-A3A0-34CB82F66495}.Debug|Win32.ActiveCfg = Debug|Win32 35 | {22504693-3E5E-4595-A3A0-34CB82F66495}.Debug|Win32.Build.0 = Debug|Win32 36 | {22504693-3E5E-4595-A3A0-34CB82F66495}.Release|Win32.ActiveCfg = Release|Win32 37 | {22504693-3E5E-4595-A3A0-34CB82F66495}.Release|Win32.Build.0 = Release|Win32 38 | {D09C8931-0A54-4328-8093-4B083C36860C}.Debug|Win32.ActiveCfg = Debug|Win32 39 | {D09C8931-0A54-4328-8093-4B083C36860C}.Debug|Win32.Build.0 = Debug|Win32 40 | {D09C8931-0A54-4328-8093-4B083C36860C}.Release|Win32.ActiveCfg = Release|Win32 41 | {D09C8931-0A54-4328-8093-4B083C36860C}.Release|Win32.Build.0 = Release|Win32 42 | {E0A4E2AC-4DD5-4721-9E0D-07221218DA68}.Debug|Win32.ActiveCfg = Debug|Win32 43 | {E0A4E2AC-4DD5-4721-9E0D-07221218DA68}.Debug|Win32.Build.0 = Debug|Win32 44 | {E0A4E2AC-4DD5-4721-9E0D-07221218DA68}.Release|Win32.ActiveCfg = Release|Win32 45 | {E0A4E2AC-4DD5-4721-9E0D-07221218DA68}.Release|Win32.Build.0 = Release|Win32 46 | EndGlobalSection 47 | GlobalSection(SolutionProperties) = preSolution 48 | HideSolutionNode = FALSE 49 | EndGlobalSection 50 | EndGlobal 51 | -------------------------------------------------------------------------------- /GNUmakefile: -------------------------------------------------------------------------------- 1 | UNAME:= $(shell uname -s) 2 | 3 | SRCDIR:= $(dir $(abspath $(lastword $(MAKEFILE_LIST)))) 4 | 5 | COMMON_SRCS= SDAT.cpp NDSStdHeader.cpp SYMBSection.cpp INFOSection.cpp INFOEntry.cpp FATSection.cpp SSEQ.cpp SWAV.cpp SWAR.cpp SBNK.cpp TimerChannel.cpp TimerPlayer.cpp TimerTrack.cpp 6 | COMMON_SRCS:= $(sort $(addprefix $(SRCDIR)common/,$(COMMON_SRCS))) 7 | 8 | SDATtoNCSF_SRCS:= $(SRCDIR)SDATtoNCSF/SDATtoNCSF.cpp $(SRCDIR)common/TagList.cpp $(SRCDIR)common/NCSF.cpp $(COMMON_SRCS) 9 | SDATStrip_SRCS:= $(SRCDIR)SDATStrip/SDATStrip.cpp $(COMMON_SRCS) 10 | NDStoNCSF_SRCS:= $(SRCDIR)NDStoNCSF/NDStoNCSF.cpp $(SRCDIR)common/TagList.cpp $(SRCDIR)common/NCSF.cpp $(COMMON_SRCS) 11 | 2SFTagsToNCSF_SRCS:= $(SRCDIR)2SFTagsToNCSF/2SFTagsToNCSF.cpp $(SRCDIR)common/TagList.cpp $(SRCDIR)common/NCSF.cpp $(COMMON_SRCS) 12 | 2SFtoNCSF_SRCS:= $(SRCDIR)2SFtoNCSF/2SFtoNCSF.cpp $(SRCDIR)common/TagList.cpp $(SRCDIR)common/NCSF.cpp $(COMMON_SRCS) 13 | 14 | PROGS= SDATtoNCSF/SDATtoNCSF SDATStrip/SDATStrip NDStoNCSF/NDStoNCSF 2SFTagsToNCSF/2SFTagsToNCSF 2SFtoNCSF/2SFtoNCSF 15 | PROGS:= $(sort $(PROGS)) 16 | 17 | PROG_SUFFIX= 18 | 19 | COMPILER:= $(shell $(CXX) -v 2>/dev/stdout) 20 | 21 | MY_CPPFLAGS= $(CPPFLAGS) -std=gnu++11 -I$(SRCDIR)common 22 | MY_CXXFLAGS= $(CXXFLAGS) -std=gnu++11 -pipe -Wall -Wctor-dtor-privacy -Wold-style-cast -Wextra -Wno-div-by-zero -Wfloat-equal -Wshadow -Winit-self -Wcast-qual -Wunreachable-code -Wabi -Woverloaded-virtual -Wno-long-long -Wno-switch -Wno-abi -I$(SRCDIR)common 23 | ifeq (,$(findstring clang,$(COMPILER))) 24 | MY_CXXFLAGS+= -Wlogical-op 25 | endif 26 | MY_LDFLAGS= $(LDFLAGS) -lz -pthread 27 | 28 | ifneq (,$(findstring MINGW,$(UNAME))) 29 | PROGS:= $(addsuffix .exe,$(PROGS)) 30 | PROG_SUFFIX= .exe 31 | endif 32 | 33 | PROG_SRCS_template= $(1)_SRCS:= $$(sort $$($(1)_SRCS)) 34 | PROG_OBJS_template= $(1)_OBJS:= $$(subst $(SRCDIR),,$$($(1)_SRCS:%.cpp=%.o)) 35 | 36 | $(foreach prog,$(PROGS),$(eval $(call PROG_SRCS_template,$(basename $(notdir $(prog)))))) 37 | $(foreach prog,$(PROGS),$(eval $(call PROG_OBJS_template,$(basename $(notdir $(prog)))))) 38 | 39 | SRCS:= $(sort $(foreach prog,$(PROGS),$($(basename $(notdir $(prog)))_SRCS))) 40 | OBJS:= $(sort $(foreach prog,$(PROGS),$($(basename $(notdir $(prog)))_OBJS))) 41 | DEPS:= $(OBJS:%.o=%.d) 42 | 43 | .PHONY: all debug clean 44 | 45 | .SUFFIXES: 46 | .SUFFIXES: .cpp .o .d $(PROG_SUFFIX) 47 | 48 | all: $(PROGS) 49 | debug: CXXFLAGS+= -g -D_DEBUG 50 | debug: all 51 | 52 | define PROG_template 53 | $(1): $$($$(basename $$(notdir $(1)))_OBJS) 54 | @echo "Linking $$@..." 55 | @$$(CXX) $$(MY_CXXFLAGS) -o $$@ $$^ $$(MY_LDFLAGS) 56 | endef 57 | define SRC_template 58 | $$(subst $(SRCDIR),,$(1:%.cpp=%.o)): $(1) 59 | @echo "Compiling $$<..." 60 | @$$(CXX) $$(MY_CXXFLAGS) -o $$(subst $(SRCDIR),,$$@) -c $$< 61 | endef 62 | define DEP_template 63 | $$(subst $(SRCDIR),,$(1:%.cpp=%.d)): $(1) 64 | @echo "Calculating depends for $$<..." 65 | -@mkdir -p $$(@D) 66 | @$$(CXX) $$(MY_CPPFLAGS) -MM -MF $$(subst $(SRCDIR),,$$@).tmp $$< 67 | @sed 's,$$(notdir $$*)\.o[ :]*,$$(subst /,\/,$$*).o $$(subst /,\/,$$@): ,g' < $$(subst $(SRCDIR),,$$@).tmp > $$(subst $(SRCDIR),,$$@) 68 | @rm $$(subst $(SRCDIR),,$$@).tmp 69 | endef 70 | 71 | $(foreach prog,$(PROGS),$(eval $(call PROG_template,$(prog)))) 72 | $(foreach src,$(SRCS),$(eval $(call SRC_template,$(src)))) 73 | $(foreach src,$(SRCS),$(eval $(call DEP_template,$(src)))) 74 | 75 | clean: 76 | @echo "Cleaning OBJs and PROGs..." 77 | -@rm $(OBJS) $(PROGS) 78 | 79 | -include $(DEPS) 80 | -------------------------------------------------------------------------------- /common/SWAV.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - SWAV (Waveform/Sample) structure 3 | * By Naram Qashat (CyberBotX) 4 | * Last modification on 2014-12-08 5 | * 6 | * Nintendo DS Nitro Composer (SDAT) Specification document found at 7 | * http://www.feshrine.net/hacking/doc/nds-sdat.html 8 | */ 9 | 10 | #include "SWAV.h" 11 | 12 | static int ima_index_table[] = 13 | { 14 | -1, -1, -1, -1, 2, 4, 6, 8, 15 | -1, -1, -1, -1, 2, 4, 6, 8 16 | }; 17 | 18 | static int ima_step_table[] = 19 | { 20 | 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 21 | 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, 22 | 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 23 | 130, 143, 157, 173, 190, 209, 230, 253, 279, 307, 24 | 337, 371, 408, 449, 494, 544, 598, 658, 724, 796, 25 | 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066, 26 | 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358, 27 | 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899, 28 | 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767 29 | }; 30 | 31 | SWAV::SWAV() : waveType(0), loop(0), sampleRate(0), time(0), loopOffset(0), nonLoopLength(0), data() 32 | { 33 | } 34 | 35 | static inline void DecodeADPCMNibble(int32_t nibble, int32_t &stepIndex, int32_t &predictedValue) 36 | { 37 | int32_t step = ima_step_table[stepIndex]; 38 | 39 | stepIndex += ima_index_table[nibble]; 40 | 41 | if (stepIndex < 0) 42 | stepIndex = 0; 43 | else if (stepIndex > 88) 44 | stepIndex = 88; 45 | 46 | int32_t diff = step >> 3; 47 | 48 | if (nibble & 4) 49 | diff += step; 50 | if (nibble & 2) 51 | diff += step >> 1; 52 | if (nibble & 1) 53 | diff += step >> 2; 54 | if (nibble & 8) 55 | predictedValue -= diff; 56 | else 57 | predictedValue += diff; 58 | 59 | if (predictedValue < -0x8000) 60 | predictedValue = -0x8000; 61 | else if (predictedValue > 0x7FFF) 62 | predictedValue = 0x7FFF; 63 | } 64 | 65 | void SWAV::DecodeADPCM(uint32_t len) 66 | { 67 | int32_t predictedValue = this->origData[0] | (this->origData[1] << 8); 68 | int32_t stepIndex = this->origData[2] | (this->origData[3] << 8); 69 | auto finalData = &this->data[0]; 70 | 71 | for (uint32_t i = 0; i < len; ++i) 72 | { 73 | int32_t nibble = this->origData[i + 4] & 0x0F; 74 | DecodeADPCMNibble(nibble, stepIndex, predictedValue); 75 | finalData[2 * i] = predictedValue; 76 | 77 | nibble = (this->origData[i + 4] >> 4) & 0x0F; 78 | DecodeADPCMNibble(nibble, stepIndex, predictedValue); 79 | finalData[2 * i + 1] = predictedValue; 80 | } 81 | } 82 | 83 | void SWAV::Read(PseudoReadFile &file) 84 | { 85 | this->waveType = file.ReadLE(); 86 | this->loop = file.ReadLE(); 87 | this->sampleRate = file.ReadLE(); 88 | this->time = file.ReadLE(); 89 | this->loopOffset = this->origLoopOffset = file.ReadLE(); 90 | this->nonLoopLength = this->origNonLoopLength = file.ReadLE(); 91 | uint32_t size = (this->loopOffset + this->nonLoopLength) * 4; 92 | this->origData.resize(size); 93 | file.ReadLE(this->origData); 94 | 95 | // Convert data accordingly 96 | if (!this->waveType) 97 | { 98 | // PCM 8-bit -> PCM signed 16-bit 99 | this->data.resize(size, 0); 100 | for (size_t i = 0; i < size; ++i) 101 | this->data[i] = this->origData[i] << 8; 102 | this->loopOffset *= 4; 103 | this->nonLoopLength *= 4; 104 | } 105 | else if (this->waveType == 1) 106 | { 107 | // PCM signed 16-bit, no conversion 108 | this->data.resize(size / 2, 0); 109 | for (size_t i = 0; i < size / 2; ++i) 110 | this->data[i] = ReadLE(&this->origData[2 * i]); 111 | this->loopOffset *= 2; 112 | this->nonLoopLength *= 2; 113 | } 114 | else if (this->waveType == 2) 115 | { 116 | // IMA ADPCM -> PCM signed 16-bit 117 | this->data.resize((size - 4) * 2, 0); 118 | this->DecodeADPCM(size - 4); 119 | if (this->loopOffset) 120 | --this->loopOffset; 121 | this->loopOffset *= 8; 122 | this->nonLoopLength *= 8; 123 | } 124 | } 125 | 126 | uint32_t SWAV::Size() const 127 | { 128 | return this->origData.size() + 12; 129 | } 130 | 131 | void SWAV::Write(PseudoWrite &file) const 132 | { 133 | file.WriteLE(this->waveType); 134 | file.WriteLE(this->loop); 135 | file.WriteLE(this->sampleRate); 136 | file.WriteLE(this->time); 137 | file.WriteLE(this->origLoopOffset); 138 | file.WriteLE(this->origNonLoopLength); 139 | file.WriteLE(this->origData); 140 | } 141 | -------------------------------------------------------------------------------- /common/common.vcxproj.filters: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hpp;hxx;hm;inl;inc;xsd 11 | 12 | 13 | 14 | 15 | Header Files 16 | 17 | 18 | Header Files 19 | 20 | 21 | Header Files 22 | 23 | 24 | Header Files 25 | 26 | 27 | Header Files 28 | 29 | 30 | Header Files 31 | 32 | 33 | Header Files 34 | 35 | 36 | Header Files 37 | 38 | 39 | Header Files 40 | 41 | 42 | Header Files 43 | 44 | 45 | Header Files 46 | 47 | 48 | Header Files 49 | 50 | 51 | Header Files 52 | 53 | 54 | Header Files 55 | 56 | 57 | Header Files 58 | 59 | 60 | Header Files 61 | 62 | 63 | Header Files 64 | 65 | 66 | Header Files 67 | 68 | 69 | Header Files 70 | 71 | 72 | Header Files 73 | 74 | 75 | Header Files 76 | 77 | 78 | 79 | 80 | Source Files 81 | 82 | 83 | Source Files 84 | 85 | 86 | Source Files 87 | 88 | 89 | Source Files 90 | 91 | 92 | Source Files 93 | 94 | 95 | Source Files 96 | 97 | 98 | Source Files 99 | 100 | 101 | Source Files 102 | 103 | 104 | Source Files 105 | 106 | 107 | Source Files 108 | 109 | 110 | Source Files 111 | 112 | 113 | Source Files 114 | 115 | 116 | Source Files 117 | 118 | 119 | Source Files 120 | 121 | 122 | Source Files 123 | 124 | 125 | 126 | 127 | 128 | -------------------------------------------------------------------------------- /SDATStrip/SDATStrip.vcxproj: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | 14 | {642DA5E2-87BC-468D-8148-45F3C1757FF3} 15 | Win32Proj 16 | SDATStrip 17 | 18 | 19 | 20 | Application 21 | true 22 | Unicode 23 | 24 | 25 | Application 26 | false 27 | true 28 | Unicode 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | true 42 | 43 | 44 | false 45 | 46 | 47 | 48 | Level4 49 | Disabled 50 | WIN32;_CONSOLE;_DEBUG;_ITERATOR_DEBUG_LEVEL=1;%(PreprocessorDefinitions) 51 | ..\common;%(AdditionalIncludeDirectories) 52 | 4127;4201;4244;4505;4512;%(DisableSpecificWarnings) 53 | 54 | 55 | Console 56 | true 57 | 58 | 59 | 60 | 61 | Level4 62 | MaxSpeed 63 | true 64 | true 65 | WIN32;_CONSOLE;NDEBUG;%(PreprocessorDefinitions) 66 | ..\common;%(AdditionalIncludeDirectories) 67 | 4127;4201;4244;4505;4512;%(DisableSpecificWarnings) 68 | 69 | 70 | Console 71 | true 72 | true 73 | true 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | {51d9da16-25bb-43cd-b340-934b5cf8e5f2} 82 | 83 | 84 | 85 | 86 | 87 | -------------------------------------------------------------------------------- /common/INFOSection.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - INFO Section structures 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-10-25 5 | * 6 | * Nintendo DS Nitro Composer (SDAT) Specification document found at 7 | * http://www.feshrine.net/hacking/doc/nds-sdat.html 8 | */ 9 | 10 | #include "INFOSection.h" 11 | 12 | template INFORecord::INFORecord() : count(0), actualCount(0), entryOffsets(), entries() 13 | { 14 | } 15 | 16 | template void INFORecord::Read(PseudoReadFile &file, uint32_t startOffset) 17 | { 18 | this->count = file.ReadLE(); 19 | this->entryOffsets.resize(this->count); 20 | file.ReadLE(this->entryOffsets); 21 | this->entries.resize(this->count); 22 | for (uint32_t i = 0; i < this->count; ++i) 23 | if (this->entryOffsets[i]) 24 | { 25 | file.pos = startOffset + this->entryOffsets[i]; 26 | this->entries[i].Read(file); 27 | ++this->actualCount; 28 | } 29 | } 30 | 31 | template uint32_t INFORecord::Size() const 32 | { 33 | uint32_t recordSize = 4 + 4 * this->count; // count + entry offsets 34 | for (uint32_t i = 0; i < this->count; ++i) 35 | recordSize += this->entries[i].Size(); 36 | return recordSize; 37 | } 38 | 39 | template void INFORecord::FixOffsets(uint32_t startOffset) 40 | { 41 | uint32_t offset = startOffset; 42 | for (uint32_t i = 0; i < this->count; ++i) 43 | { 44 | this->entryOffsets[i] = offset; 45 | offset += this->entries[i].Size(); 46 | } 47 | } 48 | 49 | template void INFORecord::WriteHeader(PseudoWrite &file) const 50 | { 51 | file.WriteLE(this->count); 52 | file.WriteLE(this->entryOffsets); 53 | } 54 | 55 | template void INFORecord::WriteData(PseudoWrite &file) const 56 | { 57 | for (uint32_t i = 0; i < this->count; ++i) 58 | this->entries[i].Write(file); 59 | } 60 | 61 | INFOSection::INFOSection() : size(0), SEQrecord(), BANKrecord(), WAVEARCrecord(), PLAYERrecord() 62 | { 63 | memcpy(this->type, "INFO", sizeof(this->type)); 64 | memset(this->recordOffsets, 0, sizeof(this->recordOffsets)); 65 | } 66 | 67 | void INFOSection::Read(PseudoReadFile &file) 68 | { 69 | uint32_t startOfINFO = file.pos; 70 | file.ReadLE(this->type); 71 | if (!VerifyHeader(this->type, "INFO")) 72 | throw std::runtime_error("SDAT INFO Section invalid"); 73 | this->size = file.ReadLE(); 74 | file.ReadLE(this->recordOffsets); 75 | if (this->recordOffsets[REC_SEQ]) 76 | { 77 | file.pos = startOfINFO + this->recordOffsets[REC_SEQ]; 78 | this->SEQrecord.Read(file, startOfINFO); 79 | } 80 | if (this->recordOffsets[REC_BANK]) 81 | { 82 | file.pos = startOfINFO + this->recordOffsets[REC_BANK]; 83 | this->BANKrecord.Read(file, startOfINFO); 84 | } 85 | if (this->recordOffsets[REC_WAVEARC]) 86 | { 87 | file.pos = startOfINFO + this->recordOffsets[REC_WAVEARC]; 88 | this->WAVEARCrecord.Read(file, startOfINFO); 89 | } 90 | if (this->recordOffsets[REC_PLAYER]) 91 | { 92 | file.pos = startOfINFO + this->recordOffsets[REC_PLAYER]; 93 | this->PLAYERrecord.Read(file, startOfINFO); 94 | } 95 | } 96 | 97 | uint32_t INFOSection::Size() const 98 | { 99 | uint32_t sectionSize = 80; // type + size + record offsets + reserved + 4 * unused records 100 | sectionSize += this->SEQrecord.Size(); 101 | sectionSize += this->BANKrecord.Size(); 102 | sectionSize += this->WAVEARCrecord.Size(); 103 | sectionSize += this->PLAYERrecord.Size(); 104 | return sectionSize; 105 | } 106 | 107 | void INFOSection::FixOffsets() 108 | { 109 | this->recordOffsets[REC_SEQ] = 0x40; 110 | this->recordOffsets[REC_SEQARC] = this->recordOffsets[REC_SEQ] + 4 + 4 * this->SEQrecord.count; 111 | this->recordOffsets[REC_BANK] = this->recordOffsets[REC_SEQARC] + 4; 112 | this->recordOffsets[REC_WAVEARC] = this->recordOffsets[REC_BANK] + 4 + 4 * this->BANKrecord.count; 113 | this->recordOffsets[REC_PLAYER] = this->recordOffsets[REC_WAVEARC] + 4 + 4 * this->WAVEARCrecord.count; 114 | this->recordOffsets[REC_GROUP] = this->recordOffsets[REC_PLAYER] + 4 + 4 * this->PLAYERrecord.count; 115 | this->recordOffsets[REC_PLAYER2] = this->recordOffsets[REC_GROUP] + 4; 116 | this->recordOffsets[REC_STRM] = this->recordOffsets[REC_PLAYER2] + 4; 117 | uint32_t offset = this->recordOffsets[REC_STRM] + 4; 118 | this->SEQrecord.FixOffsets(offset); 119 | offset += this->SEQrecord.Size() - 4 - 4 * this->SEQrecord.count; 120 | this->BANKrecord.FixOffsets(offset); 121 | offset += this->BANKrecord.Size() - 4 - 4 * this->BANKrecord.count; 122 | this->WAVEARCrecord.FixOffsets(offset); 123 | offset += this->WAVEARCrecord.Size() - 4 - 4 * this->WAVEARCrecord.count; 124 | this->PLAYERrecord.FixOffsets(offset); 125 | } 126 | 127 | void INFOSection::Write(PseudoWrite &file) const 128 | { 129 | file.WriteLE(this->type); 130 | file.WriteLE(this->size); 131 | file.WriteLE(this->recordOffsets); 132 | uint8_t reserved[24] = { }; 133 | file.WriteLE(reserved); 134 | this->SEQrecord.WriteHeader(file); 135 | file.WriteLE(0); 136 | this->BANKrecord.WriteHeader(file); 137 | this->WAVEARCrecord.WriteHeader(file); 138 | this->PLAYERrecord.WriteHeader(file); 139 | uint32_t other[3] = { }; 140 | file.WriteLE(other); 141 | this->SEQrecord.WriteData(file); 142 | this->BANKrecord.WriteData(file); 143 | this->WAVEARCrecord.WriteData(file); 144 | this->PLAYERrecord.WriteData(file); 145 | } 146 | -------------------------------------------------------------------------------- /common/SYMBSection.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - SYMB (Symbol/Filename) Section structures 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-10-25 5 | * 6 | * Nintendo DS Nitro Composer (SDAT) Specification document found at 7 | * http://www.feshrine.net/hacking/doc/nds-sdat.html 8 | */ 9 | 10 | #include "SYMBSection.h" 11 | 12 | SYMBRecord::SYMBRecord() : count(0), entryOffsets(), entries() 13 | { 14 | } 15 | 16 | void SYMBRecord::Read(PseudoReadFile &file, uint32_t startOffset) 17 | { 18 | this->count = file.ReadLE(); 19 | this->entryOffsets.resize(this->count); 20 | file.ReadLE(entryOffsets); 21 | this->entries.resize(this->count); 22 | for (uint32_t i = 0; i < this->count; ++i) 23 | if (this->entryOffsets[i]) 24 | { 25 | file.pos = startOffset + this->entryOffsets[i]; 26 | this->entries[i] = file.ReadNullTerminatedString(); 27 | } 28 | } 29 | 30 | uint32_t SYMBRecord::Size() const 31 | { 32 | uint32_t recordSize = 4 + 4 * this->count; // count + entryOffsets 33 | for (uint32_t i = 0; i < this->count; ++i) 34 | recordSize += this->entries[i].size() + 1; 35 | return recordSize; 36 | } 37 | 38 | void SYMBRecord::FixOffsets(uint32_t startOffset) 39 | { 40 | uint32_t offset = startOffset; 41 | for (uint32_t i = 0; i < this->count; ++i) 42 | { 43 | this->entryOffsets[i] = offset; 44 | offset += this->entries[i].size() + 1; 45 | } 46 | } 47 | 48 | void SYMBRecord::WriteHeader(PseudoWrite &file) const 49 | { 50 | file.WriteLE(this->count); 51 | file.WriteLE(this->entryOffsets); 52 | } 53 | 54 | void SYMBRecord::WriteData(PseudoWrite &file) const 55 | { 56 | for (uint32_t i = 0; i < this->count; ++i) 57 | file.WriteLE(this->entries[i]); 58 | } 59 | 60 | SYMBSection::SYMBSection() : size(0), SEQrecord(), BANKrecord(), WAVEARCrecord(), PLAYERrecord() 61 | { 62 | memcpy(this->type, "SYMB", sizeof(this->type)); 63 | memset(this->recordOffsets, 0, sizeof(this->recordOffsets)); 64 | } 65 | 66 | void SYMBSection::Read(PseudoReadFile &file) 67 | { 68 | uint32_t startOfSYMB = file.pos; 69 | file.ReadLE(this->type); 70 | if (!VerifyHeader(this->type, "SYMB")) 71 | throw std::runtime_error("SDAT SYMB Section invalid"); 72 | this->size = file.ReadLE(); 73 | file.ReadLE(this->recordOffsets); 74 | if (this->recordOffsets[REC_SEQ]) 75 | { 76 | file.pos = startOfSYMB + this->recordOffsets[REC_SEQ]; 77 | this->SEQrecord.Read(file, startOfSYMB); 78 | } 79 | if (this->recordOffsets[REC_BANK]) 80 | { 81 | file.pos = startOfSYMB + this->recordOffsets[REC_BANK]; 82 | this->BANKrecord.Read(file, startOfSYMB); 83 | } 84 | if (this->recordOffsets[REC_WAVEARC]) 85 | { 86 | file.pos = startOfSYMB + this->recordOffsets[REC_WAVEARC]; 87 | this->WAVEARCrecord.Read(file, startOfSYMB); 88 | } 89 | if (this->recordOffsets[REC_PLAYER]) 90 | { 91 | file.pos = startOfSYMB + this->recordOffsets[REC_PLAYER]; 92 | this->PLAYERrecord.Read(file, startOfSYMB); 93 | } 94 | } 95 | 96 | uint32_t SYMBSection::Size() const 97 | { 98 | uint32_t sectionSize = 80; // type + size + record offsets + reserved + 4 * unused records 99 | sectionSize += this->SEQrecord.Size(); 100 | sectionSize += this->BANKrecord.Size(); 101 | sectionSize += this->WAVEARCrecord.Size(); 102 | sectionSize += this->PLAYERrecord.Size(); 103 | return sectionSize; 104 | } 105 | 106 | void SYMBSection::FixOffsets() 107 | { 108 | this->recordOffsets[REC_SEQ] = 0x40; 109 | this->recordOffsets[REC_SEQARC] = this->recordOffsets[REC_SEQ] + 4 + 4 * this->SEQrecord.count; 110 | this->recordOffsets[REC_BANK] = this->recordOffsets[REC_SEQARC] + 4; 111 | this->recordOffsets[REC_WAVEARC] = this->recordOffsets[REC_BANK] + 4 + 4 * this->BANKrecord.count; 112 | this->recordOffsets[REC_PLAYER] = this->recordOffsets[REC_WAVEARC] + 4 + 4 * this->WAVEARCrecord.count; 113 | this->recordOffsets[REC_GROUP] = this->recordOffsets[REC_PLAYER] + 4 + 4 * this->PLAYERrecord.count; 114 | this->recordOffsets[REC_PLAYER2] = this->recordOffsets[REC_GROUP] + 4; 115 | this->recordOffsets[REC_STRM] = this->recordOffsets[REC_PLAYER2] + 4; 116 | uint32_t offset = this->recordOffsets[REC_STRM] + 4; 117 | this->SEQrecord.FixOffsets(offset); 118 | offset += this->SEQrecord.Size() - 4 - 4 * this->SEQrecord.count; 119 | this->BANKrecord.FixOffsets(offset); 120 | offset += this->BANKrecord.Size() - 4 - 4 * this->BANKrecord.count; 121 | this->WAVEARCrecord.FixOffsets(offset); 122 | offset += this->WAVEARCrecord.Size() - 4 - 4 * this->WAVEARCrecord.count; 123 | this->PLAYERrecord.FixOffsets(offset); 124 | } 125 | 126 | void SYMBSection::Write(PseudoWrite &file) const 127 | { 128 | file.WriteLE(this->type); 129 | file.WriteLE(this->size); 130 | file.WriteLE(this->recordOffsets); 131 | uint8_t reserved[24] = { }; 132 | file.WriteLE(reserved); 133 | this->SEQrecord.WriteHeader(file); 134 | file.WriteLE(0); 135 | this->BANKrecord.WriteHeader(file); 136 | this->WAVEARCrecord.WriteHeader(file); 137 | this->PLAYERrecord.WriteHeader(file); 138 | uint32_t other[3] = { }; 139 | file.WriteLE(other); 140 | this->SEQrecord.WriteData(file); 141 | this->BANKrecord.WriteData(file); 142 | this->WAVEARCrecord.WriteData(file); 143 | this->PLAYERrecord.WriteData(file); 144 | uint32_t sizeMulOf4 = (this->size + 3) & ~0x03; 145 | if (this->size != sizeMulOf4) 146 | for (uint32_t i = 0; i < sizeMulOf4 - this->size; ++i) 147 | file.WriteLE(0); 148 | } 149 | -------------------------------------------------------------------------------- /2SFtoNCSF/2SFtoNCSF.vcxproj: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | 14 | {E0A4E2AC-4DD5-4721-9E0D-07221218DA68} 15 | Win32Proj 16 | My2SFtoNCSF 17 | 18 | 19 | 20 | Application 21 | true 22 | Unicode 23 | 24 | 25 | Application 26 | false 27 | true 28 | Unicode 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | true 44 | 45 | 46 | false 47 | 48 | 49 | 50 | Level4 51 | Disabled 52 | WIN32;_CONSOLE;_DEBUG;_ITERATOR_DEBUG_LEVEL=1;%(PreprocessorDefinitions) 53 | ..\common;$(zlibRootDir)\include;%(AdditionalIncludeDirectories) 54 | 4127;4201;4244;4505;4512;%(DisableSpecificWarnings) 55 | 56 | 57 | Console 58 | true 59 | $(zlibRootDir)\lib;%(AdditionalLibraryDirectories) 60 | zdll.lib;%(AdditionalDependencies) 61 | 62 | 63 | copy "$(zlibRootDir)\zlib1.dll" "$(TargetDir)" 64 | 65 | 66 | 67 | 68 | Level4 69 | MaxSpeed 70 | true 71 | true 72 | WIN32;_CONSOLE;NDEBUG;%(PreprocessorDefinitions) 73 | ..\common;$(zlibRootDir)\include;%(AdditionalIncludeDirectories) 74 | 4127;4201;4244;4505;4512;%(DisableSpecificWarnings) 75 | 76 | 77 | Console 78 | true 79 | true 80 | true 81 | $(zlibRootDir)\lib;%(AdditionalLibraryDirectories) 82 | zdll.lib;%(AdditionalDependencies) 83 | 84 | 85 | copy "$(zlibRootDir)\zlib1.dll" "$(TargetDir)" 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | {51d9da16-25bb-43cd-b340-934b5cf8e5f2} 94 | 95 | 96 | 97 | 98 | 99 | -------------------------------------------------------------------------------- /common/TimerChannel.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - Timer Channel structure 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-10-15 5 | * 6 | * Adapted from source code of FeOS Sound System 7 | * By fincs 8 | * https://github.com/fincs/FSS 9 | * 10 | * Some code/concepts from DeSmuME 11 | * http://desmume.org/ 12 | * 13 | * This has been modified in order to be able to provide timing for an SSEQ. 14 | */ 15 | 16 | #pragma once 17 | 18 | #include 19 | #include "SWAV.h" 20 | #include "TimerTrack.h" 21 | 22 | inline int Cnv_Sust(int sust) 23 | { 24 | static const int16_t lut[] = 25 | { 26 | -32768, -722, -721, -651, -601, -562, -530, -503, 27 | -480, -460, -442, -425, -410, -396, -383, -371, 28 | -360, -349, -339, -330, -321, -313, -305, -297, 29 | -289, -282, -276, -269, -263, -257, -251, -245, 30 | -239, -234, -229, -224, -219, -214, -210, -205, 31 | -201, -196, -192, -188, -184, -180, -176, -173, 32 | -169, -165, -162, -158, -155, -152, -149, -145, 33 | -142, -139, -136, -133, -130, -127, -125, -122, 34 | -119, -116, -114, -111, -109, -106, -103, -101, 35 | -99, -96, -94, -91, -89, -87, -85, -82, 36 | -80, -78, -76, -74, -72, -70, -68, -66, 37 | -64, -62, -60, -58, -56, -54, -52, -50, 38 | -49, -47, -45, -43, -42, -40, -38, -36, 39 | -35, -33, -31, -30, -28, -27, -25, -23, 40 | -22, -20, -19, -17, -16, -14, -13, -11, 41 | -10, -8, -7, -6, -4, -3, -1, 0 42 | }; 43 | 44 | if (sust & 0x80) // Supposedly invalid value... 45 | sust = 0x7F; // Use apparently correct default 46 | return lut[sust]; 47 | } 48 | 49 | enum { CS_NONE, CS_START, CS_ATTACK, CS_DECAY, CS_SUSTAIN, CS_RELEASE }; 50 | 51 | enum { CF_UPDVOL, CF_UPDPAN, CF_UPDTMR, CF_BITS }; 52 | 53 | const uint32_t ARM7_CLOCK = 33513982; 54 | 55 | inline int SOUND_FREQ(int n) { return -0x1000000 / n; } 56 | 57 | inline uint32_t SOUND_VOL(int n) { return n; } 58 | inline uint32_t SOUND_VOLDIV(int n) { return n << 8; } 59 | inline uint32_t SOUND_PAN(int n) { return n << 16; } 60 | inline uint32_t SOUND_DUTY(int n) { return n << 24; } 61 | const uint32_t SOUND_REPEAT = 1 << 27; 62 | const uint32_t SOUND_ONE_SHOT = 1 << 28; 63 | inline uint32_t SOUND_LOOP(bool a) { return a ? SOUND_REPEAT : SOUND_ONE_SHOT; } 64 | const uint32_t SOUND_FORMAT_PSG = 3 << 29; 65 | inline uint32_t SOUND_FORMAT(int n) { return n << 29; } 66 | const uint32_t SCHANNEL_ENABLE = 1 << 31; 67 | 68 | /* 69 | * This structure is meant to be similar to what is stored in the actual 70 | * Nintendo DS's sound registers. Items that were not being used by this 71 | * player have been removed, and items which help the simulated registers 72 | * have been added. 73 | */ 74 | struct NDSSoundRegister 75 | { 76 | // Control Register 77 | uint8_t volumeMul; 78 | uint8_t volumeDiv; 79 | uint8_t panning; 80 | uint8_t waveDuty; 81 | uint8_t repeatMode; 82 | uint8_t format; 83 | bool enable; 84 | 85 | // Data Source Register 86 | const SWAV *source; 87 | 88 | // Timer Register 89 | uint16_t timer; 90 | 91 | // PSG Handling, not a DS register 92 | uint16_t psgX; 93 | int16_t psgLast; 94 | uint32_t psgLastCount; 95 | 96 | // The following are taken from DeSmuME 97 | double samplePosition; 98 | double sampleIncrease; 99 | 100 | // Loopstart Register 101 | uint32_t loopStart; 102 | 103 | // Length Register 104 | uint32_t length; 105 | 106 | uint32_t totalLength; 107 | 108 | NDSSoundRegister(); 109 | 110 | void ClearControlRegister(); 111 | void SetControlRegister(uint32_t reg); 112 | }; 113 | 114 | /* 115 | * From FeOS Sound System, this is temporary storage of what will go into 116 | * the Nintendo DS sound registers. It is kept separate as the original code 117 | * from FeOS Sound System utilized this to hold data prior to passing it into 118 | * the DS's registers. 119 | */ 120 | struct TempSndReg 121 | { 122 | uint32_t CR; 123 | const SWAV *SOURCE; 124 | uint16_t TIMER; 125 | uint32_t REPEAT_POINT, LENGTH; 126 | 127 | TempSndReg(); 128 | }; 129 | 130 | struct TimerPlayer; 131 | 132 | struct TimerChannel 133 | { 134 | int8_t chnId; 135 | 136 | TempSndReg tempReg; 137 | uint8_t state; 138 | int8_t trackId; // -1 = none 139 | uint8_t prio; 140 | bool manualSweep; 141 | 142 | std::bitset flags; 143 | int8_t pan; // -64 .. 63 144 | int16_t extAmpl; 145 | 146 | int16_t velocity; 147 | int8_t extPan; 148 | uint8_t key; 149 | 150 | int ampl; // 7 fractionary bits 151 | int extTune; // in 64ths of a semitone 152 | 153 | uint8_t orgKey; 154 | 155 | uint8_t modType, modSpeed, modDepth, modRange; 156 | uint16_t modDelay, modDelayCnt, modCounter; 157 | 158 | uint32_t sweepLen, sweepCnt; 159 | int16_t sweepPitch; 160 | 161 | uint8_t attackLvl, sustainLvl; 162 | uint16_t decayRate, releaseRate; 163 | 164 | /* 165 | * These were originally global variables in FeOS Sound System, but 166 | * since they were linked to a certain channel anyways, I moved them 167 | * into this class. 168 | */ 169 | int noteLength; 170 | uint16_t vol; 171 | 172 | const TimerPlayer *ply; 173 | NDSSoundRegister reg; 174 | 175 | TimerChannel(); 176 | 177 | void UpdateVol(const TimerTrack &trk); 178 | void UpdatePan(const TimerTrack &trk); 179 | void UpdateTune(const TimerTrack &trk); 180 | void UpdateMod(const TimerTrack &trk); 181 | void UpdatePorta(const TimerTrack &trk); 182 | void Release(); 183 | void Kill(); 184 | void UpdateTrack(); 185 | void Update(); 186 | int32_t GenerateSample(); 187 | void IncrementSample(); 188 | }; 189 | -------------------------------------------------------------------------------- /SDATtoNCSF/SDATtoNCSF.vcxproj: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | 14 | {480AAF0F-0749-4C3D-A6DE-3CF632AB1B0B} 15 | Win32Proj 16 | SDATtoNCSF 17 | 18 | 19 | 20 | Application 21 | true 22 | Unicode 23 | 24 | 25 | Application 26 | false 27 | true 28 | Unicode 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | true 44 | 45 | 46 | false 47 | 48 | 49 | 50 | Level4 51 | Disabled 52 | WIN32;_CONSOLE;_DEBUG;_ITERATOR_DEBUG_LEVEL=1;%(PreprocessorDefinitions) 53 | ..\common;$(zlibRootDir)\include;%(AdditionalIncludeDirectories) 54 | 4127;4201;4244;4245;4505;4512;%(DisableSpecificWarnings) 55 | 56 | 57 | Console 58 | true 59 | $(zlibRootDir)\lib;%(AdditionalLibraryDirectories) 60 | zdll.lib;%(AdditionalDependencies) 61 | 62 | 63 | copy "$(zlibRootDir)\zlib1.dll" "$(TargetDir)" 64 | 65 | 66 | 67 | 68 | Level4 69 | MaxSpeed 70 | true 71 | true 72 | WIN32;_CONSOLE;NDEBUG;%(PreprocessorDefinitions) 73 | ..\common;$(zlibRootDir)\include;%(AdditionalIncludeDirectories) 74 | 4127;4201;4244;4245;4505;4512;%(DisableSpecificWarnings) 75 | 76 | 77 | Console 78 | true 79 | true 80 | true 81 | $(zlibRootDir)\lib;%(AdditionalLibraryDirectories) 82 | zdll.lib;%(AdditionalDependencies) 83 | 84 | 85 | copy "$(zlibRootDir)\zlib1.dll" "$(TargetDir)" 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | {51d9da16-25bb-43cd-b340-934b5cf8e5f2} 94 | 95 | 96 | 97 | 98 | 99 | -------------------------------------------------------------------------------- /NDStoNCSF/NDStoNCSF.vcxproj: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | 14 | {22504693-3E5E-4595-A3A0-34CB82F66495} 15 | Win32Proj 16 | NDStoNCSF 17 | 18 | 19 | 20 | Application 21 | true 22 | Unicode 23 | 24 | 25 | Application 26 | false 27 | true 28 | Unicode 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | true 44 | 45 | 46 | false 47 | 48 | 49 | 50 | Level4 51 | Disabled 52 | WIN32;_CONSOLE;_DEBUG;_ITERATOR_DEBUG_LEVEL=1;%(PreprocessorDefinitions) 53 | ..\common;$(zlibRootDir)\include;%(AdditionalIncludeDirectories) 54 | 4127;4201;4244;4245;4505;4512;4706;%(DisableSpecificWarnings) 55 | 56 | 57 | Console 58 | true 59 | $(zlibRootDir)\lib;%(AdditionalLibraryDirectories) 60 | zdll.lib;%(AdditionalDependencies) 61 | 62 | 63 | copy "$(zlibRootDir)\zlib1.dll" "$(TargetDir)" 64 | 65 | 66 | 67 | 68 | Level4 69 | MaxSpeed 70 | true 71 | true 72 | WIN32;_CONSOLE;NDEBUG;%(PreprocessorDefinitions) 73 | ..\common;$(zlibRootDir)\include;%(AdditionalIncludeDirectories) 74 | 4127;4201;4244;4245;4505;4512;4706;%(DisableSpecificWarnings) 75 | 76 | 77 | Console 78 | true 79 | true 80 | true 81 | $(zlibRootDir)\lib;%(AdditionalLibraryDirectories) 82 | zdll.lib;%(AdditionalDependencies) 83 | 84 | 85 | copy "$(zlibRootDir)\zlib1.dll" "$(TargetDir)" 86 | 87 | 88 | 89 | 90 | {51d9da16-25bb-43cd-b340-934b5cf8e5f2} 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | -------------------------------------------------------------------------------- /2SFTagsToNCSF/2SFTagsToNCSF.vcxproj: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | 14 | {D09C8931-0A54-4328-8093-4B083C36860C} 15 | Win32Proj 16 | My2SFTagsToNCSF 17 | 18 | 19 | 20 | Application 21 | true 22 | Unicode 23 | 24 | 25 | Application 26 | false 27 | true 28 | Unicode 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | true 44 | 45 | 46 | false 47 | 48 | 49 | 50 | Level4 51 | Disabled 52 | WIN32;_CONSOLE;_DEBUG;_ITERATOR_DEBUG_LEVEL=1;%(PreprocessorDefinitions) 53 | ..\common;$(zlibRootDir)\include;%(AdditionalIncludeDirectories) 54 | 4127;4201;4244;4245;4505;4512;4706;%(DisableSpecificWarnings) 55 | 56 | 57 | Console 58 | true 59 | $(zlibRootDir)\lib;%(AdditionalLibraryDirectories) 60 | zdll.lib;%(AdditionalDependencies) 61 | 62 | 63 | copy "$(zlibRootDir)\zlib1.dll" "$(TargetDir)" 64 | 65 | 66 | 67 | 68 | Level4 69 | MaxSpeed 70 | true 71 | true 72 | WIN32;_CONSOLE;NDEBUG;%(PreprocessorDefinitions) 73 | ..\common;$(zlibRootDir)\include;%(AdditionalIncludeDirectories) 74 | 4127;4201;4244;4245;4505;4512;4706;%(DisableSpecificWarnings) 75 | 76 | 77 | Console 78 | true 79 | true 80 | true 81 | $(zlibRootDir)\lib;%(AdditionalLibraryDirectories) 82 | zdll.lib;%(AdditionalDependencies) 83 | 84 | 85 | copy "$(zlibRootDir)\zlib1.dll" "$(TargetDir)" 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | {51d9da16-25bb-43cd-b340-934b5cf8e5f2} 94 | 95 | 96 | 97 | 98 | 99 | -------------------------------------------------------------------------------- /SDATStrip/SDATStrip.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT Strip 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-10-25 5 | * 6 | * NOTE: This version has been superceded by NDS to NCSF instead. 7 | * 8 | * Version history: 9 | * v1.0 - 2013-03-25 - Initial version 10 | * v1.1 - 2013-03-26 - Merged verbosity of SDAT stripping into the SDAT class 11 | * and removed the static Strip function from this. 12 | * - Copied NDS to NCSF's include/exclude handling to here. 13 | * v1.2 - 2014-10-25 - Save the PLAYER blocks in the SDATs as opposed to 14 | * stripping them. 15 | */ 16 | 17 | #include 18 | #include "SDAT.h" 19 | 20 | static const std::string SDATSTRIP_VERSION = "1.2"; 21 | 22 | enum { UNKNOWN, HELP, VERBOSE, FORCE, EXCLUDE, INCLUDE }; 23 | const option::Descriptor opts[] = 24 | { 25 | option::Descriptor(UNKNOWN, 0, "", "", option::Arg::None, "SDAT Strip v" + SDATSTRIP_VERSION + "\nBy Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com]\n\n" 26 | "SDAT Strip will remove all duplicated SSEQs, SBNKs, and SWARs from the input SDAT. It will also keep only SBNKs used by the remaining SSEQs and keep " 27 | "only SWARs used by the remaining SBNKs. SSARs and STRMs are not kept. Any gaps in the SYMB/INFO sections of the SDAT will also be removed.\n\n" 28 | "Usage:\n" 29 | " SDATStrip [options] [...] \n" 30 | " (More than one input file can be given, they will be merged into the output.)\n\n" 31 | "Options:"), 32 | option::Descriptor(HELP, 0, "h", "help", option::Arg::None, " --help,-h \tPrint usage and exit."), 33 | option::Descriptor(VERBOSE, 0, "v", "verbose", option::Arg::None, " --verbose,-v \tVerbose output."), 34 | option::Descriptor(FORCE, 0, "f", "force", option::Arg::None, " --force,-f \tForce overwrite of output file if it is the same as the input file."), 35 | option::Descriptor(EXCLUDE, 0, "x", "exclude", RequireArgument, 36 | " --exclude= \v -x \tExclude the given filename from the final SDAT. May use * and ? wildcards."), 37 | option::Descriptor(INCLUDE, 0, "i", "include", RequireArgument, 38 | " --include= \v -i \tInclude the given filename in the final SDAT. May use * and ? wildcards."), 39 | option::Descriptor(UNKNOWN, 0, "", "", option::Arg::None, 40 | "\nVerbose output will tell you which SSEQs, SBNKS, and SWARs will be kept and which will be removed due to duplicates." 41 | "\n\nExcluded and included files will be processed in the order they are given on the command line, later arguments overriding earlier arguments. If there is more " 42 | "than 1 SDAT given, you can exclude or include based on the SDAT by prefixing the filename with the SDAT number (1-based) and a forward slash. For example, if " 43 | "there are 2 SDATs and both contain a file called XYZ, but you only want XYZ from the 2nd SDAT, use 1/XYZ as an exclude. Wildcards before the forward slash are " 44 | "also accepted."), 45 | option::Descriptor() 46 | }; 47 | 48 | int main(int argc, char *argv[]) 49 | { 50 | argc -= argc > 0; 51 | argv += argc > 0; 52 | option::Stats stats(opts, argc, argv); 53 | std::vector options(stats.options_max), buffer(stats.buffer_max); 54 | option::Parser parse(opts, argc, argv, &options[0], &buffer[0]); 55 | 56 | if (parse.error()) 57 | return 1; 58 | 59 | if (options[HELP] || !argc || parse.nonOptionsCount() < 2) 60 | { 61 | option::printUsage(std::cout, opts); 62 | return 0; 63 | } 64 | 65 | std::vector inputFilenames; 66 | for (int i = 0, inputs = parse.nonOptionsCount() - 1; i < inputs; ++i) 67 | inputFilenames.push_back(parse.nonOption(i)); 68 | std::string outputFilename = parse.nonOption(parse.nonOptionsCount() - 1); 69 | 70 | // Get exclude and include filenames from the command line 71 | IncOrExc includesAndExcludes; 72 | for (int i = 0, optionCount = parse.optionsCount(); i < optionCount; ++i) 73 | { 74 | const option::Option &opt = buffer[i]; 75 | if (opt.index() == EXCLUDE) 76 | includesAndExcludes.push_back(KeepInfo(opt.arg, KEEP_EXCLUDE)); 77 | else if (opt.index() == INCLUDE) 78 | includesAndExcludes.push_back(KeepInfo(opt.arg, KEEP_INCLUDE)); 79 | } 80 | 81 | SDAT finalSDAT; 82 | 83 | size_t failed = 0; 84 | for (size_t i = 0, count = inputFilenames.size(); i < count; ++i) 85 | { 86 | if (inputFilenames[i] == outputFilename && !options[FORCE]) 87 | { 88 | std::cerr << "One of the inputs is the same as the output! Aborting...\n"; 89 | std::cerr << "(If you wish to force this, use -f or --force.)\n"; 90 | return 1; 91 | } 92 | 93 | try 94 | { 95 | if (!FileExists(inputFilenames[i])) 96 | throw std::runtime_error("File does not exist."); 97 | 98 | PseudoReadFile fileData; 99 | fileData.GetDataFromFile(inputFilenames[i]); 100 | 101 | SDAT sdat; 102 | sdat.Read(inputFilenames[i], fileData); 103 | finalSDAT += sdat; 104 | std::cout << "Appended " << inputFilenames[i] << " to final SDAT.\n"; 105 | } 106 | catch (const std::exception &e) 107 | { 108 | std::cerr << "Error with " << inputFilenames[i] << ": " << e.what() << "\n"; 109 | ++failed; 110 | } 111 | } 112 | 113 | if (failed == inputFilenames.size()) 114 | { 115 | std::cerr << "Unable to create " << outputFilename << ",\n all inputs failed to load.\n"; 116 | return 1; 117 | } 118 | 119 | try 120 | { 121 | finalSDAT.Strip(includesAndExcludes, !!options[VERBOSE]); 122 | 123 | std::ofstream file; 124 | file.exceptions(std::ofstream::failbit | std::ofstream::badbit); 125 | file.open(outputFilename.c_str(), std::ofstream::out | std::ofstream::binary); 126 | 127 | PseudoWrite ofile(&file); 128 | 129 | finalSDAT.Write(ofile); 130 | std::cout << "Output written to " << outputFilename << "\n"; 131 | } 132 | catch (const std::exception &e) 133 | { 134 | std::cerr << "Error with " << outputFilename << ": " << e.what() << "\n"; 135 | return 1; 136 | } 137 | 138 | return 0; 139 | } 140 | -------------------------------------------------------------------------------- /common/common.vcxproj: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | 14 | {51D9DA16-25BB-43CD-B340-934B5CF8E5F2} 15 | Win32Proj 16 | common 17 | 18 | 19 | 20 | StaticLibrary 21 | true 22 | Unicode 23 | 24 | 25 | StaticLibrary 26 | false 27 | true 28 | Unicode 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | Level4 46 | Disabled 47 | WIN32;_LIB;_SCL_SECURE_NO_WARNINGS;_DEBUG;_ITERATOR_DEBUG_LEVEL=1;%(PreprocessorDefinitions) 48 | 4127;4201;4244;4245;4505;4512;4701;4706;%(DisableSpecificWarnings) 49 | $(zlibRootDir)\include;%(AdditionalIncludeDirectories) 50 | 51 | 52 | Windows 53 | true 54 | 55 | 56 | 57 | 58 | Level4 59 | MaxSpeed 60 | true 61 | true 62 | WIN32;_LIB;_SCL_SECURE_NO_WARNINGS;NDEBUG;%(PreprocessorDefinitions) 63 | 4127;4201;4244;4245;4505;4512;4701;4706;%(DisableSpecificWarnings) 64 | $(zlibRootDir)\include;%(AdditionalIncludeDirectories) 65 | 66 | 67 | Windows 68 | true 69 | true 70 | true 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | Designer 116 | 117 | 118 | 119 | 120 | 121 | -------------------------------------------------------------------------------- /common/INFOEntry.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - INFO Entry structures 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-10-25 5 | * 6 | * Nintendo DS Nitro Composer (SDAT) Specification document found at 7 | * http://www.feshrine.net/hacking/doc/nds-sdat.html 8 | */ 9 | 10 | #include "INFOEntry.h" 11 | 12 | INFOEntry::INFOEntry() : fileData(), origFilename(""), sdatNumber("") 13 | { 14 | } 15 | 16 | INFOEntry::INFOEntry(const INFOEntry& entry) : fileData(entry.fileData), origFilename(entry.origFilename), sdatNumber(entry.sdatNumber) 17 | { 18 | } 19 | 20 | INFOEntry &INFOEntry::operator=(const INFOEntry &entry) 21 | { 22 | if (this != &entry) 23 | { 24 | this->fileData = entry.fileData; 25 | this->origFilename = entry.origFilename; 26 | this->sdatNumber = entry.sdatNumber; 27 | } 28 | return *this; 29 | } 30 | 31 | std::string INFOEntry::FullFilename(bool multipleSDATs) const 32 | { 33 | std::string filename = this->origFilename; 34 | if (multipleSDATs) 35 | filename = this->sdatNumber + "/" + filename; 36 | return filename; 37 | } 38 | 39 | INFOEntrySEQ::INFOEntrySEQ() : INFOEntry(), fileID(0), unknown(0), bank(0), vol(0), cpr(0), ppr(0), ply(0), sseq(nullptr) 40 | { 41 | memset(this->unknown2, 0, sizeof(this->unknown2)); 42 | } 43 | 44 | INFOEntrySEQ::INFOEntrySEQ(const INFOEntrySEQ &entry) : INFOEntry(entry), fileID(entry.fileID), unknown(entry.unknown), bank(entry.bank), vol(entry.vol), cpr(entry.cpr), 45 | ppr(entry.ppr), ply(entry.ply), sseq(entry.sseq) 46 | { 47 | memcpy(this->unknown2, entry.unknown2, sizeof(this->unknown2)); 48 | } 49 | 50 | INFOEntrySEQ &INFOEntrySEQ::operator=(const INFOEntrySEQ &entry) 51 | { 52 | if (this != &entry) 53 | { 54 | INFOEntry::operator=(entry); 55 | this->fileID = entry.fileID; 56 | this->unknown = entry.unknown; 57 | this->bank = entry.bank; 58 | this->vol = entry.vol; 59 | this->cpr = entry.cpr; 60 | this->ppr = entry.ppr; 61 | this->ply = entry.ply; 62 | memcpy(this->unknown2, entry.unknown2, sizeof(this->unknown2)); 63 | this->sseq = entry.sseq; 64 | } 65 | return *this; 66 | } 67 | 68 | void INFOEntrySEQ::Read(PseudoReadFile &file) 69 | { 70 | this->fileID = file.ReadLE(); 71 | this->unknown = file.ReadLE(); 72 | this->bank = file.ReadLE(); 73 | this->vol = file.ReadLE(); 74 | this->cpr = file.ReadLE(); 75 | this->ppr = file.ReadLE(); 76 | this->ply = file.ReadLE(); 77 | file.ReadLE(this->unknown2); 78 | } 79 | 80 | uint32_t INFOEntrySEQ::Size() const 81 | { 82 | return 12; 83 | } 84 | 85 | void INFOEntrySEQ::Write(PseudoWrite &file) const 86 | { 87 | file.WriteLE(this->fileID); 88 | file.WriteLE(this->unknown); 89 | file.WriteLE(this->bank); 90 | file.WriteLE(this->vol); 91 | file.WriteLE(this->cpr); 92 | file.WriteLE(this->ppr); 93 | file.WriteLE(this->ply); 94 | file.WriteLE(this->unknown2); 95 | } 96 | 97 | INFOEntryBANK::INFOEntryBANK() : INFOEntry(), fileID(0), unknown(0), sbnk(nullptr) 98 | { 99 | memset(this->waveArc, 0, sizeof(this->waveArc)); 100 | } 101 | 102 | INFOEntryBANK::INFOEntryBANK(const INFOEntryBANK &entry) : INFOEntry(entry), fileID(entry.fileID), unknown(entry.unknown), sbnk(entry.sbnk) 103 | { 104 | memcpy(this->waveArc, entry.waveArc, sizeof(this->waveArc)); 105 | } 106 | 107 | INFOEntryBANK &INFOEntryBANK::operator=(const INFOEntryBANK &entry) 108 | { 109 | if (this != &entry) 110 | { 111 | INFOEntry::operator=(entry); 112 | this->fileID = entry.fileID; 113 | this->unknown = entry.unknown; 114 | memcpy(this->waveArc, entry.waveArc, sizeof(this->waveArc)); 115 | this->sbnk = entry.sbnk; 116 | } 117 | return *this; 118 | } 119 | 120 | void INFOEntryBANK::Read(PseudoReadFile &file) 121 | { 122 | this->fileID = file.ReadLE(); 123 | this->unknown = file.ReadLE(); 124 | file.ReadLE(this->waveArc); 125 | } 126 | 127 | uint32_t INFOEntryBANK::Size() const 128 | { 129 | return 12; 130 | } 131 | 132 | void INFOEntryBANK::Write(PseudoWrite &file) const 133 | { 134 | file.WriteLE(this->fileID); 135 | file.WriteLE(this->unknown); 136 | file.WriteLE(this->waveArc); 137 | } 138 | 139 | INFOEntryWAVEARC::INFOEntryWAVEARC() : INFOEntry(), fileID(0), unknown(0), swar(nullptr) 140 | { 141 | } 142 | 143 | INFOEntryWAVEARC::INFOEntryWAVEARC(const INFOEntryWAVEARC &entry) : INFOEntry(entry), fileID(entry.fileID), unknown(entry.unknown), swar(entry.swar) 144 | { 145 | } 146 | 147 | INFOEntryWAVEARC &INFOEntryWAVEARC::operator=(const INFOEntryWAVEARC &entry) 148 | { 149 | if (this != &entry) 150 | { 151 | INFOEntry::operator=(entry); 152 | this->fileID = entry.fileID; 153 | this->unknown = entry.unknown; 154 | this->swar = entry.swar; 155 | } 156 | return *this; 157 | } 158 | 159 | void INFOEntryWAVEARC::Read(PseudoReadFile &file) 160 | { 161 | this->fileID = file.ReadLE(); 162 | this->unknown = file.ReadLE(); 163 | } 164 | 165 | uint32_t INFOEntryWAVEARC::Size() const 166 | { 167 | return 4; 168 | } 169 | 170 | void INFOEntryWAVEARC::Write(PseudoWrite &file) const 171 | { 172 | file.WriteLE(this->fileID); 173 | file.WriteLE(this->unknown); 174 | } 175 | 176 | INFOEntryPLAYER::INFOEntryPLAYER() : INFOEntry(), maxSeqs(0), channelMask(0), heapSize(0) 177 | { 178 | } 179 | 180 | INFOEntryPLAYER::INFOEntryPLAYER(const INFOEntryPLAYER &entry) : INFOEntry(entry), maxSeqs(entry.maxSeqs), channelMask(entry.channelMask), heapSize(entry.heapSize) 181 | { 182 | } 183 | 184 | INFOEntryPLAYER &INFOEntryPLAYER::operator=(const INFOEntryPLAYER &entry) 185 | { 186 | if (this != &entry) 187 | { 188 | INFOEntry::operator=(entry); 189 | this->maxSeqs = entry.maxSeqs; 190 | this->channelMask = entry.channelMask; 191 | this->heapSize = entry.heapSize; 192 | } 193 | return *this; 194 | } 195 | 196 | void INFOEntryPLAYER::Read(PseudoReadFile &file) 197 | { 198 | this->maxSeqs = file.ReadLE(); 199 | this->channelMask = file.ReadLE(); 200 | this->heapSize = file.ReadLE(); 201 | } 202 | 203 | uint32_t INFOEntryPLAYER::Size() const 204 | { 205 | return 8; 206 | } 207 | 208 | void INFOEntryPLAYER::Write(PseudoWrite &file) const 209 | { 210 | file.WriteLE(this->maxSeqs); 211 | file.WriteLE(this->channelMask); 212 | file.WriteLE(this->heapSize); 213 | } 214 | -------------------------------------------------------------------------------- /SDATtoNCSF/SDATtoNCSF.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT to NCSF 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-12-08 5 | * 6 | * NOTE: This version has been superceded by NDS to NCSF instead. It also lacks 7 | * some of the features that are in NDS to NCSF. 8 | * 9 | * Version history: 10 | * v1.0 - 2013-03-25 - Initial version 11 | * v1.1 - 2013-03-28 - Made timing to be on by default, with 2 loops. 12 | * - Added options to change the fade times. 13 | * v1.2 - 2014-10-15 - Improved timing system by implementing the random, 14 | * variable, and conditional SSEQ commands. 15 | * v1.3 - 2014-12-08 - Minor cleanup of PseudoReadFile to not use a pointer. 16 | */ 17 | 18 | #include "NCSF.h" 19 | 20 | static const std::string SDATTONCSF_VERSION = "1.3"; 21 | 22 | enum { UNKNOWN, HELP, VERBOSE, TIME, FADELOOP, FADEONESHOT }; 23 | const option::Descriptor opts[] = 24 | { 25 | option::Descriptor(UNKNOWN, 0, "", "", option::Arg::None, "SDAT to NCSF v" + SDATTONCSF_VERSION + "\nBy Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com]\n\n" 26 | "SDAT to NCSF will take the incoming SDAT and create a series of NCSF files. If there is only a single SSEQ within the SDAT, then there will be a " 27 | "single NCSF file. Otherwise, there will be an NCSFLIB and multiple MININCSFs.\n\n" 28 | "Usage:\n" 29 | " SDATtoNCSF [options] \n\n" 30 | "Options:"), 31 | option::Descriptor(HELP, 0, "h", "help", option::Arg::None, " --help,-h \tPrint usage and exit."), 32 | option::Descriptor(VERBOSE, 0, "v", "verbose", option::Arg::None, " --verbose,-v \tVerbose output."), 33 | option::Descriptor(TIME, 0, "t", "time", RequireNumericArgument, 34 | " --time,-t \tCalculate time on each track to the number of loops given. Defaults to 2 loops. 0 will disable timing."), 35 | option::Descriptor(FADELOOP, 0, "l", "fade-loop", RequireNumericArgument, " --fade-loop,-l \tSet the fade time for looping tracks, in seconds, defaults to 10."), 36 | option::Descriptor(FADEONESHOT, 0, "o", "fade-one-shot", RequireNumericArgument, " --fade-one-shot,-o \tSet the fade time for one-shot tracks, in seconds, defaults to 0."), 37 | option::Descriptor(UNKNOWN, 0, "", "", option::Arg::None, "\nVerbose output will output the NCSFs created.\n\nTiming uses code based on FeOS Sound System by fincs."), 38 | option::Descriptor() 39 | }; 40 | 41 | int main(int argc, char *argv[]) 42 | { 43 | // Options parsing 44 | argc -= argc > 0; 45 | argv += argc > 0; 46 | option::Stats stats(opts, argc, argv); 47 | std::vector options(stats.options_max), buffer(stats.buffer_max); 48 | option::Parser parse(opts, argc, argv, &options[0], &buffer[0]); 49 | 50 | if (parse.error()) 51 | return 1; 52 | 53 | if (options[HELP] || !argc || parse.nonOptionsCount() < 1) 54 | { 55 | option::printUsage(std::cout, opts); 56 | return 0; 57 | } 58 | 59 | uint32_t numberOfLoops = 2; 60 | if (options[TIME]) 61 | numberOfLoops = convertTo(options[TIME].arg); 62 | uint32_t fadeLoop = 10; 63 | if (options[FADELOOP]) 64 | fadeLoop = convertTo(options[FADELOOP].arg); 65 | uint32_t fadeOneShot = 1; 66 | if (options[FADEONESHOT]) 67 | fadeOneShot = convertTo(options[FADEONESHOT].arg); 68 | 69 | try 70 | { 71 | // Read SDAT 72 | std::string sdatFilename = parse.nonOption(0); 73 | std::replace(sdatFilename.begin(), sdatFilename.end(), '\\', '/'); 74 | 75 | if (!FileExists(sdatFilename)) 76 | throw std::runtime_error("File " + sdatFilename + " does not exist."); 77 | 78 | PseudoReadFile fileData; 79 | fileData.GetDataFromFile(sdatFilename); 80 | 81 | // Create output directory 82 | std::string dirName = sdatFilename; 83 | size_t dot = dirName.rfind('.'); 84 | dirName = dirName.substr(0, dot) + "_SDATtoNCSF"; 85 | 86 | if (!DirExists(dirName)) 87 | MakeDir(dirName); 88 | if (options[VERBOSE]) 89 | std::cout << "Output will go to " << dirName << "\n"; 90 | 91 | // Parse SDAT 92 | SDAT sdat; 93 | sdat.Read(sdatFilename, fileData); 94 | 95 | if (sdat.infoSection.SEQrecord.entries.size() == 1) 96 | { 97 | // Make single NCSF 98 | TagList tags; 99 | tags["ncsfby"] = "SDAT to NCSF"; 100 | 101 | std::string ncsfFilename = sdat.infoSection.SEQrecord.entries[0].sseq->filename + ".ncsf"; 102 | auto reservedData = IntToLEVector(0); 103 | 104 | if (numberOfLoops) 105 | GetTime(ncsfFilename, &sdat, sdat.infoSection.SEQrecord.entries[0].sseq, tags, !!options[VERBOSE], numberOfLoops, fadeLoop, fadeOneShot); 106 | 107 | MakeNCSF(dirName + "/" + ncsfFilename, reservedData, fileData.data, tags.GetTags()); 108 | if (options[VERBOSE]) 109 | std::cout << "Created " << ncsfFilename << "\n"; 110 | } 111 | else 112 | { 113 | // Make NCSFLIB 114 | std::string ncsflibFilename = GetFilenameFromPath(sdatFilename); 115 | size_t libdot = ncsflibFilename.rfind('.'); 116 | ncsflibFilename = ncsflibFilename.substr(0, libdot) + ".ncsflib"; 117 | MakeNCSF(dirName + "/" + ncsflibFilename, std::vector(), fileData.data); 118 | if (options[VERBOSE]) 119 | std::cout << "Created " << ncsflibFilename << "\n"; 120 | 121 | // Make multiple MININCSFs 122 | TagList tags; 123 | tags["_lib"] = ncsflibFilename; 124 | tags["ncsfby"] = "SDAT to NCSF"; 125 | 126 | for (size_t i = 0; i < sdat.infoSection.SEQrecord.count; ++i) 127 | { 128 | if (!sdat.infoSection.SEQrecord.entryOffsets[i]) 129 | continue; 130 | std::string minincsfFilename = sdat.infoSection.SEQrecord.entries[i].sseq->filename + ".minincsf"; 131 | auto reservedData = IntToLEVector(i); 132 | 133 | TagList thisTags = tags; 134 | thisTags["origFilename"] = sdat.infoSection.SEQrecord.entries[i].sseq->origFilename; 135 | 136 | if (numberOfLoops) 137 | GetTime(minincsfFilename, &sdat, sdat.infoSection.SEQrecord.entries[i].sseq, thisTags, !!options[VERBOSE], numberOfLoops, fadeLoop, fadeOneShot); 138 | 139 | MakeNCSF(dirName + "/" + minincsfFilename, reservedData, std::vector(), thisTags.GetTags()); 140 | if (options[VERBOSE]) 141 | std::cout << "Created " << minincsfFilename << "\n"; 142 | } 143 | } 144 | } 145 | catch (const std::exception &e) 146 | { 147 | std::cerr << "Error: " << e.what() << "\n"; 148 | return 1; 149 | } 150 | 151 | return 0; 152 | } 153 | -------------------------------------------------------------------------------- /README.txt: -------------------------------------------------------------------------------- 1 | PLEASE NOTE: This entire repository is outdated, please use the tools at 2 | https://github.com/CyberBotX/NCSF instead. 3 | 4 | NCSF/SDAT Utilities 5 | By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 6 | 7 | (If you need to email me, please include NCSF in the subject line.) 8 | 9 | Special thanks to fincs for FeOS Sound System, as well as the DeSmuME 10 | team for their open-source Nintendo DS emulator. 11 | 12 | 2SF Tags to NCSF Version History 13 | -------------------------------- 14 | v1.0 - 2013-03-30 - Initial Version 15 | v1.1 - 2012-03-30 - Added option to rename the NCSFs, requested by Knurek. 16 | v1.2 - 2012-04-10 - Made it so a file is not overwritten when renaming if 17 | a duplicate is found. 18 | v1.3 - 2012-12-08 - Minor cleanup of PseudoReadFile to not use a pointer. 19 | 20 | 2SF to NCSF Version History 21 | --------------------------- 22 | v1.0 - 2014-10-29 - Initial Version 23 | v1.1 - 2012-12-08 - Minor cleanup of PseudoReadFile to not use a pointer. 24 | 25 | NDS to NCSF Version History 26 | --------------------------- 27 | v1.0 - 2013-03-25 - Initial Version 28 | v1.1 - 2013-03-26 - Merged SDAT Strip's verbosity into the SDAT class' 29 | Strip function. 30 | - Modified how excluded SSEQs are handled when stripping. 31 | - Corrected handling of files within an existing SDAT. 32 | v1.2 - 2013-03-28 - Made timing to be on by default, with 2 loops. 33 | - Added options to change the fade times. 34 | v1.3 - 2013-03-30 - Only remove files from the destination directory that 35 | were created by this utility, instead of all files. 36 | - Slightly better file checking when copying from an 37 | existing SDAT, will check by data only if checking by 38 | filename and data doesn't give any results. 39 | v1.4 - 2014-10-15 - Improved timing system by implementing the random, 40 | variable, and conditional SSEQ commands. 41 | v1.5 - 2014-10-26 - Save the PLAYER blocks in the SDATs as opposed to 42 | stripping them. 43 | - Detect if the NDS ROM is a DSi ROM and set the prefix 44 | of the NCSFLIB accordingly. 45 | - Fixed removal of output directory if there are no 46 | SSEQs found. 47 | v1.6 - 2014-11-07 - Added functionality for an SMAP-like file to be used 48 | to include/exclude SSEQs. 49 | v1.7 - 2014-12-09 - Added functionality to strip the SBNKs and SWARs of 50 | the SDAT prior to saving it. 51 | - Minor cleanup of PseudoReadFile to not use a pointer. 52 | 53 | SDAT Strip Version History 54 | -------------------------- 55 | v1.0 - 2013-03-25 - Initial Version 56 | v1.1 - 2013-03-26 - Merged verbosity of SDAT stripping into the SDAT class 57 | and removed the static Strip function from this. 58 | - Copied NDS to NCSF's include/exclude handling to here. 59 | v1.2 - 2014-10-25 - Save the PLAYER blocks in the SDATs as opposed to 60 | stripping them. 61 | 62 | SDAT to NCSF Version History 63 | ---------------------------- 64 | v1.0 - 2013-03-25 - Initial Version 65 | v1.1 - 2013-03-28 - Made timing to be on by default, with 2 loops. 66 | - Added options to change the fade times. 67 | v1.2 - 2014-10-15 - Improved timing system by implementing the random, 68 | variable, and conditional SSEQ commands. 69 | v1.3 - 2014-12-08 - Minor cleanup of PseudoReadFile to not use a pointer. 70 | 71 | These utilities are used to work with SDAT files from Nintendo DS ROMs. SDATs are 72 | created through the Nintendo Nitro/TWL SDK for the DS. NCSF is a PSF-style music format 73 | that uses the SDAT as it's "program". 74 | 75 | Contains: 76 | * 2SF Tags to NCSF v1.3 - A utility to copy tags from a 2SF set into an NCSF set. 77 | * 2SF to NCSF v1.1 - A utility to take a 2SF set and create an NCSF set out of it. 78 | * NDS to NCSF v1.7 - A utility to take a Nintendo DS ROM and create an NCSF set out of it. 79 | * SDAT Strip v1.2 - A utility to take an SDAT and strip it of all unneccesary items. 80 | (NOTE: Superceded by NDS to NCSF.) 81 | * SDAT to NCSF v1.3 - A utility to take an SDAT and create an NCSF out of it. 82 | (NOTE: Superceded by NDS to NCSF.) 83 | * zlib DLL v1.2.8 - Required by 2SF Tags to NCSF, 2SF to NCSF, NDS to NCSF, and SDAT to NCSF. 84 | 85 | WINDOWS 86 | ------- 87 | For Windows, the binaries are included (these are command-line tools). If you do not 88 | already have it, you will need the Microsoft Visual C++ 2010 Runtime installed. You 89 | can obtain it here: 90 | 91 | http://www.microsoft.com/en-us/download/details.aspx?id=5555 92 | 93 | (NOTE: You will usually not require this runtime if you have Visual Studio installed, 94 | or if you plan on installing Visual Studio. But you will need it if you do not have 95 | Visual Studio installed.) 96 | 97 | If you wish to compile these binaries under Windows yourself, you can do so with 98 | Microsoft Visual Studio. You must use version 2010 or later. If you do not have 99 | Microsoft Visual Studio, you can obtain the Express version of Microsoft Visual C++ 100 | from Microsoft, at: 101 | 102 | http://www.microsoft.com/visualstudio/eng/downloads 103 | 104 | You may use any Express version that is 2010 or later. Once you have Visual Studio 105 | installed, you need to open the SDATStuff.sln file. If using a version of Visual 106 | Studio later than 2010, you may be asked to upgrade the solution. 107 | 108 | Of note, the utilities will not compile out of the box immediately. The zlib library 109 | is also required. zlib can be obtained from here: 110 | 111 | http://www.zlib.net/ 112 | 113 | You need to download the "compiled DLL" version. 114 | 115 | Once you have this, you need to modify the value of zlibRootDir in common\common.props. 116 | Just replace ZLIBFIXME with the directory to which you extracted the above file. Once 117 | this has been done, you can compile the solution. 118 | 119 | UNIX-LIKE OPERATING SYSTEMS 120 | --------------------------- 121 | For Unix-like operating systems, you will need to compile the utilities yourself. 122 | You will need a compiler that supports C++11, at the very least it's auto keyword 123 | and the new return value syntax. For GCC, version 4.6 and later will work. For 124 | Clang, nearly any version will work. You will also need the GNU version of Make. 125 | This will usually be installed as either "make" or "gmake" depending. To build 126 | the utilities, simply run "make" or "gmake" from this directory. 127 | 128 | -------------------------------------------------------------------------------- /common/SBNK.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SSEQ Player - SDAT SBNK (Sound Bank) structures 3 | * By Naram Qashat (CyberBotX) 4 | * Last modification on 2014-12-08 5 | * 6 | * Nintendo DS Nitro Composer (SDAT) Specification document found at 7 | * http://www.feshrine.net/hacking/doc/nds-sdat.html 8 | */ 9 | 10 | #include "SBNK.h" 11 | #include "SDAT.h" 12 | 13 | SBNKInstrumentRange::SBNKInstrumentRange(uint8_t lowerNote, uint8_t upperNote, int recordType) : lowNote(lowerNote), highNote(upperNote), 14 | record(recordType), swav(0), swar(0), noteNumber(0), attackRate(0), decayRate(0), sustainLevel(0), releaseRate(0), pan(0) 15 | { 16 | } 17 | 18 | void SBNKInstrumentRange::Read(PseudoReadFile &file) 19 | { 20 | this->swav = file.ReadLE(); 21 | this->swar = file.ReadLE(); 22 | this->noteNumber = file.ReadLE(); 23 | this->attackRate = file.ReadLE(); 24 | this->decayRate = file.ReadLE(); 25 | this->sustainLevel = file.ReadLE(); 26 | this->releaseRate = file.ReadLE(); 27 | this->pan = file.ReadLE(); 28 | } 29 | 30 | void SBNKInstrumentRange::Write(PseudoWrite &file) const 31 | { 32 | file.WriteLE(this->swav); 33 | file.WriteLE(this->swar); 34 | file.WriteLE(this->noteNumber); 35 | file.WriteLE(this->attackRate); 36 | file.WriteLE(this->decayRate); 37 | file.WriteLE(this->sustainLevel); 38 | file.WriteLE(this->releaseRate); 39 | file.WriteLE(this->pan); 40 | } 41 | 42 | SBNKInstrument::SBNKInstrument() : record(0), ranges() 43 | { 44 | } 45 | 46 | void SBNKInstrument::Read(PseudoReadFile &file, uint32_t startOffset) 47 | { 48 | this->record = file.ReadLE(); 49 | this->offset = file.ReadLE(); 50 | this->unknown = file.ReadLE(); 51 | uint32_t endOfInst = file.pos; 52 | file.pos = startOffset + this->offset; 53 | if (this->record) 54 | { 55 | if (this->record == 16) 56 | { 57 | uint8_t lowNote = file.ReadLE(); 58 | uint8_t highNote = file.ReadLE(); 59 | uint8_t num = highNote - lowNote + 1; 60 | for (uint8_t i = 0; i < num; ++i) 61 | { 62 | uint16_t thisRecord = file.ReadLE(); 63 | auto range = SBNKInstrumentRange(lowNote + i, lowNote + i, thisRecord); 64 | range.Read(file); 65 | this->ranges.push_back(range); 66 | } 67 | } 68 | else if (this->record == 17) 69 | { 70 | uint8_t thisRanges[8]; 71 | file.ReadLE(thisRanges); 72 | uint8_t i = 0; 73 | while (i < 8 && thisRanges[i]) 74 | { 75 | uint16_t thisRecord = file.ReadLE(); 76 | uint8_t lowNote = i ? thisRanges[i - 1] + 1 : 0; 77 | uint8_t highNote = thisRanges[i]; 78 | auto range = SBNKInstrumentRange(lowNote, highNote, thisRecord); 79 | range.Read(file); 80 | this->ranges.push_back(range); 81 | ++i; 82 | } 83 | } 84 | else 85 | { 86 | auto range = SBNKInstrumentRange(0, 127, this->record); 87 | range.Read(file); 88 | this->ranges.push_back(range); 89 | } 90 | } 91 | file.pos = endOfInst; 92 | } 93 | 94 | uint32_t SBNKInstrument::Size() const 95 | { 96 | if (this->record) 97 | { 98 | // All include 4 bytes for record type, offset, and unknown byte 99 | if (this->record == 16) 100 | return 6 + 12 * this->ranges.size(); // lowNote + highNote + instrument ranges * 12 (2 for record type, 10 for instrument range) 101 | else if (this->record == 17) 102 | return 12 + 12 * this->ranges.size(); // 8 bytes for ranges + instrument ranges * 12 (2 for record type, 10 for instrument range) 103 | else 104 | return 14; // 10 for instrument range 105 | } 106 | else 107 | return 4; 108 | } 109 | 110 | uint16_t SBNKInstrument::FixOffset(uint16_t newOffset) 111 | { 112 | this->offset = newOffset; 113 | return this->Size() - 4; 114 | } 115 | 116 | void SBNKInstrument::WriteHeader(PseudoWrite &file) const 117 | { 118 | file.WriteLE(this->record); 119 | file.WriteLE(this->offset); 120 | file.WriteLE(this->unknown); 121 | } 122 | 123 | void SBNKInstrument::WriteData(PseudoWrite &file) const 124 | { 125 | if (this->record) 126 | { 127 | if (this->record == 16) 128 | { 129 | uint8_t lowNote = this->ranges.begin()->lowNote; 130 | uint8_t highNote = this->ranges.rbegin()->lowNote; 131 | uint8_t num = highNote - lowNote + 1; 132 | file.WriteLE(lowNote); 133 | file.WriteLE(highNote); 134 | for (uint8_t i = 0; i < num; ++i) 135 | { 136 | const auto &range = this->ranges[i]; 137 | file.WriteLE(range.record); 138 | range.Write(file); 139 | } 140 | } 141 | else if (this->record == 17) 142 | { 143 | uint8_t actualRanges = this->ranges.size(); 144 | uint8_t i = 0; 145 | for (; i < actualRanges; ++i) 146 | file.WriteLE(this->ranges[i].highNote); 147 | for (; i < 8; ++i) 148 | file.WriteLE(0); 149 | for (i = 0; i < actualRanges; ++i) 150 | { 151 | const auto &range = this->ranges[i]; 152 | file.WriteLE(range.record); 153 | range.Write(file); 154 | } 155 | } 156 | else 157 | this->ranges[0].Write(file); 158 | } 159 | } 160 | 161 | SBNK::SBNK(const std::string &fn) : filename(fn), header(), count(0), instruments(), entryNumber(-1) 162 | { 163 | } 164 | 165 | void SBNK::Read(PseudoReadFile &file) 166 | { 167 | uint32_t startOfSBNK = file.pos; 168 | this->header.Read(file); 169 | try 170 | { 171 | this->header.Verify("SBNK", 0x0100FEFF); 172 | } 173 | catch (const std::exception &) 174 | { 175 | if (SDAT::failOnMissingFiles) 176 | throw; 177 | else 178 | return; 179 | } 180 | int8_t type[4]; 181 | file.ReadLE(type); 182 | if (!VerifyHeader(type, "DATA")) 183 | throw std::runtime_error("SBNK DATA structure invalid"); 184 | file.ReadLE(); // size 185 | uint32_t reserved[8]; 186 | file.ReadLE(reserved); 187 | this->count = file.ReadLE(); 188 | this->instruments.resize(this->count); 189 | for (uint32_t i = 0; i < this->count; ++i) 190 | this->instruments[i].Read(file, startOfSBNK); 191 | } 192 | 193 | uint32_t SBNK::Size() const 194 | { 195 | return 16 + ((this->DataSize() + 3) & ~0x03); 196 | } 197 | 198 | // This excludes the size of the SBNK header (which is a 16 byte standard NDS header) 199 | // This also isn't padded to the nearest multiple of 4 200 | uint32_t SBNK::DataSize() const 201 | { 202 | uint32_t fileSize = 44; // DATA + size + 8 32-bit reserved bytes + count 203 | for (uint32_t i = 0; i < this->count; ++i) 204 | fileSize += this->instruments[i].Size(); 205 | return fileSize; 206 | } 207 | 208 | void SBNK::FixOffsets() 209 | { 210 | uint16_t offset = 0x3C + 4 * this->count; 211 | for (uint32_t i = 0; i < this->count; ++i) 212 | offset += this->instruments[i].FixOffset(offset); 213 | } 214 | 215 | void SBNK::Write(PseudoWrite &file) const 216 | { 217 | this->header.Write(file); 218 | file.WriteLE("DATA", 4); 219 | uint32_t size = this->DataSize(); 220 | uint32_t sizeMulOf4 = (size + 3) & ~0x03; 221 | file.WriteLE(sizeMulOf4); 222 | uint32_t reserved[8] = { }; 223 | file.WriteLE(reserved); 224 | file.WriteLE(this->count); 225 | for (uint32_t i = 0; i < this->count; ++i) 226 | this->instruments[i].WriteHeader(file); 227 | for (uint32_t i = 0; i < this->count; ++i) 228 | this->instruments[i].WriteData(file); 229 | if (size != sizeMulOf4) 230 | for (uint32_t i = 0; i < sizeMulOf4 - size; ++i) 231 | file.WriteLE(0); 232 | } 233 | -------------------------------------------------------------------------------- /common/TimerPlayer.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - Timer Player structure 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-12-08 5 | * 6 | * Adapted from source code of FeOS Sound System 7 | * By fincs 8 | * https://github.com/fincs/FSS 9 | * 10 | * This has been modified in order to be able to provide timing for an SSEQ. 11 | */ 12 | 13 | #include "TimerPlayer.h" 14 | 15 | #undef min 16 | #undef max 17 | 18 | TimerPlayer::TimerPlayer() : prio(0), nTracks(0), tempo(120), tempoCount(0), tempoRate(0x100), masterVol(0), sseqVol(0), trailingSilenceSeconds(0), sseq(nullptr), sbnk(nullptr), 19 | seconds(0), 20 | #ifdef _WIN32 21 | mutex(CreateMutex(nullptr, false, nullptr)), thread(nullptr), 22 | #else 23 | mutex(PTHREAD_MUTEX_INITIALIZER), thread(0), 24 | #endif 25 | maxSeconds(0), loops(0), doLength(false), doNotes(false), length() 26 | { 27 | memset(this->swar, 0, sizeof(this->swar)); 28 | for (int i = 0; i < 16; ++i) 29 | { 30 | this->channels[i].chnId = i; 31 | this->channels[i].ply = this; 32 | } 33 | memset(this->variables, -1, sizeof(this->variables)); 34 | } 35 | 36 | // Original FSS Function: Player_Setup 37 | void TimerPlayer::Setup(const SSEQ *sseqToPlay, const std::string &filename) 38 | { 39 | this->sseq = sseqToPlay; 40 | 41 | PseudoReadFile file(filename); 42 | file.GetDataFromVector(this->sseq->data.begin(), this->sseq->data.end()); 43 | 44 | this->tracks[0].Init(0, this, file); 45 | 46 | this->nTracks = 1; 47 | 48 | this->tracks[0].file = file; 49 | this->tracks[0].startPos = file.pos; 50 | } 51 | 52 | // Original FSS Function: Chn_Alloc 53 | int TimerPlayer::ChannelAlloc(int type, int priority) 54 | { 55 | static const uint8_t pcmChnArray[] = { 4, 5, 6, 7, 2, 0, 3, 1, 8, 9, 10, 11, 14, 12, 15, 13 }; 56 | static const uint8_t psgChnArray[] = { 8, 9, 10, 11, 12, 13 }; 57 | static const uint8_t noiseChnArray[] = { 14, 15 }; 58 | static const uint8_t arraySizes[] = { sizeof(pcmChnArray), sizeof(psgChnArray), sizeof(noiseChnArray) }; 59 | static const uint8_t *const arrayArray[] = { pcmChnArray, psgChnArray, noiseChnArray }; 60 | 61 | const uint8_t *const chnArray = arrayArray[type]; 62 | int arraySize = arraySizes[type]; 63 | 64 | int curChnNo = -1; 65 | for (int i = 0; i < arraySize; ++i) 66 | { 67 | int thisChnNo = chnArray[i]; 68 | TimerChannel &thisChn = this->channels[thisChnNo]; 69 | TimerChannel &curChn = this->channels[curChnNo]; 70 | if (curChnNo != -1 && thisChn.prio >= curChn.prio) 71 | { 72 | if (thisChn.prio != curChn.prio) 73 | continue; 74 | if (curChn.vol <= thisChn.vol) 75 | continue; 76 | } 77 | curChnNo = thisChnNo; 78 | } 79 | 80 | if (curChnNo == -1 || priority < this->channels[curChnNo].prio) 81 | return -1; 82 | this->channels[curChnNo].noteLength = -1; 83 | this->channels[curChnNo].vol = 0x7FF; 84 | return curChnNo; 85 | } 86 | 87 | const double SecondsPerClockCycle = 64.0 * 2728.0 / ARM7_CLOCK; 88 | 89 | // Original FSS Function: Player_Run 90 | void TimerPlayer::Run() 91 | { 92 | while (this->tempoCount > 240) 93 | { 94 | this->tempoCount -= 240; 95 | for (uint8_t i = 0; i < this->nTracks; ++i) 96 | { 97 | this->tracks[i].Run(); 98 | 99 | if (this->tracks[i].hitLoop) 100 | { 101 | this->trackTimes[i].push_back(Time(this->seconds, LOOP)); 102 | this->tracks[i].hitLoop = false; 103 | } 104 | if (this->tracks[i].hitEnd) 105 | { 106 | this->trackTimes[i].push_back(Time(this->seconds, END)); 107 | this->tracks[i].hitEnd = false; 108 | } 109 | } 110 | } 111 | this->tempoCount += (static_cast(this->tempo) * static_cast(this->tempoRate)) >> 8; 112 | 113 | this->seconds += SecondsPerClockCycle; 114 | } 115 | 116 | void TimerPlayer::UpdateTracks() 117 | { 118 | for (int i = 0; i < 16; ++i) 119 | this->channels[i].UpdateTrack(); 120 | for (int i = 0; i < MAXTRACKS; ++i) 121 | this->tracks[i].updateFlags.reset(); 122 | } 123 | 124 | Time TimerPlayer::Length() 125 | { 126 | uint32_t tracksLooped = 0, tracksEnded = 0; 127 | double len = -1; 128 | TimeType lastType = LOOP; 129 | for (uint8_t i = 0; i < this->nTracks; ++i) 130 | { 131 | auto × = this->trackTimes[i]; 132 | if (times.empty()) 133 | continue; 134 | auto &time = times[times.size() - 1]; 135 | if (time.type == LOOP && times.size() >= this->loops) 136 | ++tracksLooped; 137 | else if (time.type == END) 138 | ++tracksEnded; 139 | if (time.time > len) 140 | { 141 | len = time.time; 142 | lastType = time.type; 143 | } 144 | } 145 | if (tracksLooped == this->nTracks) 146 | return Time(len, LOOP); 147 | else if (tracksEnded == this->nTracks) 148 | return Time(len, END); 149 | else if (tracksLooped + tracksEnded == this->nTracks) 150 | return Time(len, lastType); 151 | return Time(-1, LOOP); 152 | } 153 | 154 | void TimerPlayer::LockMutex() 155 | { 156 | #ifdef _WIN32 157 | WaitForSingleObject(this->mutex, INFINITE); 158 | #else 159 | pthread_mutex_lock(&this->mutex); 160 | #endif 161 | } 162 | 163 | void TimerPlayer::UnlockMutex() 164 | { 165 | #ifdef _WIN32 166 | ReleaseMutex(this->mutex); 167 | #else 168 | pthread_mutex_unlock(&this->mutex); 169 | #endif 170 | } 171 | 172 | static inline int32_t muldiv7(int32_t val, uint8_t mul) 173 | { 174 | return mul == 127 ? val : (val * mul) >> 7; 175 | } 176 | 177 | void TimerPlayer::GetLength() 178 | { 179 | bool success = false; 180 | try 181 | { 182 | this->length = Time(); 183 | for (;;) 184 | { 185 | this->LockMutex(); 186 | bool doingLength = this->doLength; 187 | this->UnlockMutex(); 188 | if (!doingLength) 189 | { 190 | this->length = Time(-1, LOOP); 191 | return; 192 | } 193 | 194 | if (this->doNotes) 195 | { 196 | int32_t leftChannel = 0, rightChannel = 0; 197 | 198 | // I need to advance the sound channels here 199 | for (int i = 0; i < 16; ++i) 200 | { 201 | TimerChannel &chn = this->channels[i]; 202 | 203 | if (chn.state > CS_NONE) 204 | { 205 | int32_t sample = chn.GenerateSample(); 206 | chn.IncrementSample(); 207 | 208 | uint8_t datashift = chn.reg.volumeDiv; 209 | if (datashift == 3) 210 | datashift = 4; 211 | sample = muldiv7(sample, chn.reg.volumeMul) >> datashift; 212 | 213 | leftChannel += muldiv7(sample, 127 - chn.reg.panning); 214 | rightChannel += muldiv7(sample, chn.reg.panning); 215 | } 216 | } 217 | 218 | clamp(leftChannel, std::numeric_limits::min(), std::numeric_limits::max()); 219 | clamp(rightChannel, std::numeric_limits::min(), std::numeric_limits::max()); 220 | 221 | if (!leftChannel && !rightChannel) 222 | this->trailingSilenceSeconds += SecondsPerClockCycle; 223 | else if (trailingSilenceSeconds > 0) 224 | this->trailingSilenceSeconds = 0; 225 | 226 | this->UpdateTracks(); 227 | 228 | for (int i = 0; i < 16; ++i) 229 | this->channels[i].Update(); 230 | } 231 | 232 | this->Run(); 233 | 234 | if (this->doNotes && this->trailingSilenceSeconds >= 20.0) 235 | { 236 | double time = this->seconds - this->trailingSilenceSeconds; 237 | this->length = Time(time < 0 ? 0 : time, END); 238 | success = true; 239 | break; 240 | } 241 | 242 | if (!this->doNotes) 243 | { 244 | this->length = this->Length(); 245 | if (static_cast(this->length.time) != -1) 246 | { 247 | success = true; 248 | break; 249 | } 250 | } 251 | if (this->seconds > maxSeconds) 252 | break; 253 | } 254 | this->LockMutex(); 255 | this->doLength = false; 256 | this->UnlockMutex(); 257 | } 258 | catch (const std::exception &) 259 | { 260 | success = false; 261 | } 262 | if (!success) 263 | this->length = Time(-1, LOOP); 264 | } 265 | 266 | #ifdef _WIN32 267 | DWORD WINAPI TimerPlayer::GetLengthThread(void *handle) 268 | #else 269 | void *TimerPlayer::GetLengthThread(void *handle) 270 | #endif 271 | { 272 | TimerPlayer *player = reinterpret_cast(handle); 273 | player->GetLength(); 274 | #ifdef _WIN32 275 | return 0; 276 | #else 277 | return nullptr; 278 | #endif 279 | } 280 | 281 | void TimerPlayer::StartLengthThread() 282 | { 283 | this->doLength = true; 284 | #ifdef _WIN32 285 | DWORD threadID; 286 | this->thread = CreateThread(nullptr, 0, TimerPlayer::GetLengthThread, this, 0, &threadID); 287 | #else 288 | pthread_create(&this->thread, nullptr, TimerPlayer::GetLengthThread, this); 289 | #endif 290 | } 291 | 292 | void TimerPlayer::WaitForThread() 293 | { 294 | #ifdef _WIN32 295 | WaitForSingleObject(this->thread, INFINITE); 296 | #else 297 | pthread_join(this->thread, nullptr); 298 | #endif 299 | } 300 | -------------------------------------------------------------------------------- /2SFTagsToNCSF/2SFTagsToNCSF.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 2SF Tags to NCSF 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-12-08 5 | * 6 | * Version history: 7 | * v1.0 - 2013-03-30 - Initial version 8 | * v1.1 - 2012-03-30 - Added option to rename the NCSFs, requested by Knurek. 9 | * v1.2 - 2012-04-10 - Made it so a file is not overwritten when renaming if 10 | * a duplicate is found. 11 | * v1.3 - 2012-12-08 - Minor cleanup of PseudoReadFile to not use a pointer. 12 | */ 13 | 14 | #include 15 | #include "NCSF.h" 16 | 17 | static const std::string TWOSFTAGSTONCSF_VERSION = "1.3"; 18 | 19 | enum { UNKNOWN, HELP, VERBOSE, EXCLUDETAG, RENAME }; 20 | const option::Descriptor opts[] = 21 | { 22 | option::Descriptor(UNKNOWN, 0, "", "", option::Arg::None, "2SF Tags to NCSF v" + TWOSFTAGSTONCSF_VERSION + "\nBy Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com]\n\n" 23 | "2SF Tags to NCSF will copy tags from a 2SF set and place them into the tags of an NCSF set.\n\n" 24 | "Usage:\n" 25 | " 2SFTagsToNCSF [options] \n\n" 26 | "Options:"), 27 | option::Descriptor(HELP, 0, "h", "help", option::Arg::None, " --help,-h \tPrint usage and exit."), 28 | option::Descriptor(VERBOSE, 0, "v", "verbose", option::Arg::None, " --verbose,-v \tVerbose output."), 29 | option::Descriptor(EXCLUDETAG, 0, "x", "exclude", RequireArgument, " --exclude= \v -x \tExclude the given tag from the tags to copy."), 30 | option::Descriptor(RENAME, 0, "r", "rename", option::Arg::None, " --rename,-r \tRenames the NCSFs to match the 2SFs."), 31 | option::Descriptor(UNKNOWN, 0, "", "", option::Arg::None, 32 | "\nVerbose output will output the tags that were copied." 33 | "\n\nRegardless of which tags are excluded on the command line, the _lib, 2sfby, length and fade tags will always be excluded from the conversion process."), 34 | option::Descriptor() 35 | }; 36 | 37 | typedef std::map> TwoSFs; 38 | typedef std::map> NCSFs; 39 | 40 | int main(int argc, char *argv[]) 41 | { 42 | // Options parsing 43 | argc -= argc > 0; 44 | argv += argc > 0; 45 | option::Stats stats(opts, argc, argv); 46 | std::vector options(stats.options_max), buffer(stats.buffer_max); 47 | option::Parser parse(opts, argc, argv, &options[0], &buffer[0]); 48 | 49 | if (parse.error()) 50 | return 1; 51 | 52 | if (options[HELP] || !argc || parse.nonOptionsCount() < 2) 53 | { 54 | option::printUsage(std::cout, opts); 55 | return 0; 56 | } 57 | 58 | // Get the tags to exclude 59 | std::vector tagsToExclude; 60 | for (option::Option *opt = options[EXCLUDETAG]; opt; opt = opt->next()) 61 | tagsToExclude.push_back(opt->arg); 62 | 63 | std::string twoSFDirectory = parse.nonOption(0); 64 | std::replace(twoSFDirectory.begin(), twoSFDirectory.end(), '\\', '/'); 65 | std::string NCSFDirectory = parse.nonOption(1); 66 | std::replace(NCSFDirectory.begin(), NCSFDirectory.end(), '\\', '/'); 67 | 68 | std::string twoSFExtensions[] = { ".2sf", ".mini2sf", ".2sflib" }; 69 | auto twoSFExtensionsVector = std::vector(twoSFExtensions, twoSFExtensions + 3); 70 | Files twoSFFiles = GetFilesInDirectory(twoSFDirectory, twoSFExtensionsVector); 71 | 72 | std::map twoSFSDATs; 73 | TwoSFs twoSFs; 74 | uint8_t sdatSignature[] = { 0x53, 0x44, 0x41, 0x54, 0xFF, 0xFE, 0x00, 0x01 }; 75 | std::vector sdatSignatureVector(sdatSignature, sdatSignature + 8); 76 | // Get the tags and sdats from the 2SFs 77 | std::for_each(twoSFFiles.begin(), twoSFFiles.end(), [&](const std::string &filename) 78 | { 79 | try 80 | { 81 | PseudoReadFile fileData; 82 | fileData.GetDataFromFile(filename); 83 | 84 | auto programSection = GetProgramSectionFromPSF(fileData, 0x24, 8, 4, true); 85 | TagList tags = GetTagsFromPSF(fileData, 0x24); 86 | if (tags.Exists("_lib")) 87 | { 88 | uint16_t SSEQNumber = ReadLE(&programSection[8]); 89 | twoSFs.insert(std::make_pair(filename, std::make_tuple(SSEQNumber, nullptr, tags))); 90 | } 91 | else 92 | { 93 | PseudoReadFile romFileData(filename); 94 | romFileData.GetDataFromVector(programSection.begin() + 8, programSection.end()); 95 | 96 | romFileData.pos = 0; 97 | romFileData.startOffset = romFileData.GetNextOffset(0, sdatSignatureVector); 98 | 99 | SDAT sdat; 100 | sdat.Read(filename, romFileData, false); 101 | std::string filenameMinusPath = GetFilenameFromPath(filename); 102 | twoSFSDATs.insert(std::make_pair(filenameMinusPath, sdat)); 103 | } 104 | } 105 | catch (const std::exception &e) 106 | { 107 | std::cerr << "ERROR: " << e.what() << "\n"; 108 | } 109 | }); 110 | 111 | if (twoSFSDATs.empty()) 112 | { 113 | std::cerr << "ERROR: No SDAT found in the 2SFs, for some reason...\n"; 114 | return 1; 115 | } 116 | 117 | // For the 2SFs that had a _lib tag, get their SSEQ from the SDAT 118 | std::for_each(twoSFs.begin(), twoSFs.end(), [&](TwoSFs::value_type &twoSF) 119 | { 120 | uint16_t SSEQNumber = std::get<0>(twoSF.second); 121 | const SSEQ *&sseq = std::get<1>(twoSF.second); 122 | const TagList &tags = std::get<2>(twoSF.second); 123 | const SDAT &sdat = twoSFSDATs.find(tags["_lib"])->second; 124 | sseq = sdat.infoSection.SEQrecord.entries[SSEQNumber].sseq; 125 | }); 126 | 127 | std::string ncsfExtensions[] = { ".ncsf", ".minincsf", ".ncsflib" }; 128 | auto ncsfExtensionsVector = std::vector(ncsfExtensions, ncsfExtensions + 3); 129 | Files ncsfFiles = GetFilesInDirectory(NCSFDirectory, ncsfExtensionsVector); 130 | 131 | SDAT ncsfSDAT; 132 | NCSFs ncsfs; 133 | // Get the tags and SDAT for the NCSFs 134 | std::for_each(ncsfFiles.begin(), ncsfFiles.end(), [&](const std::string &filename) 135 | { 136 | try 137 | { 138 | PseudoReadFile fileData; 139 | fileData.GetDataFromFile(filename); 140 | 141 | auto programSection = GetProgramSectionFromPSF(fileData, 0x25, 12, 8); 142 | TagList tags = GetTagsFromPSF(fileData, 0x25); 143 | // If the program section is empty, this is a minincsf 144 | if (programSection.empty()) 145 | { 146 | uint32_t SSEQNumber = ReadLE(&fileData.data[16]); 147 | ncsfs.insert(std::make_pair(filename, std::make_pair(SSEQNumber, tags))); 148 | } 149 | // Otherwise it is either an ncsf or an ncsflib 150 | else 151 | { 152 | PseudoReadFile sdatFileData(filename); 153 | sdatFileData.GetDataFromVector(programSection.begin(), programSection.end()); 154 | 155 | ncsfSDAT.Read(filename, sdatFileData); 156 | if (!tags.Empty()) 157 | ncsfs.insert(std::make_pair(filename, std::make_pair(0, tags))); 158 | } 159 | } 160 | catch (const std::exception &) 161 | { 162 | } 163 | }); 164 | // Copy the tag data from the 2SFs to the NCSFs 165 | std::for_each(ncsfs.begin(), ncsfs.end(), [&](const NCSFs::value_type &ncsf) 166 | { 167 | uint32_t SSEQNumber = ncsf.second.first; 168 | const SSEQ *sseq = ncsfSDAT.infoSection.SEQrecord.entries[SSEQNumber].sseq; 169 | 170 | auto twoSF = std::find_if(twoSFs.begin(), twoSFs.end(), [&](const TwoSFs::value_type &item) 171 | { 172 | return sseq->data == std::get<1>(item.second)->data; 173 | }); 174 | if (twoSF != twoSFs.end()) 175 | { 176 | std::string filename = ncsf.first; 177 | if (!!options[RENAME]) 178 | { 179 | auto dot = twoSF->first.rfind('.'); 180 | filename = twoSF->first.substr(0, dot); 181 | filename = GetFilenameFromPath(filename); 182 | if (NCSFDirectory[NCSFDirectory.size() - 1] != '/') 183 | filename = "/" + filename; 184 | filename = NCSFDirectory + filename; 185 | if (FileExists(filename + ".minincsf")) 186 | for (unsigned i = 1; ; ++i) 187 | { 188 | std::string istr = stringify(i); 189 | if (!FileExists(filename + "_Duplicate" + istr + ".minincsf")) 190 | { 191 | filename += "_Duplicate" + istr; 192 | break; 193 | } 194 | } 195 | filename += ".minincsf"; 196 | remove(ncsf.first.c_str()); 197 | } 198 | if (!!options[VERBOSE]) 199 | std::cout << "Copying tags from " << twoSF->first << "\n to " << filename << "\n"; 200 | 201 | TagList twoSFTags = std::get<2>(twoSF->second); 202 | twoSFTags.Remove("_lib"); 203 | twoSFTags.Remove("2sfby"); 204 | twoSFTags.Remove("length"); 205 | twoSFTags.Remove("fade"); 206 | std::for_each(tagsToExclude.begin(), tagsToExclude.end(), [&](const std::string &tag) { twoSFTags.Remove(tag); }); 207 | 208 | TagList ncsfTags = ncsf.second.second; 209 | ncsfTags.CopyOverwriteExistingOnly(twoSFTags); 210 | 211 | auto reservedData = IntToLEVector(SSEQNumber); 212 | 213 | MakeNCSF(filename, reservedData, std::vector(), ncsfTags.GetTags()); 214 | } 215 | }); 216 | 217 | return 0; 218 | } 219 | -------------------------------------------------------------------------------- /2SFtoNCSF/2SFtoNCSF.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 2SF to NCSF 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-12-08 5 | * 6 | * Version history: 7 | * v1.0 - 2014-10-29 - Initial version 8 | * v1.1 - 2012-12-08 - Minor cleanup of PseudoReadFile to not use a pointer. 9 | */ 10 | 11 | #include 12 | #include "NCSF.h" 13 | 14 | static const std::string TWOSFTONCSF_VERSION = "1.1"; 15 | 16 | enum { UNKNOWN, HELP, VERBOSE, TIME, FADELOOP, FADEONESHOT, EXCLUDETAG }; 17 | const option::Descriptor opts[] = 18 | { 19 | option::Descriptor(UNKNOWN, 0, "", "", option::Arg::None, "2SF to NCSF v" + TWOSFTONCSF_VERSION + "\nBy Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com]\n\n" 20 | "2SF to NCSF will create an NCSF set from a corresponding 2SF set.\n\n" 21 | "Usage:\n" 22 | " 2SFtoNCSF [options] []\n\n" 23 | "Options:"), 24 | option::Descriptor(HELP, 0, "h", "help", option::Arg::None, " --help,-h \tPrint usage and exit."), 25 | option::Descriptor(VERBOSE, 0, "v", "verbose", option::Arg::None, " --verbose,-v \tVerbose output."), 26 | option::Descriptor(TIME, 0, "t", "time", RequireNumericArgument, 27 | " --time,-t \tCalculate time on each track to the number of loops given. Defaults to 2 loops. 0 will disable timing."), 28 | option::Descriptor(FADELOOP, 0, "l", "fade-loop", RequireNumericArgument, " --fade-loop,-l \tSet the fade time for looping tracks, in seconds, defaults to 10."), 29 | option::Descriptor(FADEONESHOT, 0, "o", "fade-one-shot", RequireNumericArgument, " --fade-one-shot,-o \tSet the fade time for one-shot tracks, in seconds, defaults to 0."), 30 | option::Descriptor(EXCLUDETAG, 0, "x", "exclude", RequireArgument, " --exclude= \v -x \tExclude the given tag from the tags to copy."), 31 | option::Descriptor(UNKNOWN, 0, "", "", option::Arg::None, 32 | "\nThis tool only works with 2SF sets created with Caitsith2's Legacy of Ys driver, and not older sets such as those using the Yoshi's Island DS driver." 33 | "\n\nIf the output NCSFLIB filename is not given, attempts to infer the filename will be made." 34 | "\n\nVerbose output will output the tags that were copied." 35 | "\n\nRegardless of which tags are excluded on the command line, the _lib, 2sfby, length and fade tags will always be excluded from the conversion process." 36 | "\n\nThis tool simply converts an existing 2SF set to an NCSF set. If you want more control over the process, it is recommended that you use NDStoNCSF on an NDS ROM."), 37 | option::Descriptor() 38 | }; 39 | 40 | typedef std::map> TwoSFs; 41 | 42 | int main(int argc, char *argv[]) 43 | { 44 | // Options parsing 45 | argc -= argc > 0; 46 | argv += argc > 0; 47 | option::Stats stats(opts, argc, argv); 48 | std::vector options(stats.options_max), buffer(stats.buffer_max); 49 | option::Parser parse(opts, argc, argv, &options[0], &buffer[0]); 50 | 51 | if (parse.error()) 52 | return 1; 53 | 54 | if (options[HELP] || !argc || parse.nonOptionsCount() < 1) 55 | { 56 | option::printUsage(std::cout, opts); 57 | return 0; 58 | } 59 | 60 | // Get the tags to exclude 61 | std::vector tagsToExclude; 62 | for (option::Option *opt = options[EXCLUDETAG]; opt; opt = opt->next()) 63 | tagsToExclude.push_back(opt->arg); 64 | 65 | uint32_t numberOfLoops = 2; 66 | if (options[TIME]) 67 | numberOfLoops = convertTo(options[TIME].arg); 68 | uint32_t fadeLoop = 10; 69 | if (options[FADELOOP]) 70 | fadeLoop = convertTo(options[FADELOOP].arg); 71 | uint32_t fadeOneShot = 1; 72 | if (options[FADEONESHOT]) 73 | fadeOneShot = convertTo(options[FADEONESHOT].arg); 74 | 75 | std::string twoSFDirectory = parse.nonOption(0); 76 | std::replace(twoSFDirectory.begin(), twoSFDirectory.end(), '\\', '/'); 77 | std::string ncsflibFilename = ""; 78 | if (parse.nonOptionsCount() >= 2) 79 | ncsflibFilename = parse.nonOption(1); 80 | 81 | std::string twoSFExtensions[] = { ".2sf", ".mini2sf", ".2sflib" }; 82 | auto twoSFExtensionsVector = std::vector(twoSFExtensions, twoSFExtensions + 3); 83 | Files twoSFFiles = GetFilesInDirectory(twoSFDirectory, twoSFExtensionsVector); 84 | std::sort(twoSFFiles.begin(), twoSFFiles.end()); 85 | 86 | std::map twoSFSDATs; 87 | TwoSFs twoSFs; 88 | uint8_t sdatSignature[] = { 0x53, 0x44, 0x41, 0x54, 0xFF, 0xFE, 0x00, 0x01 }; 89 | std::vector sdatSignatureVector(sdatSignature, sdatSignature + 8); 90 | // Get the tags and sdats from the 2SFs 91 | std::for_each(twoSFFiles.begin(), twoSFFiles.end(), [&](const std::string &filename) 92 | { 93 | if (!!options[VERBOSE]) 94 | std::cout << "Processing " << filename << "\n"; 95 | try 96 | { 97 | PseudoReadFile fileData; 98 | fileData.GetDataFromFile(filename); 99 | 100 | auto programSection = GetProgramSectionFromPSF(fileData, 0x24, 8, 4, true); 101 | TagList tags = GetTagsFromPSF(fileData, 0x24); 102 | if (tags.Exists("_lib")) 103 | { 104 | if (programSection.empty()) 105 | throw std::runtime_error("This 2SF had no program section!"); 106 | uint16_t SSEQNumber = ReadLE(&programSection[8]); 107 | twoSFs.insert(std::make_pair(filename, std::make_tuple(SSEQNumber, tags))); 108 | } 109 | else 110 | { 111 | PseudoReadFile romFileData(filename); 112 | romFileData.GetDataFromVector(programSection.begin() + 8, programSection.end()); 113 | 114 | char gameNameArray[12]; 115 | romFileData.ReadLE(gameNameArray); 116 | std::string gameName = std::string(gameNameArray, gameNameArray + 12); 117 | if (gameName != "LEGACY OF YS") 118 | throw std::runtime_error("This tool only works on the Legacy of Ys ROM, but I got '" + gameName + "' instead."); 119 | 120 | romFileData.pos = 0; 121 | romFileData.startOffset = romFileData.GetNextOffset(0, sdatSignatureVector); 122 | 123 | SDAT sdat; 124 | sdat.Read(filename, romFileData, false); 125 | std::string filenameMinusPath = GetFilenameFromPath(filename); 126 | twoSFSDATs.insert(std::make_pair(filenameMinusPath, sdat)); 127 | if (ncsflibFilename.empty() && tags.Empty()) 128 | { 129 | size_t dot = filenameMinusPath.rfind('.'); 130 | ncsflibFilename = filenameMinusPath.substr(0, dot) + ".ncsflib"; 131 | } 132 | if (!tags.Empty()) 133 | { 134 | uint16_t SSEQNumber = ReadLE(&programSection[0x0d0fc8]); 135 | twoSFs.insert(std::make_pair(filename, std::make_tuple(SSEQNumber, tags))); 136 | } 137 | } 138 | } 139 | catch (const std::exception &e) 140 | { 141 | std::cerr << "ERROR: " << e.what() << "\n"; 142 | } 143 | }); 144 | 145 | if (twoSFSDATs.empty()) 146 | { 147 | std::cerr << "ERROR: No SDAT found in the 2SFs, for some reason...\n"; 148 | return 1; 149 | } 150 | 151 | if (twoSFs.empty()) 152 | { 153 | std::cerr << "ERROR: No SSEQs were found to convert.\n"; 154 | return 1; 155 | } 156 | 157 | if (twoSFs.size() > 1 && ncsflibFilename.empty()) 158 | { 159 | std::cerr << "ERROR: Unable to infer filename to use for NCSFLIB. Specify it on the command line.\n"; 160 | return 1; 161 | } 162 | 163 | // Create a merged SDAT from the sequences that were in the 2SF set 164 | if (options[VERBOSE]) 165 | std::cout << "Building merged SDAT...\n"; 166 | SDAT finalSDAT; 167 | int32_t sdatNumber = 0; 168 | std::for_each(twoSFs.begin(), twoSFs.end(), [&](TwoSFs::value_type &twoSF) 169 | { 170 | const TagList &tags = std::get<1>(twoSF.second); 171 | std::string filenameMinusPath = GetFilenameFromPath(twoSF.first); 172 | const SDAT &sdat = twoSFSDATs.find(tags.Exists("_lib") ? tags["_lib"] : filenameMinusPath)->second; 173 | SDAT newSDAT = sdat.MakeFromSSEQ(std::get<0>(twoSF.second)); 174 | newSDAT.filename = stringify(sdatNumber++ + 1); 175 | newSDAT.infoSection.SEQrecord.entries[0].sdatNumber = twoSF.first; 176 | finalSDAT += newSDAT; 177 | }); 178 | 179 | finalSDAT.count = 1; 180 | finalSDAT.Strip(IncOrExc(), options[VERBOSE].count() > 1); 181 | 182 | // Setup the output directory, making sure it is clear beforehand (if it exists) 183 | std::string NCSFDirectory = twoSFDirectory; 184 | if (twoSFDirectory[twoSFDirectory.size() - 1] == '/') 185 | NCSFDirectory = NCSFDirectory.substr(0, twoSFDirectory.size() - 1); 186 | NCSFDirectory += "_2SFtoNCSF"; 187 | if (DirExists(NCSFDirectory)) 188 | { 189 | std::string extensions[] = { ".ncsf", ".minincsf", ".ncsflib" }; 190 | auto extensionsVector = std::vector(extensions, extensions + 3); 191 | Files files = GetFilesInDirectory(NCSFDirectory, extensionsVector); 192 | RemoveFiles(files); 193 | } 194 | else 195 | MakeDir(NCSFDirectory); 196 | if (options[VERBOSE]) 197 | std::cout << "Output will go to " << NCSFDirectory << "\n"; 198 | 199 | // Create vector data for SDAT 200 | PseudoWrite sdatData; 201 | finalSDAT.Write(sdatData); 202 | 203 | bool singleNCSF = finalSDAT.infoSection.SEQrecord.count == 1; 204 | if (!singleNCSF) 205 | { 206 | // Make NCSFLIB if we are creating more than one NCSF 207 | MakeNCSF(NCSFDirectory + "/" + ncsflibFilename, std::vector(), sdatData.vector->data); 208 | if (options[VERBOSE]) 209 | std::cout << "Created " << ncsflibFilename << "\n"; 210 | } 211 | for (size_t i = 0, sseqs = finalSDAT.infoSection.SEQrecord.count; i < sseqs; ++i) 212 | { 213 | std::string origFilename = finalSDAT.infoSection.SEQrecord.entries[i].sdatNumber; 214 | TagList tags = std::get<1>(twoSFs.find(origFilename)->second); 215 | tags.Remove("_lib"); 216 | tags.Remove("2sfby"); 217 | tags.Remove("length"); 218 | tags.Remove("fade"); 219 | std::for_each(tagsToExclude.begin(), tagsToExclude.end(), [&](const std::string &tag) { tags.Remove(tag); }); 220 | tags["ncsfby"] = "2SF to NCSF"; 221 | tags["origFilename"] = finalSDAT.infoSection.SEQrecord.entries[i].sseq->origFilename; 222 | if (!singleNCSF) 223 | tags["_lib"] = ncsflibFilename; 224 | 225 | std::string filename = GetFilenameFromPath(origFilename); 226 | size_t dot = filename.rfind('.'); 227 | filename = filename.substr(0, dot) + (singleNCSF ? ".ncsf" : ".minincsf"); 228 | std::vector programData; 229 | if (singleNCSF) 230 | programData = sdatData.vector->data; 231 | 232 | auto reservedData = IntToLEVector(i); 233 | 234 | if (numberOfLoops) 235 | GetTime(filename, &finalSDAT, finalSDAT.infoSection.SEQrecord.entries[i].sseq, tags, !!options[VERBOSE], numberOfLoops, fadeLoop, fadeOneShot); 236 | 237 | MakeNCSF(NCSFDirectory + "/" + filename, reservedData, programData, tags.GetTags()); 238 | if (options[VERBOSE]) 239 | std::cout << "Created " << filename << "\n"; 240 | } 241 | 242 | return 0; 243 | } 244 | -------------------------------------------------------------------------------- /common/NCSF.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Common NCSF functions 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-12-08 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include "NCSF.h" 13 | #include "TimerPlayer.h" 14 | 15 | // Create an NCSF file 16 | void MakeNCSF(const std::string &filename, const std::vector &reservedSectionData, const std::vector &programSectionData, 17 | const std::vector &tags) 18 | { 19 | // Create zlib compressed version of program section, if one was given 20 | auto finalProgramSectionData = programSectionData; 21 | 22 | unsigned long programCompressedSize = finalProgramSectionData.empty() ? 0 : compressBound(finalProgramSectionData.size()); 23 | auto programCompressedData = std::vector(programCompressedSize); 24 | 25 | if (programCompressedSize) 26 | { 27 | compress2(&programCompressedData[0], &programCompressedSize, &finalProgramSectionData[0], finalProgramSectionData.size(), 9); 28 | programCompressedData.resize(programCompressedSize); 29 | } 30 | 31 | // Create file 32 | std::ofstream file; 33 | file.exceptions(std::ofstream::failbit | std::ofstream::badbit); 34 | file.open(filename.c_str(), std::ofstream::out | std::ofstream::binary); 35 | 36 | PseudoWrite ofile(&file); 37 | 38 | ofile.WriteLE("PSF", 3); 39 | ofile.WriteLE(0x25); 40 | ofile.WriteLE(reservedSectionData.empty() ? 0 : reservedSectionData.size()); 41 | ofile.WriteLE(programCompressedSize); 42 | if (programCompressedSize) 43 | { 44 | uint32_t crc = crc32(0, Z_NULL, 0); 45 | crc = crc32(crc, &programCompressedData[0], programCompressedSize); 46 | ofile.WriteLE(crc); 47 | } 48 | else 49 | ofile.WriteLE(0); 50 | if (!reservedSectionData.empty()) 51 | ofile.WriteLE(reservedSectionData); 52 | if (!programCompressedData.empty()) 53 | ofile.WriteLE(programCompressedData); 54 | if (!tags.empty()) 55 | { 56 | ofile.WriteLE("[TAG]", 5); 57 | for (size_t i = 0, len = tags.size(); i < len; ++i) 58 | { 59 | ofile.WriteLE(tags[i], tags[i].size()); 60 | ofile.WriteLE(0x0A); 61 | } 62 | } 63 | 64 | file.close(); 65 | } 66 | 67 | // Check if the given file data is a valid PSF, throwing an exception if it's 68 | // not a valid PSF 69 | void CheckForValidPSF(PseudoReadFile &file, uint8_t versionByte) 70 | { 71 | // Various checks on the file's size will be done throughout 72 | if (file.data.size() < 4) 73 | throw std::range_error("File is too small."); 74 | 75 | file.pos = 0; 76 | 77 | // Read the (hopefully) PSF header 78 | char PSFHeader[4]; 79 | file.ReadLE(PSFHeader); 80 | 81 | // Verify it actually is a PSF file, as well as having the NCSF version byte 82 | if (PSFHeader[0] != 'P' || PSFHeader[1] != 'S' || PSFHeader[2] != 'F') 83 | throw std::runtime_error("Not a PSF file."); 84 | 85 | if (PSFHeader[3] != versionByte) 86 | throw std::runtime_error("Version byte of " + NumToHexString(PSFHeader[3]) + 87 | " does not equal what we were looking for (" + NumToHexString(versionByte) + ")."); 88 | 89 | if (file.data.size() < 16) 90 | throw std::range_error("File is too small."); 91 | 92 | // Get the sizes on the reserved and program sections 93 | uint32_t reservedSize = file.ReadLE(), programCompressedSize = file.ReadLE(); 94 | 95 | // Skip the CRC 96 | file.pos += 4; 97 | 98 | // Check the reserved section 99 | if (reservedSize && file.data.size() < reservedSize + 16) 100 | throw std::range_error("File is too small."); 101 | 102 | file.pos += reservedSize; 103 | 104 | // Check the program section 105 | if (programCompressedSize && file.data.size() < reservedSize + programCompressedSize + 16) 106 | throw std::range_error("File is too small."); 107 | } 108 | 109 | // Extract the program section from a PSF. Does not do any checks on the file, 110 | // as those will be done in CheckForValidPSF anyways. 111 | std::vector GetProgramSectionFromPSF(PseudoReadFile &file, uint8_t versionByte, uint32_t programHeaderSize, uint32_t programSizeOffset, bool addHeaderSize) 112 | { 113 | // Check to make sure the file is valid 114 | CheckForValidPSF(file, versionByte); 115 | 116 | // Get the sizes on the reserved and program sections 117 | file.pos = 4; 118 | uint32_t reservedSize = file.ReadLE(), programCompressedSize = file.ReadLE(); 119 | 120 | // Skip the CRC 121 | file.pos += 4; 122 | 123 | // We need a program section to continue 124 | if (!programCompressedSize) 125 | return std::vector(); 126 | 127 | // If there is a reserved section, skip over it 128 | if (reservedSize) 129 | file.pos += reservedSize; 130 | 131 | // Read the compressed program section 132 | auto programSectionCompressed = std::vector(programCompressedSize); 133 | file.ReadLE(programSectionCompressed); 134 | 135 | // Uncompress the program section, the reason uncompress is called twice: 136 | // first call is to get just the first 4 bytes that tell the size of the 137 | // entire uncompressed section, second call gets everything 138 | auto programSectionUncompressed = std::vector(programHeaderSize); 139 | unsigned long programUncompressedSize = programHeaderSize; 140 | uncompress(&programSectionUncompressed[0], &programUncompressedSize, &programSectionCompressed[0], programCompressedSize); 141 | programUncompressedSize = ReadLE(&programSectionUncompressed[programSizeOffset]); 142 | if (addHeaderSize) 143 | programUncompressedSize += programHeaderSize; 144 | programSectionUncompressed.resize(programUncompressedSize); 145 | uncompress(&programSectionUncompressed[0], &programUncompressedSize, &programSectionCompressed[0], programCompressedSize); 146 | 147 | return std::vector(programSectionUncompressed.begin(), programSectionUncompressed.end()); 148 | } 149 | 150 | // The whitespace trimming was modified from the following answer on Stack Overflow: 151 | // http://stackoverflow.com/a/217605 152 | 153 | static struct IsWhitespace : std::unary_function 154 | { 155 | bool operator()(const char &x) const 156 | { 157 | return x >= 0x01 && x <= 0x20; 158 | } 159 | } isWhitespace; 160 | 161 | static inline std::string LeftTrimWhitespace(const std::string &orig) 162 | { 163 | auto first_non_space = std::find_if(orig.begin(), orig.end(), std::not1(isWhitespace)); 164 | return std::string(first_non_space, orig.end()); 165 | } 166 | 167 | static inline std::string RightTrimWhitespace(const std::string &orig) 168 | { 169 | auto last_non_space = std::find_if(orig.rbegin(), orig.rend(), std::not1(isWhitespace)).base(); 170 | return std::string(orig.begin(), last_non_space); 171 | } 172 | 173 | static inline std::string TrimWhitespace(const std::string &orig) 174 | { 175 | return LeftTrimWhitespace(RightTrimWhitespace(orig)); 176 | } 177 | 178 | // Get only the tags from the PSF 179 | TagList GetTagsFromPSF(PseudoReadFile &file, uint8_t versionByte) 180 | { 181 | // Check to make sure the file is valid 182 | CheckForValidPSF(file, versionByte); 183 | 184 | TagList tags; 185 | 186 | // Get the starting offset of the tags 187 | char TagHeader[] = "[TAG]"; 188 | auto TagHeaderVector = std::vector(TagHeader, TagHeader + 5); 189 | int32_t TagOffset = file.GetNextOffset(0, TagHeaderVector); 190 | 191 | // Only continue on if we have tags 192 | if (TagOffset != -1) 193 | { 194 | file.pos = TagOffset + 5; 195 | std::string name, value; 196 | bool onName = true; 197 | size_t lengthOfTags = file.data.size() - file.pos; 198 | for (size_t x = 0; x < lengthOfTags; ++x) 199 | { 200 | char curr = file.ReadLE(); 201 | if (curr == 0x0A) 202 | { 203 | if (!name.empty() && !value.empty()) 204 | { 205 | name = TrimWhitespace(name); 206 | value = TrimWhitespace(value); 207 | if (tags.Exists(name)) 208 | tags[name] += "\n" + value; 209 | else 210 | tags[name] = value; 211 | } 212 | name = value = ""; 213 | onName = true; 214 | continue; 215 | } 216 | if (curr == '=') 217 | { 218 | onName = false; 219 | continue; 220 | } 221 | if (onName) 222 | name += curr; 223 | else 224 | value += curr; 225 | } 226 | } 227 | 228 | return tags; 229 | } 230 | 231 | // A simple function to get a file's extension 232 | static auto GetExtension = [](const std::string &filename) -> std::string 233 | { 234 | auto dot = filename.rfind('.'); 235 | return dot == std::string::npos ? "" : filename.substr(dot); 236 | }; 237 | 238 | // Get a list of files in the given directory 239 | Files GetFilesInDirectory(const std::string &path, const std::vector &extensions) 240 | { 241 | DIR *dir; 242 | dirent *entry; 243 | Files files; 244 | 245 | std::string finalPath = path; 246 | if (finalPath[path.size() - 1] != '/') 247 | finalPath += '/'; 248 | 249 | if ((dir = opendir(path.c_str()))) 250 | { 251 | while ((entry = readdir(dir))) 252 | { 253 | std::string filename = std::string(entry->d_name); 254 | if (filename == "." || filename == "..") 255 | continue; 256 | std::string fullPath = finalPath + filename; 257 | // Although the following function is for checking if a directory 258 | // exists, it can also be used to check if a path is a directory, 259 | // saving a little bit of extra code 260 | if (DirExists(fullPath)) 261 | continue; 262 | // We want to skip any files not matching the extensions we gave, if any 263 | std::string thisExtension = GetExtension(filename); 264 | auto extensionMatch = std::find_if(extensions.begin(), extensions.end(), [&](const std::string &extension) 265 | { 266 | return extension == thisExtension; 267 | }); 268 | if (extensions.empty() || extensionMatch != extensions.end()) 269 | files.push_back(fullPath); 270 | } 271 | closedir(dir); 272 | } 273 | 274 | return files; 275 | } 276 | 277 | // Remove the files in the given list of files 278 | void RemoveFiles(const Files &files) 279 | { 280 | std::for_each(files.begin(), files.end(), [](const std::string &file) { remove(file.c_str()); }); 281 | } 282 | 283 | // Get time on SSEQ (uses a separate thread so it can be killed off if it takes longer than a few seconds) 284 | static Time GetTime(TimerPlayer *player, uint32_t loopCount, uint32_t numberOfLoops) 285 | { 286 | player->loops = numberOfLoops; 287 | player->StartLengthThread(); 288 | uint32_t i = 0; 289 | for (; i < loopCount; ++i) 290 | { 291 | player->LockMutex(); 292 | bool doingLength = player->doLength; 293 | player->UnlockMutex(); 294 | if (doingLength) 295 | { 296 | #ifdef _WIN32 297 | Sleep(150); 298 | #else 299 | timespec req; 300 | req.tv_sec = 0; 301 | req.tv_nsec = 150000000; 302 | while (nanosleep(&req, &req) == -1 && errno == EINTR); 303 | #endif 304 | } 305 | else 306 | break; 307 | } 308 | Time length; 309 | if (i == loopCount) 310 | { 311 | player->LockMutex(); 312 | player->doLength = false; 313 | player->UnlockMutex(); 314 | player->WaitForThread(); 315 | length = Time(-1, LOOP); 316 | } 317 | else 318 | { 319 | player->WaitForThread(); 320 | length = player->length; 321 | } 322 | return length; 323 | } 324 | 325 | static inline int Cnv_Scale(int scale) 326 | { 327 | static const int16_t lut[] = 328 | { 329 | -32768, -421, -361, -325, -300, -281, -265, -252, 330 | -240, -230, -221, -212, -205, -198, -192, -186, 331 | -180, -175, -170, -165, -161, -156, -152, -148, 332 | -145, -141, -138, -134, -131, -128, -125, -122, 333 | -120, -117, -114, -112, -110, -107, -105, -103, 334 | -100, -98, -96, -94, -92, -90, -88, -86, 335 | -85, -83, -81, -79, -78, -76, -74, -73, 336 | -71, -70, -68, -67, -65, -64, -62, -61, 337 | -60, -58, -57, -56, -54, -53, -52, -51, 338 | -49, -48, -47, -46, -45, -43, -42, -41, 339 | -40, -39, -38, -37, -36, -35, -34, -33, 340 | -32, -31, -30, -29, -28, -27, -26, -25, 341 | -24, -23, -23, -22, -21, -20, -19, -18, 342 | -17, -17, -16, -15, -14, -13, -12, -12, 343 | -11, -10, -9, -9, -8, -7, -6, -6, 344 | -5, -4, -3, -3, -2, -1, -1, 0 345 | }; 346 | 347 | if (scale & 0x80) // Supposedly invalid value... 348 | scale = 0x7F; // Use apparently correct default 349 | return lut[scale]; 350 | } 351 | 352 | // Get time on SSEQ, will run the player at least once (without "playing" the 353 | // music), if the song is one-shot (and not looping), it will run the player 354 | // a second time, "playing" the song to determine when silence has occurred. 355 | // After which, it will store the data in the tags for the SSEQ. 356 | void GetTime(const std::string &filename, const SDAT *sdat, const SSEQ *sseq, TagList &tags, bool verbose, uint32_t numberOfLoops, uint32_t fadeLoop, uint32_t fadeOneShot) 357 | { 358 | const auto &info = sdat->infoSection.SEQrecord.entries[sseq->entryNumber]; 359 | auto player = std::unique_ptr(new TimerPlayer()); 360 | player->Setup(sseq, info.origFilename); 361 | player->maxSeconds = 6000; 362 | // Get the time, without "playing" the notes 363 | Time length = GetTime(player.get(), 20, numberOfLoops); 364 | // If the length was for a one-shot song, get the time again, this time "playing" the notes 365 | bool gotLength = false; 366 | if (static_cast(length.time) != -1 && length.type == END) 367 | { 368 | player.reset(new TimerPlayer()); 369 | player->sseqVol = Cnv_Scale(info.vol); 370 | player->Setup(sseq, info.origFilename); 371 | const auto &sbnkInfo = sdat->infoSection.BANKrecord.entries[info.bank]; 372 | player->sbnk = sbnkInfo.sbnk; 373 | for (int i = 0; i < 4; ++i) 374 | if (sbnkInfo.waveArc[i] != 0xFFFF) 375 | player->swar[i] = sdat->infoSection.WAVEARCrecord.entries[sbnkInfo.waveArc[i]].swar; 376 | player->maxSeconds = length.time + 30; 377 | player->doNotes = true; 378 | Time oldLength = length; 379 | length = GetTime(player.get(), 40, numberOfLoops); 380 | if (static_cast(length.time) != -1) 381 | gotLength = true; 382 | else 383 | length = oldLength; 384 | } 385 | if (static_cast(length.time) != -1) 386 | { 387 | if (length.type == LOOP) 388 | tags["fade"] = stringify(fadeLoop); 389 | else 390 | tags["fade"] = stringify(fadeOneShot); 391 | if (!static_cast(length.time)) 392 | length.time = 1; 393 | std::string lengthString = SecondsToString(std::ceil(length.time)); 394 | tags["length"] = lengthString; 395 | if (verbose) 396 | { 397 | std::cout << "Time for " << filename << ": " << lengthString << " (" << (length.type == LOOP ? "timed to 2 loops" : "one-shot") << ")\n"; 398 | if (length.type == END && !gotLength) 399 | std::cout << "(NOTE: Was unable to detect silence at the end of the track, time may be inaccurate.)\n"; 400 | } 401 | } 402 | else if (verbose) 403 | { 404 | tags.Remove("fade"); 405 | tags.Remove("length"); 406 | std::cout << "Unable to calculate time for " << filename << "\n"; 407 | } 408 | } 409 | -------------------------------------------------------------------------------- /common/common.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SDAT - Common functions 3 | * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com] 4 | * Last modification on 2014-11-12 5 | */ 6 | 7 | #pragma once 8 | 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #ifdef _MSC_VER 23 | # include 24 | # define rmdir(dir) _rmdir((dir)) 25 | # include "win_dirent.h" 26 | #else 27 | # include 28 | # ifndef _WIN32 29 | # include 30 | # endif 31 | #endif 32 | #ifdef _WIN32 33 | # define mkdir(dir, mode) _mkdir((dir)) 34 | #endif 35 | #include "optionparser.h" 36 | 37 | /* 38 | * Pseudo-file data structures 39 | * 40 | * The first structure is mainly so and entire can be loaded at once 41 | * and then "read" from the vector in this. 42 | * 43 | * The second set of structures are wrappers around either an std::ofstream 44 | * or an std::vector of uint8_t to make it easier to write data to it. 45 | */ 46 | 47 | struct PseudoReadFile 48 | { 49 | std::string filename; 50 | std::vector data; 51 | uint32_t pos, startOffset; 52 | 53 | PseudoReadFile(const std::string &fn = "") : filename(fn), data(), pos(0), startOffset(0) 54 | { 55 | } 56 | 57 | PseudoReadFile(const PseudoReadFile &file) : filename(file.filename), data(file.data.begin(), file.data.end()), pos(file.pos), 58 | startOffset(file.startOffset) 59 | { 60 | } 61 | 62 | PseudoReadFile &operator=(const PseudoReadFile &file) 63 | { 64 | if (this != &file) 65 | { 66 | this->filename = file.filename; 67 | this->data.assign(file.data.begin(), file.data.end()); 68 | this->pos = file.pos; 69 | this->startOffset = file.startOffset; 70 | } 71 | return *this; 72 | } 73 | 74 | void GetDataFromFile(const std::string &fn) 75 | { 76 | this->filename = fn; 77 | std::ifstream file; 78 | file.exceptions(std::ifstream::failbit | std::ifstream::badbit); 79 | file.open(fn.c_str(), std::ifstream::in | std::ifstream::binary); 80 | this->GetDataFromFile(file); 81 | file.close(); 82 | } 83 | 84 | void GetDataFromFile(std::ifstream &file) 85 | { 86 | auto origPos = file.tellg(); 87 | file.seekg(0, std::ifstream::end); 88 | this->pos = file.tellg(); 89 | file.seekg(0, std::ifstream::beg); 90 | this->data.resize(this->pos); 91 | file.read(reinterpret_cast(&this->data[0]), this->pos); 92 | this->pos = this->startOffset = 0; 93 | file.seekg(origPos, std::ifstream::beg); 94 | } 95 | 96 | template void GetDataFromVector(InputIterator start, InputIterator end) 97 | { 98 | this->data.assign(start, end); 99 | this->pos = this->startOffset = 0; 100 | } 101 | 102 | template T ReadLE() 103 | { 104 | if (this->startOffset + this->pos >= this->data.size() || this->startOffset + this->pos + sizeof(T) > this->data.size()) 105 | throw std::range_error("PseudoReadFile position was set past the end of the data."); 106 | T finalVal = 0; 107 | for (size_t i = 0; i < sizeof(T); ++i) 108 | finalVal |= this->data[this->startOffset + this->pos++] << (i * 8); 109 | return finalVal; 110 | } 111 | 112 | template void ReadLE(T (&arr)[N]) 113 | { 114 | for (size_t i = 0; i < N; ++i) 115 | arr[i] = this->ReadLE(); 116 | } 117 | 118 | template void ReadLE(uint8_t (&arr)[N]) 119 | { 120 | if (this->startOffset + this->pos >= this->data.size() || this->startOffset + this->pos + N > this->data.size()) 121 | throw std::range_error("PseudoReadFile position was set past the end of the data."); 122 | memcpy(&arr[0], &this->data[this->startOffset + this->pos], N); 123 | this->pos += N; 124 | } 125 | 126 | template void ReadLE(std::vector &arr) 127 | { 128 | for (size_t i = 0, len = arr.size(); i < len; ++i) 129 | arr[i] = this->ReadLE(); 130 | } 131 | 132 | void ReadLE(std::vector &arr) 133 | { 134 | if (this->startOffset + this->pos >= this->data.size() || this->startOffset + this->pos + arr.size() > this->data.size()) 135 | throw std::range_error("PseudoReadFile position was set past the end of the data."); 136 | memcpy(&arr[0], &this->data[this->startOffset + this->pos], arr.size()); 137 | this->pos += arr.size(); 138 | } 139 | 140 | std::string ReadNullTerminatedString() 141 | { 142 | char chr; 143 | std::string str; 144 | do 145 | { 146 | chr = static_cast(this->ReadLE()); 147 | if (chr) 148 | str += chr; 149 | } while (chr); 150 | return str; 151 | } 152 | 153 | // The following 2 functions are only utilized by the SSEQ player. 154 | int Read24() 155 | { 156 | int finalVal = 0; 157 | for (size_t i = 0; i < 3; ++i) 158 | finalVal |= this->ReadLE() << (i * 8); 159 | return finalVal; 160 | } 161 | 162 | int ReadVL() 163 | { 164 | int x = 0; 165 | for (;;) 166 | { 167 | int vl = this->ReadLE(); 168 | x = (x << 7) | (vl & 0x7F); 169 | if (!(vl & 0x80)) 170 | break; 171 | } 172 | return x; 173 | } 174 | 175 | // The idea behind this function comes from VGMToolbox, however the actual functionality 176 | // of it is much smoother than the one in VGMToolbox, as this leverages the std::search 177 | // function to get the offset in the data vector 178 | int32_t GetNextOffset(uint32_t startingOffset, const std::vector &searchBytes) 179 | { 180 | int32_t ret = -1; 181 | 182 | auto offset = std::search(this->data.begin() + startingOffset, this->data.end(), searchBytes.begin(), searchBytes.end()); 183 | if (offset != this->data.end()) 184 | ret = offset - this->data.begin(); 185 | 186 | return ret; 187 | } 188 | }; 189 | 190 | struct PseudoWriteFile 191 | { 192 | std::ofstream *file; 193 | 194 | PseudoWriteFile(std::ofstream *ofile) : file(ofile) 195 | { 196 | } 197 | 198 | template void WriteLE(const T &val) 199 | { 200 | for (size_t i = 0; i < sizeof(T); ++i) 201 | this->file->put((val >> (i * 8)) & 0xFF); 202 | } 203 | 204 | template void WriteLE(const T (&arr)[N]) 205 | { 206 | for (size_t i = 0; i < N; ++i) 207 | this->WriteLE(arr[i]); 208 | } 209 | 210 | template void WriteLE(const uint8_t (&arr)[N]) 211 | { 212 | this->file->write(reinterpret_cast(&arr[0]), N); 213 | } 214 | 215 | template void WriteLE(const std::vector &arr) 216 | { 217 | for (size_t i = 0, len = arr.size(); i < len; ++i) 218 | this->WriteLE(arr[i]); 219 | } 220 | 221 | void WriteLE(const std::vector &arr) 222 | { 223 | this->file->write(reinterpret_cast(&arr[0]), arr.size()); 224 | } 225 | 226 | void WriteLE(const std::string &str, int32_t size = -1) 227 | { 228 | this->file->write(str.c_str(), size == -1 ? str.size() + 1 : size); 229 | } 230 | }; 231 | 232 | struct PseudoWriteVector 233 | { 234 | std::vector data; 235 | 236 | PseudoWriteVector() : data() 237 | { 238 | } 239 | 240 | template void WriteLE(const T &val) 241 | { 242 | for (size_t i = 0; i < sizeof(T); ++i) 243 | this->data.push_back((val >> (i * 8)) & 0xFF); 244 | } 245 | 246 | template void WriteLE(const T (&arr)[N]) 247 | { 248 | for (size_t i = 0; i < N; ++i) 249 | this->WriteLE(arr[i]); 250 | } 251 | 252 | template void WriteLE(const uint8_t (&arr)[N]) 253 | { 254 | this->data.insert(this->data.end(), arr, arr + N); 255 | } 256 | 257 | template void WriteLE(const std::vector &arr) 258 | { 259 | for (size_t i = 0, len = arr.size(); i < len; ++i) 260 | this->WriteLE(arr[i]); 261 | } 262 | 263 | void WriteLE(const std::vector &arr) 264 | { 265 | this->data.insert(this->data.end(), arr.begin(), arr.end()); 266 | } 267 | 268 | void WriteLE(const std::string &str, int32_t size = -1) 269 | { 270 | size_t finalSize = size == -1 ? str.size() + 1 : size; 271 | auto strData = std::vector(finalSize, 0); 272 | memcpy(&strData[0], str.c_str(), finalSize); 273 | this->data.insert(this->data.end(), strData.begin(), strData.end()); 274 | } 275 | }; 276 | 277 | enum PseudoWriteType 278 | { 279 | PSEUDOWRITE_FILE, 280 | PSEUDOWRITE_VECTOR 281 | }; 282 | 283 | struct PseudoWrite 284 | { 285 | std::unique_ptr file; 286 | std::unique_ptr vector; 287 | PseudoWriteType type; 288 | 289 | PseudoWrite() : file(), vector(new PseudoWriteVector()), type(PSEUDOWRITE_VECTOR) 290 | { 291 | } 292 | 293 | PseudoWrite(std::ofstream *newFile) : file(new PseudoWriteFile(newFile)), vector(), type(PSEUDOWRITE_FILE) 294 | { 295 | } 296 | 297 | template void WriteLE(const T &val) 298 | { 299 | if (type == PSEUDOWRITE_FILE) 300 | this->file->WriteLE(val); 301 | else 302 | this->vector->WriteLE(val); 303 | } 304 | 305 | template void WriteLE(const T (&arr)[N]) 306 | { 307 | if (type == PSEUDOWRITE_FILE) 308 | this->file->WriteLE(arr); 309 | else 310 | this->vector->WriteLE(arr); 311 | } 312 | 313 | template void WriteLE(const uint8_t (&arr)[N]) 314 | { 315 | if (type == PSEUDOWRITE_FILE) 316 | this->file->WriteLE(arr); 317 | else 318 | this->vector->WriteLE(arr); 319 | } 320 | 321 | template void WriteLE(const std::vector &arr) 322 | { 323 | if (type == PSEUDOWRITE_FILE) 324 | this->file->WriteLE(arr); 325 | else 326 | this->vector->WriteLE(arr); 327 | } 328 | 329 | void WriteLE(const std::vector &arr) 330 | { 331 | if (type == PSEUDOWRITE_FILE) 332 | this->file->WriteLE(arr); 333 | else 334 | this->vector->WriteLE(arr); 335 | } 336 | 337 | void WriteLE(const std::string &str, int32_t size = -1) 338 | { 339 | if (type == PSEUDOWRITE_FILE) 340 | this->file->WriteLE(str, size); 341 | else 342 | this->vector->WriteLE(str, size); 343 | } 344 | }; 345 | 346 | /* 347 | * String Conversion 348 | * 349 | * The following class and 3 functions come from the C++ FAQ, Section 39, FAQ 39.3 350 | * http://www.parashift.com/c++-faq/convert-string-to-any.html 351 | */ 352 | 353 | class BadConversion : public std::runtime_error 354 | { 355 | public: 356 | BadConversion(const std::string &s) : std::runtime_error(s) 357 | { 358 | } 359 | }; 360 | 361 | template inline std::string stringify(const T &x) 362 | { 363 | std::ostringstream o; 364 | if (!(o << x)) 365 | throw BadConversion(std::string("stringify(") + typeid(x).name() + ")"); 366 | return o.str(); 367 | } 368 | 369 | template inline void convert(const std::string &s, T &x, bool failIfLeftoverChars = true) 370 | { 371 | std::istringstream i(s); 372 | char c; 373 | if (!(i >> x) || (failIfLeftoverChars && i.get(c))) 374 | throw BadConversion(s); 375 | } 376 | 377 | template inline T convertTo(const std::string &s, bool failIfLeftoverChars = true) 378 | { 379 | T x; 380 | convert(s, x, failIfLeftoverChars); 381 | return x; 382 | } 383 | 384 | // Read a little endian value from an array/pointer 385 | template inline T ReadLE(const uint8_t *arr) 386 | { 387 | T finalVal = 0; 388 | for (size_t i = 0; i < sizeof(T); ++i) 389 | finalVal |= arr[i] << (i * 8); 390 | return finalVal; 391 | } 392 | 393 | // Get a vector of 8-bit values in little endian format from any other integer 394 | template static inline std::vector IntToLEVector(const T &val) 395 | { 396 | auto vec = std::vector(sizeof(T)); 397 | for (size_t i = 0; i < sizeof(T); ++i) 398 | vec[i] = (val >> (i * 8)) & 0xFF; 399 | return vec; 400 | } 401 | 402 | /* 403 | * The following function is used to convert an integer into a hexadecimal 404 | * string, the length being determined by the size of the integer. 8-bit 405 | * integers are in the format of 0x00, 16-bit integers are in the format of 406 | * 0x0000, and so on. 407 | */ 408 | template inline std::string NumToHexString(const T &num) 409 | { 410 | std::string hex; 411 | uint8_t len = sizeof(T) * 2; 412 | for (uint8_t i = 0; i < len; ++i) 413 | { 414 | uint8_t tmp = (num >> (i * 4)) & 0xF; 415 | hex = static_cast(tmp < 10 ? tmp + '0' : tmp - 10 + 'a') + hex; 416 | } 417 | return "0x" + hex; 418 | } 419 | 420 | template inline void clamp(T1 &valueToClamp, const T2 &minValue, const T2 &maxValue) 421 | { 422 | if (valueToClamp < minValue) 423 | valueToClamp = minValue; 424 | else if (valueToClamp > maxValue) 425 | valueToClamp = maxValue; 426 | } 427 | 428 | /* 429 | * SDAT Record types 430 | * List of types taken from the Nitro Composer Specification 431 | * http://www.feshrine.net/hacking/doc/nds-sdat.html 432 | */ 433 | enum RecordName 434 | { 435 | REC_SEQ, 436 | REC_SEQARC, 437 | REC_BANK, 438 | REC_WAVEARC, 439 | REC_PLAYER, 440 | REC_GROUP, 441 | REC_PLAYER2, 442 | REC_STRM 443 | }; 444 | 445 | template inline bool VerifyHeader(const int8_t (&arr)[N], const std::string &header) 446 | { 447 | std::string arrHeader = std::string(&arr[0], &arr[N]); 448 | return arrHeader == header; 449 | } 450 | 451 | inline bool FileExists(const std::string &filename) 452 | { 453 | std::ifstream file(filename.c_str()); 454 | return !!file; 455 | } 456 | 457 | /* 458 | * Wildcard matching code by M Shahid Shafiq, from: 459 | * http://www.codeproject.com/Articles/19694/String-Wildcard-Matching-and 460 | */ 461 | inline bool WildcardCompare(const std::string &tameText, const std::string &wildText) 462 | { 463 | enum State 464 | { 465 | Exact, // exact match 466 | Any, // ? 467 | AnyRepeat // * 468 | }; 469 | 470 | const char *str = tameText.c_str(); 471 | const char *pattern = wildText.c_str(); 472 | const char *q = nullptr; 473 | State state = Exact; 474 | 475 | bool match = true; 476 | while (match && *pattern) 477 | { 478 | if (*pattern == '*') 479 | { 480 | state = AnyRepeat; 481 | q = pattern + 1; 482 | } 483 | else if (*pattern == '?') 484 | state = Any; 485 | else 486 | state = Exact; 487 | 488 | if (!*str) 489 | break; 490 | 491 | switch (state) 492 | { 493 | case Exact: 494 | match = std::toupper(*str) == std::toupper(*pattern); 495 | ++str; 496 | ++pattern; 497 | break; 498 | 499 | case Any: 500 | match = true; 501 | ++str; 502 | ++pattern; 503 | break; 504 | 505 | case AnyRepeat: 506 | match = true; 507 | ++str; 508 | 509 | if (std::toupper(*str) == std::toupper(*q)) 510 | ++pattern; 511 | } 512 | } 513 | 514 | if (state == AnyRepeat) 515 | return std::toupper(*str) == std::toupper(*q); 516 | else if (state == Any) 517 | return std::toupper(*str) == std::toupper(*pattern); 518 | else 519 | return match && std::toupper(*str) == std::toupper(*pattern); 520 | } 521 | 522 | // The following are for handling a vector of included or excluded files 523 | enum KeepType 524 | { 525 | KEEP_EXCLUDE, 526 | KEEP_INCLUDE, 527 | KEEP_NEITHER 528 | }; 529 | 530 | struct KeepInfo 531 | { 532 | std::string filename; 533 | KeepType keep; 534 | 535 | KeepInfo(const std::string &fn = "", KeepType toKeep = KEEP_NEITHER) : filename(fn), keep(toKeep) 536 | { 537 | } 538 | }; 539 | 540 | typedef std::vector IncOrExc; 541 | 542 | inline KeepType IncludeFilename(const std::string &filename, const std::string &sdatNumber, const IncOrExc &includesAndExcludes) 543 | { 544 | KeepType keep = KEEP_NEITHER; 545 | std::for_each(includesAndExcludes.begin(), includesAndExcludes.end(), [&](const KeepInfo &info) 546 | { 547 | size_t slash = info.filename.find('/'); 548 | if (slash != std::string::npos) 549 | { 550 | std::string currSDATNumber = info.filename.substr(0, slash); 551 | std::string currFilename = info.filename.substr(slash + 1); 552 | if (WildcardCompare(sdatNumber, currSDATNumber) && WildcardCompare(filename, currFilename)) 553 | keep = info.keep; 554 | } 555 | else if (WildcardCompare(filename, info.filename)) 556 | keep = info.keep; 557 | }); 558 | return keep; 559 | } 560 | 561 | // Check if the directory exists 562 | inline bool DirExists(const std::string &dirName) 563 | { 564 | struct stat st; 565 | if (!stat(dirName.c_str(), &st)) 566 | return S_ISDIR(st.st_mode); 567 | return false; 568 | } 569 | 570 | // Make the directory given 571 | inline void MakeDir(const std::string &dirName) 572 | { 573 | mkdir(dirName.c_str(), 0755); 574 | } 575 | 576 | // Get just the filename from a path 577 | inline std::string GetFilenameFromPath(const std::string &path) 578 | { 579 | size_t lastSlash = path.rfind('/'); 580 | if (lastSlash == std::string::npos) 581 | return path; 582 | return path.substr(lastSlash + 1); 583 | } 584 | 585 | // Convert a time from seconds into a human readable string 586 | inline std::string SecondsToString(double seconds) 587 | { 588 | uint32_t minutes = static_cast(seconds / 60); 589 | seconds -= minutes * 60; 590 | 591 | std::string time; 592 | if (minutes < 10) 593 | time += "0"; 594 | time += stringify(minutes) + ":"; 595 | if (seconds < 10) 596 | time += "0"; 597 | time += stringify(seconds); 598 | return time; 599 | } 600 | 601 | // Comes from http://techoverflow.net/blog/2013/01/25/efficiently-encoding-variable-length-integers-in-cc/ 602 | // But modified to use a vector instead 603 | template inline std::vector EncodeVarLen(T value) 604 | { 605 | std::vector output; 606 | // While more than 7 bits of data are left, occupy the last output byte and set the next byte flag 607 | while (value > 127) 608 | { 609 | output.push_back((value & 0x7F) | 0x80); 610 | // Remove the seven bits we just wrote 611 | value >>= 7; 612 | } 613 | output.push_back(value & 0x7F); 614 | return output; 615 | } 616 | 617 | // The following functions are for the options parser 618 | 619 | inline option::ArgStatus RequireArgument(const option::Option &opt, bool msg) 620 | { 621 | if (opt.arg && *opt.arg) 622 | return option::ARG_OK; 623 | 624 | if (msg) 625 | std::cerr << "Option '" << std::string(opt.name).substr(0, opt.namelen) << "' requires a non-empty argument.\n"; 626 | return option::ARG_ILLEGAL; 627 | } 628 | 629 | inline bool IsDigitsOnly(const std::string &input, const std::locale &loc = std::locale::classic()) 630 | { 631 | auto inputChars = std::vector(input.begin(), input.end()); 632 | size_t length = inputChars.size(); 633 | auto masks = std::vector::mask>(length); 634 | std::use_facet>(loc).is(&inputChars[0], &inputChars[length], &masks[0]); 635 | for (size_t x = 0; x < length; ++x) 636 | if (inputChars[x] != '.' && !(masks[x] & std::ctype::digit)) 637 | return false; 638 | return true; 639 | } 640 | 641 | inline option::ArgStatus RequireNumericArgument(const option::Option &opt, bool msg) 642 | { 643 | if (opt.arg && *opt.arg && IsDigitsOnly(opt.arg)) 644 | return option::ARG_OK; 645 | 646 | if (msg) 647 | std::cerr << "Option '" << std::string(opt.name).substr(0, opt.namelen) << "' requires a non-empty numeric argument.\n"; 648 | return option::ARG_ILLEGAL; 649 | } 650 | -------------------------------------------------------------------------------- /common/win_dirent.h: -------------------------------------------------------------------------------- 1 | /* 2 | * dirent.h - dirent API for Microsoft Visual Studio 3 | * 4 | * Copyright (C) 2006-2012 Toni Ronkko 5 | * 6 | * Permission is hereby granted, free of charge, to any person obtaining 7 | * a copy of this software and associated documentation files (the 8 | * ``Software''), to deal in the Software without restriction, including 9 | * without limitation the rights to use, copy, modify, merge, publish, 10 | * distribute, sublicense, and/or sell copies of the Software, and to 11 | * permit persons to whom the Software is furnished to do so, subject to 12 | * the following conditions: 13 | * 14 | * The above copyright notice and this permission notice shall be included 15 | * in all copies or substantial portions of the Software. 16 | * 17 | * THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS 18 | * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 19 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 20 | * IN NO EVENT SHALL TONI RONKKO BE LIABLE FOR ANY CLAIM, DAMAGES OR 21 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 22 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 23 | * OTHER DEALINGS IN THE SOFTWARE. 24 | * 25 | * $Id: dirent.h,v 1.20 2014/03/19 17:52:23 tronkko Exp $ 26 | */ 27 | 28 | #pragma once 29 | 30 | /* 31 | * Define architecture flags so we don't need to include windows.h. 32 | * Avoiding windows.h makes it simpler to use windows sockets in conjunction 33 | * with dirent.h. 34 | */ 35 | #if !defined(_68K_) && !defined(_MPPC_) && !defined(_X86_) && !defined(_IA64_) && !defined(_AMD64_) && defined(_M_IX86) 36 | # define _X86_ 37 | #endif 38 | #if !defined(_68K_) && !defined(_MPPC_) && !defined(_X86_) && !defined(_IA64_) && !defined(_AMD64_) && defined(_M_AMD64) 39 | # define _AMD64_ 40 | #endif 41 | 42 | #include 43 | #include 44 | #include 45 | #include 46 | #include 47 | #include 48 | #include 49 | #include 50 | #include 51 | #include 52 | #include 53 | 54 | /* Indicates that d_type field is available in dirent structure */ 55 | #define _DIRENT_HAVE_D_TYPE 56 | 57 | /* Indicates that d_namlen field is available in dirent structure */ 58 | #define _DIRENT_HAVE_D_NAMLEN 59 | 60 | /* Entries missing from MSVC 6.0 */ 61 | #ifndef FILE_ATTRIBUTE_DEVICE 62 | # define FILE_ATTRIBUTE_DEVICE 0x40 63 | #endif 64 | 65 | /* File type and permission flags for stat() */ 66 | #ifndef S_IFMT 67 | # define S_IFMT _S_IFMT /* File type mask */ 68 | #endif 69 | #ifndef S_IFDIR 70 | # define S_IFDIR _S_IFDIR /* Directory */ 71 | #endif 72 | #ifndef S_IFCHR 73 | # define S_IFCHR _S_IFCHR /* Character device */ 74 | #endif 75 | #ifndef S_IFFIFO 76 | # define S_IFFIFO _S_IFFIFO /* Pipe */ 77 | #endif 78 | #ifndef S_IFREG 79 | # define S_IFREG _S_IFREG /* Regular file */ 80 | #endif 81 | #ifndef S_IREAD 82 | # define S_IREAD _S_IREAD /* Read permission */ 83 | #endif 84 | #ifndef S_IWRITE 85 | # define S_IWRITE _S_IWRITE /* Write permission */ 86 | #endif 87 | #ifndef S_IEXEC 88 | # define S_IEXEC _S_IEXEC /* Execute permission */ 89 | #endif 90 | #ifndef S_IFIFO 91 | # define S_IFIFO _S_IFIFO /* Pipe */ 92 | #endif 93 | #ifndef S_IFBLK 94 | # define S_IFBLK 0 /* Block device */ 95 | #endif 96 | #ifndef S_IFLNK 97 | # define S_IFLNK 0 /* Link */ 98 | #endif 99 | #ifndef S_IFSOCK 100 | # define S_IFSOCK 0 /* Socket */ 101 | #endif 102 | 103 | #ifdef _MSC_VER 104 | # define S_IRUSR S_IREAD /* Read user */ 105 | # define S_IWUSR S_IWRITE /* Write user */ 106 | # define S_IXUSR 0 /* Execute user */ 107 | # define S_IRGRP 0 /* Read group */ 108 | # define S_IWGRP 0 /* Write group */ 109 | # define S_IXGRP 0 /* Execute group */ 110 | # define S_IROTH 0 /* Read others */ 111 | # define S_IWOTH 0 /* Write others */ 112 | # define S_IXOTH 0 /* Execute others */ 113 | #endif 114 | 115 | /* Maximum length of file name */ 116 | #ifndef PATH_MAX 117 | # define PATH_MAX MAX_PATH 118 | #endif 119 | #ifndef FILENAME_MAX 120 | # define FILENAME_MAX MAX_PATH 121 | #endif 122 | #ifndef NAME_MAX 123 | # define NAME_MAX FILENAME_MAX 124 | #endif 125 | 126 | /* File type flags for d_type */ 127 | #define DT_UNKNOWN 0 128 | #define DT_REG S_IFREG 129 | #define DT_DIR S_IFDIR 130 | #define DT_FIFO S_IFIFO 131 | #define DT_SOCK S_IFSOCK 132 | #define DT_CHR S_IFCHR 133 | #define DT_BLK S_IFBLK 134 | #define DT_LNK S_IFLNK 135 | 136 | /* Macros for converting between st_mode and d_type */ 137 | #define IFTODT(mode) ((mode) & S_IFMT) 138 | #define DTTOIF(type) (type) 139 | 140 | /* 141 | * File type macros. Note that block devices, sockets and links cannot be 142 | * distinguished on Windows and the macros S_ISBLK, S_ISSOCK and S_ISLNK are 143 | * only defined for compatibility. These macros should always return false 144 | * on Windows. 145 | */ 146 | #define S_ISFIFO(mode) (((mode) & S_IFMT) == S_IFIFO) 147 | #define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR) 148 | #define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG) 149 | #define S_ISLNK(mode) (((mode) & S_IFMT) == S_IFLNK) 150 | #define S_ISSOCK(mode) (((mode) & S_IFMT) == S_IFSOCK) 151 | #define S_ISCHR(mode) (((mode) & S_IFMT) == S_IFCHR) 152 | #define S_ISBLK(mode) (((mode) & S_IFMT) == S_IFBLK) 153 | 154 | /* Return the exact length of d_namlen without zero terminator */ 155 | #define _D_EXACT_NAMLEN(p) ((p)->d_namlen) 156 | 157 | /* Return number of bytes needed to store d_namlen */ 158 | #define _D_ALLOC_NAMLEN(p) (PATH_MAX) 159 | 160 | /* Wide-character version */ 161 | struct _wdirent 162 | { 163 | long d_ino; /* Always zero */ 164 | unsigned short d_reclen; /* Structure size */ 165 | size_t d_namlen; /* Length of name without \0 */ 166 | int d_type; /* File type */ 167 | wchar_t d_name[PATH_MAX]; /* File name */ 168 | }; 169 | 170 | struct _WDIR 171 | { 172 | _wdirent ent; /* Current directory entry */ 173 | WIN32_FIND_DATAW data; /* Private file data */ 174 | int cached; /* True if data is valid */ 175 | HANDLE handle; /* Win32 search handle */ 176 | wchar_t *patt; /* Initial directory name */ 177 | }; 178 | 179 | static _WDIR *_wopendir(const wchar_t *dirname); 180 | static _wdirent *_wreaddir(_WDIR *dirp); 181 | static int _wclosedir(_WDIR *dirp); 182 | static void _wrewinddir(_WDIR* dirp); 183 | 184 | /* For compatibility with Symbian */ 185 | #define wdirent _wdirent 186 | #define WDIR _WDIR 187 | #define wopendir _wopendir 188 | #define wreaddir _wreaddir 189 | #define wclosedir _wclosedir 190 | #define wrewinddir _wrewinddir 191 | 192 | /* Multi-byte character versions */ 193 | struct dirent 194 | { 195 | long d_ino; /* Always zero */ 196 | unsigned short d_reclen; /* Structure size */ 197 | size_t d_namlen; /* Length of name without \0 */ 198 | int d_type; /* File type */ 199 | char d_name[PATH_MAX]; /* File name */ 200 | }; 201 | 202 | struct DIR 203 | { 204 | dirent ent; 205 | _WDIR *wdirp; 206 | }; 207 | 208 | static DIR *opendir(const char *dirname); 209 | static dirent *readdir(DIR *dirp); 210 | static int closedir(DIR *dirp); 211 | static void rewinddir(DIR *dirp); 212 | 213 | /* Internal utility functions */ 214 | static WIN32_FIND_DATAW *dirent_first(_WDIR *dirp); 215 | static WIN32_FIND_DATAW *dirent_next(_WDIR *dirp); 216 | 217 | static int dirent_mbstowcs_s(size_t *pReturnValue, wchar_t *wcstr, size_t sizeInWords, const char *mbstr, size_t count); 218 | 219 | static int dirent_wcstombs_s(size_t *pReturnValue, char *mbstr, size_t sizeInBytes, const wchar_t *wcstr, size_t count); 220 | 221 | static void dirent_set_errno(int error); 222 | 223 | /* 224 | * Open directory stream DIRNAME for read and return a pointer to the 225 | * internal working area that is used to retrieve individual directory 226 | * entries. 227 | */ 228 | static _WDIR *_wopendir(const wchar_t *dirname) 229 | { 230 | /* Must have directory name */ 231 | if (!dirname || !dirname[0]) 232 | { 233 | dirent_set_errno(ENOENT); 234 | return nullptr; 235 | } 236 | 237 | /* Allocate new _WDIR structure */ 238 | _WDIR *dirp = static_cast<_WDIR *>(malloc(sizeof(_WDIR))); 239 | int error; 240 | if (dirp) 241 | { 242 | /* Reset _WDIR structure */ 243 | dirp->handle = INVALID_HANDLE_VALUE; 244 | dirp->cached = 0; 245 | 246 | /* Compute the length of full path plus zero terminator */ 247 | DWORD n = GetFullPathNameW(dirname, 0, nullptr, nullptr); 248 | 249 | /* Allocate room for absolute directory name and search pattern */ 250 | dirp->patt = static_cast(malloc(sizeof(wchar_t) * n + 16)); 251 | if (dirp->patt) 252 | { 253 | /* 254 | * Convert relative directory name to an absolute one. This 255 | * allows rewinddir() to function correctly even when current 256 | * working directory is changed between opendir() and rewinddir(). 257 | */ 258 | n = GetFullPathNameW(dirname, n, dirp->patt, nullptr); 259 | if (n > 0) 260 | { 261 | /* Append search pattern \* to the directory name */ 262 | wchar_t *p = dirp->patt + n; 263 | if (dirp->patt < p) 264 | { 265 | switch (p[-1]) 266 | { 267 | case '\\': 268 | case '/': 269 | case ':': 270 | /* Directory ends in path separator, e.g. c:\temp\ */ 271 | /*NOP*/ 272 | break; 273 | 274 | default: 275 | /* Directory name doesn't end in path separator */ 276 | *p++ = '\\'; 277 | } 278 | } 279 | *p++ = '*'; 280 | *p = '\0'; 281 | 282 | /* Open directory stream and retrieve the first entry */ 283 | if (dirent_first(dirp)) 284 | /* Directory stream opened successfully */ 285 | error = 0; 286 | else 287 | { 288 | /* Cannot retrieve first entry */ 289 | error = 1; 290 | dirent_set_errno(ENOENT); 291 | } 292 | } 293 | else 294 | { 295 | /* Cannot retrieve full path name */ 296 | dirent_set_errno(ENOENT); 297 | error = 1; 298 | } 299 | } 300 | else 301 | /* Cannot allocate memory for search pattern */ 302 | error = 1; 303 | } 304 | else 305 | /* Cannot allocate _WDIR structure */ 306 | error = 1; 307 | 308 | /* Clean up in case of error */ 309 | if (error && dirp) 310 | { 311 | _wclosedir(dirp); 312 | dirp = nullptr; 313 | } 314 | 315 | return dirp; 316 | } 317 | 318 | /* 319 | * Read next directory entry. The directory entry is returned in dirent 320 | * structure in the d_name field. Individual directory entries returned by 321 | * this function include regular files, sub-directories, pseudo-directories 322 | * "." and ".." as well as volume labels, hidden files and system files. 323 | */ 324 | static _wdirent *_wreaddir(_WDIR *dirp) 325 | { 326 | /* Read next directory entry */ 327 | WIN32_FIND_DATAW *datap = dirent_next(dirp); 328 | _wdirent *entp; 329 | if (datap) 330 | { 331 | /* Pointer to directory entry to return */ 332 | entp = &dirp->ent; 333 | 334 | /* 335 | * Copy file name as wide-character string. If the file name is too 336 | * long to fit in to the destination buffer, then truncate file name 337 | * to PATH_MAX characters and zero-terminate the buffer. 338 | */ 339 | size_t n = 0; 340 | while (n + 1 < PATH_MAX && datap->cFileName[n]) 341 | { 342 | entp->d_name[n] = datap->cFileName[n]; 343 | ++n; 344 | } 345 | dirp->ent.d_name[n] = 0; 346 | 347 | /* Length of file name excluding zero terminator */ 348 | entp->d_namlen = n; 349 | 350 | /* File type */ 351 | DWORD attr = datap->dwFileAttributes; 352 | if (attr & FILE_ATTRIBUTE_DEVICE) 353 | entp->d_type = DT_CHR; 354 | else if (attr & FILE_ATTRIBUTE_DIRECTORY) 355 | entp->d_type = DT_DIR; 356 | else 357 | entp->d_type = DT_REG; 358 | 359 | /* Reset dummy fields */ 360 | entp->d_ino = 0; 361 | entp->d_reclen = sizeof(_wdirent); 362 | } 363 | else 364 | /* Last directory entry read */ 365 | entp = nullptr; 366 | 367 | return entp; 368 | } 369 | 370 | /* 371 | * Close directory stream opened by opendir() function. This invalidates the 372 | * DIR structure as well as any directory entry read previously by 373 | * _wreaddir(). 374 | */ 375 | static int _wclosedir(_WDIR *dirp) 376 | { 377 | int ok; 378 | if (dirp) 379 | { 380 | /* Release search handle */ 381 | if (dirp->handle != INVALID_HANDLE_VALUE) 382 | { 383 | FindClose(dirp->handle); 384 | dirp->handle = INVALID_HANDLE_VALUE; 385 | } 386 | 387 | /* Release search pattern */ 388 | if (dirp->patt) 389 | { 390 | free(dirp->patt); 391 | dirp->patt = nullptr; 392 | } 393 | 394 | /* Release directory structure */ 395 | free(dirp); 396 | ok = /*success*/0; 397 | } 398 | else 399 | { 400 | /* Invalid directory stream */ 401 | dirent_set_errno(EBADF); 402 | ok = /*failure*/-1; 403 | } 404 | return ok; 405 | } 406 | 407 | /* 408 | * Rewind directory stream such that _wreaddir() returns the very first 409 | * file name again. 410 | */ 411 | static void _wrewinddir(_WDIR* dirp) 412 | { 413 | if (dirp) 414 | { 415 | /* Release existing search handle */ 416 | if (dirp->handle != INVALID_HANDLE_VALUE) 417 | FindClose(dirp->handle); 418 | 419 | /* Open new search handle */ 420 | dirent_first(dirp); 421 | } 422 | } 423 | 424 | /* Get first directory entry (internal) */ 425 | static WIN32_FIND_DATAW *dirent_first(_WDIR *dirp) 426 | { 427 | /* Open directory and retrieve the first entry */ 428 | dirp->handle = FindFirstFileW(dirp->patt, &dirp->data); 429 | WIN32_FIND_DATAW *datap; 430 | if (dirp->handle != INVALID_HANDLE_VALUE) 431 | { 432 | /* a directory entry is now waiting in memory */ 433 | datap = &dirp->data; 434 | dirp->cached = 1; 435 | } 436 | else 437 | { 438 | /* Failed to re-open directory: no directory entry in memory */ 439 | dirp->cached = 0; 440 | datap = nullptr; 441 | } 442 | return datap; 443 | } 444 | 445 | /* Get next directory entry (internal) */ 446 | static WIN32_FIND_DATAW *dirent_next(_WDIR *dirp) 447 | { 448 | WIN32_FIND_DATAW *p; 449 | 450 | /* Get next directory entry */ 451 | if (dirp->cached) 452 | { 453 | /* A valid directory entry already in memory */ 454 | p = &dirp->data; 455 | dirp->cached = 0; 456 | } 457 | else if (dirp->handle != INVALID_HANDLE_VALUE) 458 | { 459 | /* Get the next directory entry from stream */ 460 | if (!!FindNextFileW(dirp->handle, &dirp->data)) 461 | /* Got a file */ 462 | p = &dirp->data; 463 | else 464 | { 465 | /* The very last entry has been processed or an error occured */ 466 | FindClose(dirp->handle); 467 | dirp->handle = INVALID_HANDLE_VALUE; 468 | p = nullptr; 469 | } 470 | } 471 | else 472 | /* End of directory stream reached */ 473 | p = NULL; 474 | 475 | return p; 476 | } 477 | 478 | /* 479 | * Open directory stream using plain old C-string. 480 | */ 481 | static DIR *opendir(const char *dirname) 482 | { 483 | /* Must have directory name */ 484 | if (!dirname || !dirname[0]) 485 | { 486 | dirent_set_errno(ENOENT); 487 | return nullptr; 488 | } 489 | 490 | /* Allocate memory for DIR structure */ 491 | DIR *dirp = static_cast(malloc(sizeof(struct DIR))); 492 | int error; 493 | if (dirp) 494 | { 495 | wchar_t wname[PATH_MAX]; 496 | size_t n; 497 | 498 | /* Convert directory name to wide-character string */ 499 | error = dirent_mbstowcs_s(&n, wname, PATH_MAX, dirname, PATH_MAX); 500 | if (!error) 501 | { 502 | /* Open directory stream using wide-character name */ 503 | dirp->wdirp = _wopendir(wname); 504 | if (dirp->wdirp) 505 | /* Directory stream opened */ 506 | error = 0; 507 | else 508 | /* Failed to open directory stream */ 509 | error = 1; 510 | } 511 | else 512 | /* 513 | * Cannot convert file name to wide-character string. This 514 | * occurs if the string contains invalid multi-byte sequences or 515 | * the output buffer is too small to contain the resulting 516 | * string. 517 | */ 518 | error = 1; 519 | } 520 | else 521 | /* Cannot allocate DIR structure */ 522 | error = 1; 523 | 524 | /* Clean up in case of error */ 525 | if (error && dirp) 526 | { 527 | free(dirp); 528 | dirp = nullptr; 529 | } 530 | 531 | return dirp; 532 | } 533 | 534 | /* 535 | * Read next directory entry. 536 | * 537 | * When working with text consoles, please note that file names returned by 538 | * readdir() are represented in the default ANSI code page while any output to 539 | * console is typically formatted on another code page. Thus, non-ASCII 540 | * characters in file names will not usually display correctly on console. The 541 | * problem can be fixed in two ways: (1) change the character set of console 542 | * to 1252 using chcp utility and use Lucida Console font, or (2) use 543 | * _cprintf function when writing to console. The _cprinf() will re-encode 544 | * ANSI strings to the console code page so many non-ASCII characters will 545 | * display correcly. 546 | */ 547 | static dirent *readdir(DIR *dirp) 548 | { 549 | /* Read next directory entry */ 550 | WIN32_FIND_DATAW *datap = dirent_next(dirp->wdirp); 551 | dirent *entp; 552 | if (datap) 553 | { 554 | size_t n; 555 | 556 | /* Attempt to convert file name to multi-byte string */ 557 | int error = dirent_wcstombs_s(&n, dirp->ent.d_name, PATH_MAX, datap->cFileName, PATH_MAX); 558 | 559 | /* 560 | * If the file name cannot be represented by a multi-byte string, 561 | * then attempt to use old 8+3 file name. This allows traditional 562 | * Unix-code to access some file names despite of unicode 563 | * characters, although file names may seem unfamiliar to the user. 564 | * 565 | * Be ware that the code below cannot come up with a short file 566 | * name unless the file system provides one. At least 567 | * VirtualBox shared folders fail to do this. 568 | */ 569 | if (error && datap->cAlternateFileName[0]) 570 | error = dirent_wcstombs_s(&n, dirp->ent.d_name, PATH_MAX, datap->cAlternateFileName, PATH_MAX); 571 | 572 | if (!error) 573 | { 574 | /* Initialize directory entry for return */ 575 | entp = &dirp->ent; 576 | 577 | /* Length of file name excluding zero terminator */ 578 | entp->d_namlen = n - 1; 579 | 580 | /* File attributes */ 581 | DWORD attr = datap->dwFileAttributes; 582 | if (attr & FILE_ATTRIBUTE_DEVICE) 583 | entp->d_type = DT_CHR; 584 | else if (attr & FILE_ATTRIBUTE_DIRECTORY) 585 | entp->d_type = DT_DIR; 586 | else 587 | entp->d_type = DT_REG; 588 | 589 | /* Reset dummy fields */ 590 | entp->d_ino = 0; 591 | entp->d_reclen = sizeof(dirent); 592 | } 593 | else 594 | { 595 | /* 596 | * Cannot convert file name to multi-byte string so construct 597 | * an errornous directory entry and return that. Note that 598 | * we cannot return NULL as that would stop the processing 599 | * of directory entries completely. 600 | */ 601 | entp = &dirp->ent; 602 | entp->d_name[0] = '?'; 603 | entp->d_name[1] = '\0'; 604 | entp->d_namlen = 1; 605 | entp->d_type = DT_UNKNOWN; 606 | entp->d_ino = 0; 607 | entp->d_reclen = 0; 608 | } 609 | } 610 | else 611 | /* No more directory entries */ 612 | entp = nullptr; 613 | 614 | return entp; 615 | } 616 | 617 | /* 618 | * Close directory stream. 619 | */ 620 | static int closedir(DIR *dirp) 621 | { 622 | int ok; 623 | if (dirp) 624 | { 625 | /* Close wide-character directory stream */ 626 | ok = _wclosedir(dirp->wdirp); 627 | dirp->wdirp = nullptr; 628 | 629 | /* Release multi-byte character version */ 630 | free(dirp); 631 | } 632 | else 633 | { 634 | /* Invalid directory stream */ 635 | dirent_set_errno(EBADF); 636 | ok = /*failure*/-1; 637 | } 638 | return ok; 639 | } 640 | 641 | /* 642 | * Rewind directory stream to beginning. 643 | */ 644 | static void rewinddir(DIR *dirp) 645 | { 646 | /* Rewind wide-character string directory stream */ 647 | _wrewinddir(dirp->wdirp); 648 | } 649 | 650 | /* Convert multi-byte string to wide character string */ 651 | static int dirent_mbstowcs_s(size_t *pReturnValue, wchar_t *wcstr, size_t sizeInWords, const char *mbstr, size_t count) 652 | { 653 | int error; 654 | 655 | #if defined(_MSC_VER) && _MSC_VER >= 1400 656 | /* Microsoft Visual Studio 2005 or later */ 657 | error = mbstowcs_s(pReturnValue, wcstr, sizeInWords, mbstr, count); 658 | #else 659 | /* Older Visual Studio or non-Microsoft compiler */ 660 | 661 | /* Convert to wide-character string (or count characters) */ 662 | size_t n = mbstowcs(wcstr, mbstr, sizeInWords); 663 | if (!wcstr || n < count) 664 | { 665 | /* Zero-terminate output buffer */ 666 | if (wcstr && sizeInWords) 667 | { 668 | if (n >= sizeInWords) 669 | n = sizeInWords - 1; 670 | wcstr[n] = 0; 671 | } 672 | 673 | /* Length of resuting multi-byte string WITH zero terminator */ 674 | if (pReturnValue) 675 | *pReturnValue = n + 1; 676 | 677 | /* Success */ 678 | error = 0; 679 | } 680 | else 681 | /* Could not convert string */ 682 | error = 1; 683 | #endif 684 | 685 | return error; 686 | } 687 | 688 | /* Convert wide-character string to multi-byte string */ 689 | static int dirent_wcstombs_s(size_t *pReturnValue, char *mbstr, size_t sizeInBytes /* max size of mbstr */, const wchar_t *wcstr, size_t count) 690 | { 691 | int error; 692 | 693 | #if defined(_MSC_VER) && _MSC_VER >= 1400 694 | /* Microsoft Visual Studio 2005 or later */ 695 | error = wcstombs_s(pReturnValue, mbstr, sizeInBytes, wcstr, count); 696 | #else 697 | /* Older Visual Studio or non-Microsoft compiler */ 698 | 699 | /* Convert to multi-byte string (or count the number of bytes needed) */ 700 | size_t n = wcstombs(mbstr, wcstr, sizeInBytes); 701 | if (!mbstr || n < count) 702 | { 703 | /* Zero-terminate output buffer */ 704 | if (mbstr && sizeInBytes) 705 | { 706 | if (n >= sizeInBytes) 707 | n = sizeInBytes - 1; 708 | mbstr[n] = '\0'; 709 | } 710 | 711 | /* Lenght of resulting multi-bytes string WITH zero-terminator */ 712 | if (pReturnValue) 713 | *pReturnValue = n + 1; 714 | 715 | /* Success */ 716 | error = 0; 717 | } 718 | else 719 | /* Cannot convert string */ 720 | error = 1; 721 | #endif 722 | 723 | return error; 724 | } 725 | 726 | /* Set errno variable */ 727 | static void dirent_set_errno(int error) 728 | { 729 | #if defined(_MSC_VER) && _MSC_VER >= 1400 730 | /* Microsoft Visual Studio 2005 and later */ 731 | _set_errno(error); 732 | #else 733 | /* Non-Microsoft compiler or older Microsoft compiler */ 734 | errno = error; 735 | #endif 736 | } 737 | --------------------------------------------------------------------------------