tobid7/ctrff-pub
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Make ctrff usable again

Browse Source
This commit is contained in:
tobid7
2025-12-06 21:34:19 +01:00
parent b021609c4c
commit bfa6c9e92a
15 changed files with 97 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
include/ctrff/bcstm.hpp
View File

@@ -2,7 +2,6 @@
#include <ctrff/binutil.hpp> #include <ctrff/binutil.hpp>
#include <ctrff/types.hpp> #include <ctrff/types.hpp>
#include <palladium>
namespace ctrff { namespace ctrff {
class CTRFF_API BCSTM { class CTRFF_API BCSTM {

1
include/ctrff/bcwav.hpp
View File

@@ -2,7 +2,6 @@
#include <ctrff/binutil.hpp> #include <ctrff/binutil.hpp>
#include <ctrff/types.hpp> #include <ctrff/types.hpp>
#include <palladium>
namespace ctrff { namespace ctrff {
class CTRFF_API BCWAV { class CTRFF_API BCWAV {

1
include/ctrff/binutil.hpp
View File

@@ -1,7 +1,6 @@
#pragma once #pragma once
#include <ctrff/types.hpp> #include <ctrff/types.hpp>
#include <palladium>
namespace ctrff { namespace ctrff {
class BinFile { class BinFile {

1
include/ctrff/helper.hpp
View File

@@ -1,7 +1,6 @@
#pragma once #pragma once
#include <ctrff/types.hpp> #include <ctrff/types.hpp>
#include <palladium>
namespace ctrff { namespace ctrff {
CTRFF_API void String2U16(ctrff::u16 *res, const std::string &src, size_t max); CTRFF_API void String2U16(ctrff::u16 *res, const std::string &src, size_t max);

1
include/ctrff/lz11.hpp
View File

@@ -1,7 +1,6 @@
#pragma once #pragma once
#include <ctrff/types.hpp> #include <ctrff/types.hpp>
#include <palladium>
namespace ctrff { namespace ctrff {
namespace LZ11 { namespace LZ11 {

1
include/ctrff/smdh.hpp
View File

@@ -24,7 +24,6 @@ struct CTRFF_API SMDH {
} }
~SMDH() = default; ~SMDH() = default;
static SMDH Default(); static SMDH Default();
PD_SHARED(SMDH);
enum Language { enum Language {
Language_Japanese, Language_Japanese,

8
include/ctrff/types.hpp
View File

@@ -50,6 +50,14 @@ SOFTWARE.
#endif #endif
#include <cstddef> #include <cstddef>
#include <format>
#include <fstream>
#include <iostream>
#include <memory>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
namespace ctrff { namespace ctrff {
using u8 = unsigned char; using u8 = unsigned char;

12
source/bcstm.cpp
View File

@@ -1,7 +1,7 @@
#include <ctrff/bcstm.hpp> #include <ctrff/bcstm.hpp>
/** Using this a single time so inline it */ /** Using this a single time so inline it */
inline PD::u32 Swap32(PD::u32 in) { inline ctrff::u32 Swap32(ctrff::u32 in) {
return (in >> 24) | ((in >> 8) & 0x0000FF00) | ((in << 8) & 0x00FF0000) | return (in >> 24) | ((in >> 8) & 0x0000FF00) | ((in << 8) & 0x00FF0000) |
(in << 24); (in << 24);
} }
@@ -28,7 +28,7 @@ CTRFF_API void BCSTM::LoadFile(const std::string& path) {
pReader.Read(pHeader.FileSize); pReader.Read(pHeader.FileSize);
pReader.Read(pHeader.NumBlocks); pReader.Read(pHeader.NumBlocks);
pReader.Read(pHeader.Reserved); pReader.Read(pHeader.Reserved);
for (PD::u16 i = 0; i < pHeader.NumBlocks; i++) { for (ctrff::u16 i = 0; i < pHeader.NumBlocks; i++) {
SizedReference ref; SizedReference ref;
ReadSizedReference(ref); ReadSizedReference(ref);
if (ref.Ref.TypeID == Ref_InfoBlock) { if (ref.Ref.TypeID == Ref_InfoBlock) {
@@ -119,8 +119,8 @@ CTRFF_API void BCSTM::ReadSeekBlock(SD_Block& block) {
} }
pSeekBlock.Data.reserve(pSeekBlock.Header.Size + 1); pSeekBlock.Data.reserve(pSeekBlock.Header.Size + 1);
for (PD::u32 i = 0; i < pSeekBlock.Header.Size; i++) { for (ctrff::u32 i = 0; i < pSeekBlock.Header.Size; i++) {
PD::u8 v; ctrff::u8 v;
pReader.Read(v); pReader.Read(v);
pSeekBlock.Data.push_back(v); pSeekBlock.Data.push_back(v);
} }
@@ -129,7 +129,7 @@ CTRFF_API void BCSTM::ReadSeekBlock(SD_Block& block) {
CTRFF_API void BCSTM::ReadReferenceTab(ReferenceTable& tab) { CTRFF_API void BCSTM::ReadReferenceTab(ReferenceTable& tab) {
pReader.Read(tab.Count); pReader.Read(tab.Count);
tab.Refs.reserve(tab.Count + 1); tab.Refs.reserve(tab.Count + 1);
for (PD::u32 i = 0; i < tab.Count; i++) { for (ctrff::u32 i = 0; i < tab.Count; i++) {
Reference r; Reference r;
pReader.Read(r.TypeID); pReader.Read(r.TypeID);
pReader.Read(r.Padding); pReader.Read(r.Padding);
@@ -155,7 +155,7 @@ CTRFF_API void BCSTM::ReadGotoBeginning(bool use_loop_beg) {
} }
} }
CTRFF_API void BCSTM::ReadBlock(PD::u32 block, PD::u8* ref) { CTRFF_API void BCSTM::ReadBlock(ctrff::u32 block, ctrff::u8* ref) {
if (!ref) { if (!ref) {
throw std::runtime_error("BCSTM: pointer ref is nullptr!"); throw std::runtime_error("BCSTM: pointer ref is nullptr!");
} }

8
source/bcwav.cpp
View File

@@ -1,7 +1,7 @@
#include <ctrff/bcwav.hpp> #include <ctrff/bcwav.hpp>
/** Using this a single time so inline it */ /** Using this a single time so inline it */
inline PD::u32 Swap32(PD::u32 in) { inline ctrff::u32 Swap32(ctrff::u32 in) {
return (in >> 24) | ((in >> 8) & 0x0000FF00) | ((in << 8) & 0x00FF0000) | return (in >> 24) | ((in >> 8) & 0x0000FF00) | ((in << 8) & 0x00FF0000) |
(in << 24); (in << 24);
} }
@@ -28,7 +28,7 @@ CTRFF_API void BCWAV::LoadFile(const std::string& path) {
pReader.Read(pHeader.FileSize); pReader.Read(pHeader.FileSize);
pReader.Read(pHeader.NumBlocks); pReader.Read(pHeader.NumBlocks);
pReader.Read(pHeader.Reserved); pReader.Read(pHeader.Reserved);
for (PD::u16 i = 0; i < pHeader.NumBlocks; i++) { for (ctrff::u16 i = 0; i < pHeader.NumBlocks; i++) {
SizedReference ref; SizedReference ref;
ReadSizedReference(ref); ReadSizedReference(ref);
if (ref.Ref.TypeID == Ref_InfoBlock) { if (ref.Ref.TypeID == Ref_InfoBlock) {
@@ -86,7 +86,7 @@ CTRFF_API void BCWAV::ReadInfoBlock(InfoBlock& block) {
CTRFF_API void BCWAV::ReadReferenceTab(ReferenceTable& tab) { CTRFF_API void BCWAV::ReadReferenceTab(ReferenceTable& tab) {
pReader.Read(tab.Count); pReader.Read(tab.Count);
tab.Refs.reserve(tab.Count + 1); tab.Refs.reserve(tab.Count + 1);
for (PD::u32 i = 0; i < tab.Count; i++) { for (ctrff::u32 i = 0; i < tab.Count; i++) {
Reference r; Reference r;
pReader.Read(r.TypeID); pReader.Read(r.TypeID);
pReader.Read(r.Padding); pReader.Read(r.Padding);
@@ -111,7 +111,7 @@ CTRFF_API void BCWAV::ReadGotoBeginning(bool use_loop_beg) {
} }
} }
CTRFF_API void BCWAV::ReadBlock(PD::u32 block, PD::u8* ref) { CTRFF_API void BCWAV::ReadBlock(ctrff::u32 block, ctrff::u8* ref) {
// if (pFile.tellg() > pHeader.FileSize || block >= GetNumBlocks()) { // if (pFile.tellg() > pHeader.FileSize || block >= GetNumBlocks()) {
// throw std::runtime_error("BCWAV: Decode block Out of range!"); // throw std::runtime_error("BCWAV: Decode block Out of range!");
// } // }

22
source/binutil.cpp
View File

@@ -2,22 +2,22 @@
namespace ctrff { namespace ctrff {
/** Supported reads */ /** Supported reads */
template CTRFF_API void BinUtil::Read<PD::u8>(PD::u8&); template CTRFF_API void BinUtil::Read<ctrff::u8>(ctrff::u8&);
template CTRFF_API void BinUtil::Read<PD::u16>(PD::u16&); template CTRFF_API void BinUtil::Read<ctrff::u16>(ctrff::u16&);
template CTRFF_API void BinUtil::Read<PD::u32>(PD::u32&); template CTRFF_API void BinUtil::Read<ctrff::u32>(ctrff::u32&);
template CTRFF_API void BinUtil::Read<PD::u64>(PD::u64&); template CTRFF_API void BinUtil::Read<ctrff::u64>(ctrff::u64&);
/** Supported writes */ /** Supported writes */
template CTRFF_API void BinUtil::Write<PD::u8>(const PD::u8&); template CTRFF_API void BinUtil::Write<ctrff::u8>(const ctrff::u8&);
template CTRFF_API void BinUtil::Write<PD::u16>(const PD::u16&); template CTRFF_API void BinUtil::Write<ctrff::u16>(const ctrff::u16&);
template CTRFF_API void BinUtil::Write<PD::u32>(const PD::u32&); template CTRFF_API void BinUtil::Write<ctrff::u32>(const ctrff::u32&);
template CTRFF_API void BinUtil::Write<PD::u64>(const PD::u64&); template CTRFF_API void BinUtil::Write<ctrff::u64>(const ctrff::u64&);
template <typename T> template <typename T>
void BinUtil::Read(T& v) { void BinUtil::Read(T& v) {
// Check if Value could be Read // Check if Value could be Read
static_assert(std::is_integral<T>::value, "Cannot Read type T"); static_assert(std::is_integral<T>::value, "Cannot Read type T");
v = 0; // Set value to 0 (most cases a windows problem) v = 0; // Set value to 0 (most cases a windows problem)
std::vector<PD::u8> buf(sizeof(T), 0); // declare buffer std::vector<ctrff::u8> buf(sizeof(T), 0); // declare buffer
// Read data into buffer // Read data into buffer
m_file.read(reinterpret_cast<char*>(buf.data()), sizeof(T)); m_file.read(reinterpret_cast<char*>(buf.data()), sizeof(T));
// Loop or in be reverse loop and chift the values // Loop or in be reverse loop and chift the values
@@ -29,11 +29,11 @@ template <typename T>
void BinUtil::Write(const T& v) { void BinUtil::Write(const T& v) {
// Check if Value could Write // Check if Value could Write
static_assert(std::is_integral<T>::value, "Cannot Write type T"); static_assert(std::is_integral<T>::value, "Cannot Write type T");
std::vector<PD::u8> buf(sizeof(T), 0); // declare buffer std::vector<ctrff::u8> buf(sizeof(T), 0); // declare buffer
// Loop or in be reverse loop and write the values // Loop or in be reverse loop and write the values
for (size_t i = 0; i < sizeof(T); i++) { for (size_t i = 0; i < sizeof(T); i++) {
buf[(m_big ? sizeof(T) - 1 - i : i)] = buf[m_big ? sizeof(T) - 1 - i : i] = buf[(m_big ? sizeof(T) - 1 - i : i)] = buf[m_big ? sizeof(T) - 1 - i : i] =
static_cast<PD::u8>((v >> (8 * i)) & 0xFF); static_cast<ctrff::u8>((v >> (8 * i)) & 0xFF);
} }
// Write buffer into file // Write buffer into file
m_file.write(reinterpret_cast<const char*>(buf.data()), sizeof(T)); m_file.write(reinterpret_cast<const char*>(buf.data()), sizeof(T));

55
source/helper.cpp
View File

@@ -2,31 +2,33 @@
#include <cwchar> #include <cwchar>
#include <iostream> #include <iostream>
void MakePixelRGBA(PD::u8 &r, PD::u8 &g, PD::u8 &b, PD::u8 &a, PD::u16 px) { void MakePixelRGBA(ctrff::u8 &r, ctrff::u8 &g, ctrff::u8 &b, ctrff::u8 &a,
ctrff::u16 px) {
b = (px & 0x1f) << 3; b = (px & 0x1f) << 3;
g = ((px >> 0x5) & 0x3f) << 2; g = ((px >> 0x5) & 0x3f) << 2;
r = ((px >> 0xb) & 0x1f) << 3; r = ((px >> 0xb) & 0x1f) << 3;
a = 0xff; a = 0xff;
} }
CTRFF_API PD::u16 MakePixel565(const PD::u8 &r, const PD::u8 &g, CTRFF_API ctrff::u16 MakePixel565(const ctrff::u8 &r, const ctrff::u8 &g,
const PD::u8 &b) { const ctrff::u8 &b) {
PD::u16 res = 0; ctrff::u16 res = 0;
res |= (r & ~0x7) << 8; res |= (r & ~0x7) << 8;
res |= (g & ~0x3) << 3; res |= (g & ~0x3) << 3;
res |= (b) >> 3; res |= (b) >> 3;
return res; return res;
} }
CTRFF_API PD::u32 TileIndex(const int &x, const int &y, const int &w) { CTRFF_API ctrff::u32 TileIndex(const int &x, const int &y, const int &w) {
return (((y >> 3) * (w >> 3) + (x >> 3)) << 6) + return (((y >> 3) * (w >> 3) + (x >> 3)) << 6) +
((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) | ((y & 2) << 2) | ((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) | ((y & 2) << 2) |
((x & 4) << 2) | ((y & 4) << 3)); ((x & 4) << 2) | ((y & 4) << 3));
} }
// TODO: Fix colors // TODO: Fix colors
CTRFF_API void ctrff::RGB565toRGBA(std::vector<PD::u8> &img, PD::u16 *icon, CTRFF_API void ctrff::RGB565toRGBA(std::vector<ctrff::u8> &img,
const int &w, const int &h) { ctrff::u16 *icon, const int &w,
const int &h) {
if (img.size() != (48 * 48 * 4)) { if (img.size() != (48 * 48 * 4)) {
img.resize(48 * 48 * 4); img.resize(48 * 48 * 4);
img.clear(); img.clear();
@@ -34,36 +36,37 @@ CTRFF_API void ctrff::RGB565toRGBA(std::vector<PD::u8> &img, PD::u16 *icon,
for (int y = 0; y < h; y++) { for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++) { for (int x = 0; x < w; x++) {
auto idx = TileIndex(x, y, w); auto idx = TileIndex(x, y, w);
PD::u32 pos = (y * w + x) * 4; ctrff::u32 pos = (y * w + x) * 4;
MakePixelRGBA(img[pos + 0], img[pos + 1], img[pos + 2], img[pos + 3], MakePixelRGBA(img[pos + 0], img[pos + 1], img[pos + 2], img[pos + 3],
icon[idx]); icon[idx]);
} }
} }
} }
CTRFF_API void ctrff::RGBA2RGB565(PD::u16 *out, const std::vector<PD::u8> &img, CTRFF_API void ctrff::RGBA2RGB565(ctrff::u16 *out,
const std::vector<ctrff::u8> &img,
const int &w, const int &h) { const int &w, const int &h) {
if (img.size() != size_t(w * h * 4)) return; if (img.size() != size_t(w * h * 4)) return;
std::vector<PD::u8> px8 = img; std::vector<ctrff::u8> px8 = img;
for (int y = 0; y < h; y++) { for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++) { for (int x = 0; x < w; x++) {
auto idx = TileIndex(x, y, w); auto idx = TileIndex(x, y, w);
PD::u32 pos = (y * w + x) * 4; ctrff::u32 pos = (y * w + x) * 4;
out[idx] = MakePixel565(img[pos], img[pos + 1], img[pos + 2]); out[idx] = MakePixel565(img[pos], img[pos + 1], img[pos + 2]);
} }
} }
} }
CTRFF_API std::vector<PD::u8> ctrff::DownscaleImage( CTRFF_API std::vector<ctrff::u8> ctrff::DownscaleImage(
const std::vector<PD::u8> &img, int w, int h, int scale) { const std::vector<ctrff::u8> &img, int w, int h, int scale) {
std::vector<PD::u8> res(((w / scale) * (h / scale)) * 4); std::vector<ctrff::u8> res(((w / scale) * (h / scale)) * 4);
int samples = scale * scale; int samples = scale * scale;
for (int y = 0; y < h; y += scale) { for (int y = 0; y < h; y += scale) {
for (int x = 0; x < w; x += scale) { for (int x = 0; x < w; x += scale) {
PD::u32 r = 0; ctrff::u32 r = 0;
PD::u32 g = 0; ctrff::u32 g = 0;
PD::u32 b = 0; ctrff::u32 b = 0;
PD::u32 a = 0; ctrff::u32 a = 0;
for (int oy = 0; oy < scale; oy++) { for (int oy = 0; oy < scale; oy++) {
for (int ox = 0; ox < scale; ox++) { for (int ox = 0; ox < scale; ox++) {
int pos = ((y + oy) * w + (x + ox)) * 4; int pos = ((y + oy) * w + (x + ox)) * 4;
@@ -74,16 +77,16 @@ CTRFF_API std::vector<PD::u8> ctrff::DownscaleImage(
} }
} }
int pos = ((y / scale) * (w / scale) + (x / scale)) * 4; int pos = ((y / scale) * (w / scale) + (x / scale)) * 4;
res[pos++] = (PD::u8)(r / samples); res[pos++] = (ctrff::u8)(r / samples);
res[pos++] = (PD::u8)(g / samples); res[pos++] = (ctrff::u8)(g / samples);
res[pos++] = (PD::u8)(b / samples); res[pos++] = (ctrff::u8)(b / samples);
res[pos++] = (PD::u8)(a / samples); res[pos++] = (ctrff::u8)(a / samples);
} }
} }
return res; return res;
} }
CTRFF_API void ctrff::String2U16(PD::u16 *res, const std::string &src, CTRFF_API void ctrff::String2U16(ctrff::u16 *res, const std::string &src,
size_t max) { size_t max) {
/// GOT FORCED TO REPLACE std::wstring_convert by some /// GOT FORCED TO REPLACE std::wstring_convert by some
/// manual work as it got removed in cxx20 /// manual work as it got removed in cxx20
@@ -93,7 +96,7 @@ CTRFF_API void ctrff::String2U16(PD::u16 *res, const std::string &src,
size_t len = 0; size_t len = 0;
size_t i = 0; size_t i = 0;
while (i < src.size() && len < max) { while (i < src.size() && len < max) {
PD::u8 c = src[i]; ctrff::u8 c = src[i];
if (c < 0x80) { if (c < 0x80) {
// 1byte // 1byte
@@ -116,7 +119,7 @@ CTRFF_API void ctrff::String2U16(PD::u16 *res, const std::string &src,
// 4byte // 4byte
if (i + 3 >= src.size()) if (i + 3 >= src.size())
throw std::invalid_argument("Invalid UTF-8 sequence"); throw std::invalid_argument("Invalid UTF-8 sequence");
PD::u32 codepoint = ((c & 0x07) << 18) | ((src[i + 1] & 0x3F) << 12) | ctrff::u32 codepoint = ((c & 0x07) << 18) | ((src[i + 1] & 0x3F) << 12) |
((src[i + 2] & 0x3F) << 6) | (src[i + 3] & 0x3F); ((src[i + 2] & 0x3F) << 6) | (src[i + 3] & 0x3F);
codepoint -= 0x10000; codepoint -= 0x10000;
res[len++] = 0xD800 | ((codepoint >> 10) & 0x3FF); res[len++] = 0xD800 | ((codepoint >> 10) & 0x3FF);
@@ -128,7 +131,7 @@ CTRFF_API void ctrff::String2U16(PD::u16 *res, const std::string &src,
} }
} }
CTRFF_API std::string ctrff::U16toU8(PD::u16 *in, size_t max) { CTRFF_API std::string ctrff::U16toU8(ctrff::u16 *in, size_t max) {
/// GOT FORCED TO REPLACE std::wstring_convert by some /// GOT FORCED TO REPLACE std::wstring_convert by some
/// manual work as it got removed in cxx20 /// manual work as it got removed in cxx20
if (!in || max == 0) { if (!in || max == 0) {

49
source/lz11.cpp
View File

@@ -5,14 +5,14 @@
namespace ctrff { namespace ctrff {
namespace LZ11 { namespace LZ11 {
PD::u32 GetOccurenceLength(const PD::u8* new_ptr, size_t new_len, ctrff::u32 GetOccurenceLength(const ctrff::u8* new_ptr, size_t new_len,
const PD::u8* old_ptr, size_t old_len, const ctrff::u8* old_ptr, size_t old_len,
PD::u32& disp) { ctrff::u32& disp) {
disp = 0; disp = 0;
if (new_len == 0) { if (new_len == 0) {
return 0; return 0;
} }
PD::u32 res = 0; ctrff::u32 res = 0;
if (old_len > 0) { if (old_len > 0) {
for (size_t i = 0; i < old_len - 1; i++) { for (size_t i = 0; i < old_len - 1; i++) {
auto ref = old_ptr + i; auto ref = old_ptr + i;
@@ -35,20 +35,20 @@ PD::u32 GetOccurenceLength(const PD::u8* new_ptr, size_t new_len,
return res; return res;
} }
CTRFF_API std::vector<PD::u8> Compress(const std::vector<PD::u8>& in) { CTRFF_API std::vector<ctrff::u8> Compress(const std::vector<ctrff::u8>& in) {
if (in.size() > 0xFFFFFF) { if (in.size() > 0xFFFFFF) {
std::cout << "ERROR: LZ11 input is too large!" << std::endl; std::cout << "ERROR: LZ11 input is too large!" << std::endl;
return std::vector<PD::u8>(); return std::vector<ctrff::u8>();
} }
std::stringstream s; std::stringstream s;
// SETUP HEADER // // SETUP HEADER //
s << static_cast<PD::u8>(0x11); s << static_cast<ctrff::u8>(0x11);
s << static_cast<PD::u8>(in.size() & 0xFF); s << static_cast<ctrff::u8>(in.size() & 0xFF);
s << static_cast<PD::u8>((in.size() >> 8) & 0xFF); s << static_cast<ctrff::u8>((in.size() >> 8) & 0xFF);
s << static_cast<PD::u8>((in.size() >> 16) & 0xFF); s << static_cast<ctrff::u8>((in.size() >> 16) & 0xFF);
size_t res_len = 4; // 4-byte header size_t res_len = 4; // 4-byte header
PD::u8 out_buf[0x21]; // 33 bytes ctrff::u8 out_buf[0x21]; // 33 bytes
out_buf[0] = 0; out_buf[0] = 0;
size_t obl = 1; // out_buf_len size_t obl = 1; // out_buf_len
size_t buf_blocks = 0; size_t buf_blocks = 0;
@@ -63,7 +63,7 @@ CTRFF_API std::vector<PD::u8> Compress(const std::vector<PD::u8>& in) {
buf_blocks = 0; buf_blocks = 0;
} }
PD::u32 disp = 0; ctrff::u32 disp = 0;
size_t old_len = std::min(rb, static_cast<size_t>(0x1000)); size_t old_len = std::min(rb, static_cast<size_t>(0x1000));
size_t len = LZ11::GetOccurenceLength( size_t len = LZ11::GetOccurenceLength(
in.data() + rb, std::min(in.size() - rb, static_cast<size_t>(0x10110)), in.data() + rb, std::min(in.size() - rb, static_cast<size_t>(0x10110)),
@@ -73,21 +73,22 @@ CTRFF_API std::vector<PD::u8> Compress(const std::vector<PD::u8>& in) {
out_buf[obl++] = in[rb++]; out_buf[obl++] = in[rb++];
} else { } else {
rb += len; rb += len;
out_buf[0] |= static_cast<PD::u8>(1 << (7 - buf_blocks)); out_buf[0] |= static_cast<ctrff::u8>(1 << (7 - buf_blocks));
if (len > 0x110) { if (len > 0x110) {
out_buf[obl++] = out_buf[obl++] =
0x10 | static_cast<PD::u8>(((len - 0x111) >> 12) & 0x0F); 0x10 | static_cast<ctrff::u8>(((len - 0x111) >> 12) & 0x0F);
out_buf[obl++] = static_cast<PD::u8>(((len - 0x111) >> 4) & 0xFF); out_buf[obl++] = static_cast<ctrff::u8>(((len - 0x111) >> 4) & 0xFF);
out_buf[obl] = static_cast<PD::u8>(((len - 0x111) << 4) & 0xF0); out_buf[obl] = static_cast<ctrff::u8>(((len - 0x111) << 4) & 0xF0);
} else if (len > 0x10) { } else if (len > 0x10) {
out_buf[obl++] = 0x00 | static_cast<PD::u8>(((len - 0x11) >> 4) & 0x0F); out_buf[obl++] =
out_buf[obl] = static_cast<PD::u8>(((len - 0x11) << 4) & 0xF0); 0x00 | static_cast<ctrff::u8>(((len - 0x11) >> 4) & 0x0F);
out_buf[obl] = static_cast<ctrff::u8>(((len - 0x11) << 4) & 0xF0);
} else { } else {
out_buf[obl] |= static_cast<PD::u8>(((len - 1) << 4) & 0xF0); out_buf[obl] |= static_cast<ctrff::u8>(((len - 1) << 4) & 0xF0);
} }
obl++; obl++;
out_buf[obl++] = static_cast<PD::u8>(((disp - 1) >> 8) & 0x0F); out_buf[obl++] = static_cast<ctrff::u8>(((disp - 1) >> 8) & 0x0F);
out_buf[obl++] = static_cast<PD::u8>((disp - 1) & 0xFF); out_buf[obl++] = static_cast<ctrff::u8>((disp - 1) & 0xFF);
} }
buf_blocks++; buf_blocks++;
} }
@@ -98,13 +99,13 @@ CTRFF_API std::vector<PD::u8> Compress(const std::vector<PD::u8>& in) {
} }
if (res_len % 4 != 0) { if (res_len % 4 != 0) {
PD::u32 pad_len = 4 - (res_len % 4); ctrff::u32 pad_len = 4 - (res_len % 4);
PD::u8 pad[4] = {0}; ctrff::u8 pad[4] = {0};
s.write(reinterpret_cast<const char*>(pad), pad_len); s.write(reinterpret_cast<const char*>(pad), pad_len);
res_len += pad_len; res_len += pad_len;
} }
std::vector<PD::u8> res(res_len); std::vector<ctrff::u8> res(res_len);
s.read(reinterpret_cast<char*>(res.data()), res.size()); s.read(reinterpret_cast<char*>(res.data()), res.size());
return res; return res;
} }

6
source/smdh.cpp
View File

@@ -39,14 +39,14 @@ CTRFF_API void ctrff::SMDH::Read(std::fstream &f) {
f.read(reinterpret_cast<char *>(&IconLarge), sizeof(IconLarge)); f.read(reinterpret_cast<char *>(&IconLarge), sizeof(IconLarge));
} }
CTRFF_API void ctrff::SMDH::SetIcon(const std::vector<PD::u8> &buf) { CTRFF_API void ctrff::SMDH::SetIcon(const std::vector<ctrff::u8> &buf) {
RGBA2RGB565(IconLarge, buf, 48, 48); RGBA2RGB565(IconLarge, buf, 48, 48);
auto small_icon = DownscaleImage(buf, 48, 48, 2); auto small_icon = DownscaleImage(buf, 48, 48, 2);
RGBA2RGB565(IconSmall, small_icon, 24, 24); RGBA2RGB565(IconSmall, small_icon, 24, 24);
} }
CTRFF_API std::vector<PD::u8> ctrff::SMDH::GetIcon() { CTRFF_API std::vector<ctrff::u8> ctrff::SMDH::GetIcon() {
std::vector<PD::u8> res(48 * 48 * 4); std::vector<ctrff::u8> res(48 * 48 * 4);
ctrff::RGB565toRGBA(res, IconLarge, 48, 48); ctrff::RGB565toRGBA(res, IconLarge, 48, 48);
return res; return res;
} }

2
tool/main.cpp
View File

@@ -121,7 +121,7 @@ void MakeSMDH(const cf7::command::ArgumentList &data) {
smdh.SetAuthor(a); smdh.SetAuthor(a);
std::vector<unsigned char> img; std::vector<unsigned char> img;
int w, h, c; int w, h, c;
PD::u8 *buf = stbi_load(i.c_str(), &w, &h, &c, 4); ctrff::u8 *buf = stbi_load(i.c_str(), &w, &h, &c, 4);
if (buf == nullptr) { if (buf == nullptr) {
cf7::PrintFancy({ cf7::PrintFancy({
std::make_pair("Error", cf7::col(190, 0, 0)), std::make_pair("Error", cf7::col(190, 0, 0)),

16
tool/test.cpp
View File

@@ -16,20 +16,20 @@ void Result(const std::string& name, T a, T b) {
void BinTest(bool be) { void BinTest(bool be) {
std::fstream s("test.bin", std::ios::out | std::ios::binary); std::fstream s("test.bin", std::ios::out | std::ios::binary);
PD::u8 t8 = 0xdf; ctrff::u8 t8 = 0xdf;
PD::u16 t16 = 0x4564; ctrff::u16 t16 = 0x4564;
PD::u32 t32 = 0x58464743; ctrff::u32 t32 = 0x58464743;
PD::u64 t64 = 1234567890123456789ULL; ctrff::u64 t64 = 1234567890123456789ULL;
ctrff::BinUtil u(s, be); ctrff::BinUtil u(s, be);
u.Write(t8); u.Write(t8);
u.Write(t16); u.Write(t16);
u.Write(t32); u.Write(t32);
u.Write(t64); u.Write(t64);
s.close(); s.close();
PD::u8 r8 = 0; ctrff::u8 r8 = 0;
PD::u16 r16 = 0; ctrff::u16 r16 = 0;
PD::u32 r32 = 0; ctrff::u32 r32 = 0;
PD::u64 r64 = 0; ctrff::u64 r64 = 0;
s.open("test.bin", std::ios::in | std::ios::binary); s.open("test.bin", std::ios::in | std::ios::binary);
u.Read(r8); u.Read(r8);
u.Read(r16); u.Read(r16);