#include #include #include "TXTR.hpp" #include "PAK.hpp" #include "athena/FileWriter.hpp" #include "hecl/hecl.hpp" namespace DataSpec { static logvisor::Module Log("libpng"); static int CountBits(uint32_t n) { int ret = 0; for (int i = 0; i < 32; ++i) if (((n >> i) & 1) != 0) ++ret; return ret; } /* Box filter algorithm (for mipmapping) */ static void BoxFilter(const uint8_t* input, unsigned chanCount, unsigned inWidth, unsigned inHeight, uint8_t* output, bool dxt1) { unsigned mipWidth = 1; unsigned mipHeight = 1; if (inWidth > 1) mipWidth = inWidth / 2; if (inHeight > 1) mipHeight = inHeight / 2; unsigned y, x, c; for (y = 0; y < mipHeight; ++y) { unsigned miplineBase = mipWidth * y; unsigned in1LineBase = inWidth * (y * 2); unsigned in2LineBase = inWidth * (y * 2 + 1); for (x = 0; x < mipWidth; ++x) { uint8_t* out = &output[(miplineBase + x) * chanCount]; for (c = 0; c < chanCount; ++c) { uint32_t tmp = 0; tmp += input[(in1LineBase + (x * 2)) * chanCount + c]; tmp += input[(in1LineBase + (x * 2 + 1)) * chanCount + c]; tmp += input[(in2LineBase + (x * 2)) * chanCount + c]; tmp += input[(in2LineBase + (x * 2 + 1)) * chanCount + c]; out[c] = uint8_t(tmp / 4); if (c == 3 && dxt1) out[c] = uint8_t(out[c] ? 0xff : 0x0); } } } } static size_t ComputeMippedTexelCount(unsigned inWidth, unsigned inHeight) { size_t ret = 0; while (inWidth > 0 && inHeight > 0) { ret += inWidth * inHeight; inWidth /= 2; inHeight /= 2; } return ret; } /* GX uses this upsampling technique to extract full 8-bit range */ static inline uint8_t Convert3To8(uint8_t v) { /* Swizzle bits: 00000123 -> 12312312 */ return (v << 5) | (v << 2) | (v >> 1); } static inline uint8_t Convert8To3(uint8_t v) { return v >> 5; } static inline uint8_t Convert4To8(uint8_t v) { /* Swizzle bits: 00001234 -> 12341234 */ return (v << 4) | v; } static inline uint8_t Convert8To4(uint8_t v) { return v >> 4; } static inline uint8_t Convert5To8(uint8_t v) { /* Swizzle bits: 00012345 -> 12345123 */ return (v << 3) | (v >> 2); } static inline uint8_t Convert8To5(uint8_t v) { return v >> 3; } static inline uint8_t Convert6To8(uint8_t v) { /* Swizzle bits: 00123456 -> 12345612 */ return (v << 2) | (v >> 4); } static inline uint8_t Convert8To6(uint8_t v) { return v >> 2; } static inline uint8_t Lookup4BPP(const uint8_t* texels, int width, int x, int y) { int bwidth = (width + 7) / 8; int bx = x / 8; int by = y / 8; int rx = x % 8; int ry = y % 8; int bidx = by * bwidth + bx; const uint8_t* btexels = &texels[32 * bidx]; return btexels[ry * 4 + rx / 2] >> ((rx & 1) ? 0 : 4) & 0xf; } static inline void Set4BPP(uint8_t* texels, int width, int x, int y, uint8_t val) { int bwidth = (width + 7) / 8; int bx = x / 8; int by = y / 8; int rx = x % 8; int ry = y % 8; int bidx = by * bwidth + bx; uint8_t* btexels = &texels[32 * bidx]; btexels[ry * 4 + rx / 2] |= (val & 0xf) << ((rx & 1) ? 0 : 4); } static inline uint8_t Lookup8BPP(const uint8_t* texels, int width, int x, int y) { int bwidth = (width + 7) / 8; int bx = x / 8; int by = y / 4; int rx = x % 8; int ry = y % 4; int bidx = by * bwidth + bx; const uint8_t* btexels = &texels[32 * bidx]; return btexels[ry * 8 + rx]; } static inline void Set8BPP(uint8_t* texels, int width, int x, int y, uint8_t val) { int bwidth = (width + 7) / 8; int bx = x / 8; int by = y / 4; int rx = x % 8; int ry = y % 4; int bidx = by * bwidth + bx; uint8_t* btexels = &texels[32 * bidx]; btexels[ry * 8 + rx] = val; } static inline uint16_t Lookup16BPP(const uint8_t* texels, int width, int x, int y) { int bwidth = (width + 3) / 4; int bx = x / 4; int by = y / 4; int rx = x % 4; int ry = y % 4; int bidx = by * bwidth + bx; const uint16_t* btexels = (uint16_t*)&texels[32 * bidx]; return btexels[ry * 4 + rx]; } static inline void Set16BPP(uint8_t* texels, int width, int x, int y, uint16_t val) { int bwidth = (width + 3) / 4; int bx = x / 4; int by = y / 4; int rx = x % 4; int ry = y % 4; int bidx = by * bwidth + bx; uint16_t* btexels = (uint16_t*)&texels[32 * bidx]; btexels[ry * 4 + rx] = val; } static inline void LookupRGBA8(const uint8_t* texels, int width, int x, int y, uint8_t* r, uint8_t* g, uint8_t* b, uint8_t* a) { int bwidth = (width + 3) / 4; int bx = x / 4; int by = y / 4; int rx = x % 4; int ry = y % 4; int bidx = (by * bwidth + bx) * 2; const uint16_t* artexels = (uint16_t*)&texels[32 * bidx]; const uint16_t* gbtexels = (uint16_t*)&texels[32 * (bidx + 1)]; uint16_t ar = hecl::SBig(artexels[ry * 4 + rx]); *a = ar >> 8 & 0xff; *r = ar & 0xff; uint16_t gb = hecl::SBig(gbtexels[ry * 4 + rx]); *g = gb >> 8 & 0xff; *b = gb & 0xff; } static inline void SetRGBA8(uint8_t* texels, int width, int x, int y, uint8_t r, uint8_t g, uint8_t b, uint8_t a) { int bwidth = (width + 3) / 4; int bx = x / 4; int by = y / 4; int rx = x % 4; int ry = y % 4; int bidx = (by * bwidth + bx) * 2; uint16_t* artexels = (uint16_t*)&texels[32 * bidx]; uint16_t* gbtexels = (uint16_t*)&texels[32 * (bidx + 1)]; uint16_t ar = (a << 8) | r; artexels[ry * 4 + rx] = hecl::SBig(ar); uint16_t gb = (g << 8) | b; gbtexels[ry * 4 + rx] = hecl::SBig(gb); } static void DecodeI4(png_structp png, png_infop info, const uint8_t* texels, int width, int height) { png_set_IHDR(png, info, width, height, 8, PNG_COLOR_TYPE_GRAY, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); png_write_info(png, info); std::unique_ptr buf(new uint8_t[width]); // memset(buf.get(), 0, width); for (int y = height - 1; y >= 0; --y) { for (int x = 0; x < width; ++x) buf[x] = Convert4To8(Lookup4BPP(texels, width, x, y)); png_write_row(png, buf.get()); } } #if 0 static void EncodeI4(const uint8_t* rgbaIn, uint8_t* texels, int width, int height) { for (int y=height-1 ; y>=0 ; --y) { for (int x=0 ; x buf(new uint8_t[width]); for (int y = height - 1; y >= 0; --y) { for (int x = 0; x < width; ++x) buf[x] = Lookup8BPP(texels, width, x, y); png_write_row(png, buf.get()); } } static void EncodeI8(const uint8_t* rgbaIn, uint8_t* texels, int width, int height) { for (int y = height - 1; y >= 0; --y) { for (int x = 0; x < width; ++x) Set8BPP(texels, width, x, y, rgbaIn[x]); rgbaIn += width; } } static void DecodeIA4(png_structp png, png_infop info, const uint8_t* texels, int width, int height) { png_set_IHDR(png, info, width, height, 8, PNG_COLOR_TYPE_GRAY_ALPHA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); png_write_info(png, info); std::unique_ptr buf(new uint8_t[width * 2]); for (int y = height - 1; y >= 0; --y) { for (int x = 0; x < width; ++x) { uint8_t texel = Lookup8BPP(texels, width, x, y); buf[x * 2 ] = Convert4To8(texel & 0xf); buf[x * 2 + 1] = Convert4To8(texel >> 4 & 0xf); } png_write_row(png, buf.get()); } } #if 0 static void EncodeIA4(const uint8_t* rgbaIn, uint8_t* texels, int width, int height) { for (int y=height-1 ; y>=0 ; --y) { for (int x=0 ; x buf(new uint16_t[width]); for (int y = height - 1; y >= 0; --y) { for (int x = 0; x < width; ++x) buf[x] = hecl::SBig(Lookup16BPP(texels, width, x, y)); png_write_row(png, (png_bytep)buf.get()); } } static void EncodeIA8(const uint8_t* rgbaIn, uint8_t* texels, int width, int height) { for (int y = height - 1; y >= 0; --y) { for (int x = 0; x < width; ++x) Set16BPP(texels, width, x, y, hecl::SBig(((uint16_t*)rgbaIn)[x])); rgbaIn += width * 2; } } static const uint8_t* DecodePalette(png_structp png, png_infop info, int numEntries, const uint8_t* data) { uint32_t format = hecl::SBig(*(uint32_t*)data); data += 8; png_color cEntries[256]; png_byte aEntries[256]; switch (format) { case 0: { /* IA8 */ for (int e = 0; e < numEntries; ++e) { cEntries[e].red = data[e * 2]; cEntries[e].green = data[e * 2]; cEntries[e].blue = data[e * 2]; aEntries[e] = data[e * 2 + 1]; } break; } case 1: { /* RGB565 */ const uint16_t* data16 = (uint16_t*)data; for (int e = 0; e < numEntries; ++e) { uint16_t texel = hecl::SBig(data16[e]); cEntries[e].red = Convert5To8(texel >> 11 & 0x1f); cEntries[e].green = Convert6To8(texel >> 5 & 0x3f); cEntries[e].blue = Convert5To8(texel & 0x1f); } break; } case 2: { /* RGB5A3 */ const uint16_t* data16 = (uint16_t*)data; for (int e = 0; e < numEntries; ++e) { uint16_t texel = hecl::SBig(data16[e]); if (texel & 0x8000) { cEntries[e].red = Convert5To8(texel >> 10 & 0x1f); cEntries[e].green = Convert5To8(texel >> 5 & 0x1f); cEntries[e].blue = Convert5To8(texel & 0x1f); aEntries[e] = 0xff; } else { cEntries[e].red = Convert4To8(texel >> 8 & 0xf); cEntries[e].green = Convert4To8(texel >> 4 & 0xf); cEntries[e].blue = Convert4To8(texel & 0xf); aEntries[e] = Convert3To8(texel >> 12 & 0x7); } } break; } } png_set_PLTE(png, info, cEntries, numEntries); if (format == 0 || format == 2) png_set_tRNS(png, info, aEntries, numEntries, nullptr); data += numEntries * 2; return data; } static uint8_t* EncodePalette(png_structp png, png_infop info, int numEntries, uint8_t* data) { png_colorp cEntries; int pngNumEntries; if (png_get_PLTE(png, info, &cEntries, &pngNumEntries) != PNG_INFO_PLTE) { cEntries = nullptr; pngNumEntries = 0; } png_bytep aEntries; int pngNumAEntries; png_color_16p trans_color = nullptr; if (png_get_tRNS(png, info, &aEntries, &pngNumAEntries, &trans_color) != PNG_INFO_tRNS) { aEntries = nullptr; pngNumAEntries = 0; } uint32_t format = 0; /* Default IA8 */ for (int e = 0; e < pngNumEntries; ++e) { png_colorp ent = &cEntries[e]; if (ent->red != ent->green || ent->red != ent->blue) { if (pngNumAEntries) format = 2; /* RGB565 if not greyscale and has alpha */ else format = 1; /* RGB565 if not greyscale */ break; } } ((uint32_t*)data)[0] = hecl::SBig(format); data += 4; ((uint16_t*)data)[0] = hecl::SBig(uint16_t(numEntries)); ((uint16_t*)data)[1] = hecl::SBig(uint16_t(1)); data += 4; switch (format) { case 0: { /* IA8 */ for (int e = 0; e < numEntries; ++e) { if (e < pngNumEntries) data[e * 2] = cEntries[e].green; else data[e * 2] = 0; if (e < pngNumAEntries) data[e * 2 + 1] = aEntries[e]; else data[e * 2 + 1] = 0; } break; } case 1: { /* RGB565 */ uint16_t* data16 = (uint16_t*)data; for (int e = 0; e < numEntries; ++e) { if (e < pngNumEntries) { uint16_t texel = Convert8To5(cEntries[e].red) << 11; texel |= Convert8To6(cEntries[e].green) << 5; texel |= Convert8To5(cEntries[e].blue); data16[e] = hecl::SBig(texel); } else { data16[e] = 0; } } break; } case 2: { /* RGB5A3 */ uint16_t* data16 = (uint16_t*)data; for (int e = 0; e < numEntries; ++e) { uint8_t alpha = 0; if (e < pngNumAEntries) alpha = aEntries[e]; uint16_t texel = 0; if (alpha == 0xff) { texel |= 0x8000; if (e < pngNumEntries) { texel |= Convert8To5(cEntries[e].red) << 10; texel |= Convert8To5(cEntries[e].green) << 5; texel |= Convert8To5(cEntries[e].blue); } } else { if (e < pngNumEntries) { texel |= Convert8To4(cEntries[e].red) << 8; texel |= Convert8To4(cEntries[e].green) << 4; texel |= Convert8To4(cEntries[e].blue); texel |= Convert8To3(alpha << 12); } } data16[e] = hecl::SBig(texel); } break; } } data += numEntries * 2; return data; } static const uint8_t* DecodePaletteSPLT(png_structp png, png_infop info, int numEntries, const uint8_t* data) { uint32_t format = hecl::SBig(*(uint32_t*)data); data += 8; png_sPLT_entry entries[256] = {}; png_sPLT_t GXEntry = {(char*)"GXPalette", 8, entries, numEntries}; switch (format) { case 0: { /* IA8 */ GXEntry.name = (char*)"GX_IA8"; for (int e = 0; e < numEntries; ++e) { entries[e].red = data[e * 2]; entries[e].green = data[e * 2]; entries[e].blue = data[e * 2]; entries[e].alpha = data[e * 2 + 1]; } break; } case 1: { /* RGB565 */ GXEntry.name = (char*)"GX_RGB565"; const uint16_t* data16 = (uint16_t*)data; for (int e = 0; e < numEntries; ++e) { uint16_t texel = hecl::SBig(data16[e]); entries[e].red = Convert5To8(texel >> 11 & 0x1f); entries[e].green = Convert6To8(texel >> 5 & 0x3f); entries[e].blue = Convert5To8(texel & 0x1f); entries[e].alpha = 0xff; } break; } case 2: { /* RGB5A3 */ GXEntry.name = (char*)"GX_RGB5A3"; const uint16_t* data16 = (uint16_t*)data; for (int e = 0; e < numEntries; ++e) { uint16_t texel = hecl::SBig(data16[e]); if (texel & 0x8000) { entries[e].red = Convert5To8(texel >> 10 & 0x1f); entries[e].green = Convert5To8(texel >> 5 & 0x1f); entries[e].blue = Convert5To8(texel & 0x1f); entries[e].alpha = 0xff; } else { entries[e].red = Convert4To8(texel >> 8 & 0xf); entries[e].green = Convert4To8(texel >> 4 & 0xf); entries[e].blue = Convert4To8(texel & 0xf); entries[e].alpha = Convert3To8(texel >> 12 & 0x7); } } break; } } png_set_sPLT(png, info, &GXEntry, 1); data += numEntries * 2; return data; } static uint8_t* EncodePaletteSPLT(png_structp png, png_infop info, int numEntries, uint8_t* data) { png_sPLT_tp palettes; int pngNumPalettes = png_get_sPLT(png, info, &palettes); int pngNumEntries = 0; png_sPLT_entryp cEntries = nullptr; for (int i = 0; i < pngNumPalettes; ++i) { png_sPLT_tp palette = &palettes[i]; if (!strncmp(palette->name, "GX_", 3)) { pngNumEntries = palette->nentries; cEntries = palette->entries; break; } } uint32_t format = 2; /* Default RGB5A3 */ for (int e = 0; e < pngNumEntries; ++e) { png_sPLT_entryp ent = &cEntries[e]; if (ent->red != ent->green || ent->red != ent->blue) { if (ent->alpha) { format = 2; break; } else format = 1; } } ((uint32_t*)data)[0] = hecl::SBig(format); data += 4; ((uint16_t*)data)[0] = hecl::SBig(uint16_t(1)); ((uint16_t*)data)[1] = hecl::SBig(uint16_t(numEntries)); data += 4; switch (format) { case 0: { /* IA8 */ for (int e = 0; e < numEntries; ++e) { if (e < pngNumEntries) { data[e * 2] = cEntries[e].green; data[e * 2 + 1] = cEntries[e].alpha; } else { data[e * 2] = 0; data[e * 2 + 1] = 0; } } break; } case 1: { /* RGB565 */ uint16_t* data16 = (uint16_t*)data; for (int e = 0; e < numEntries; ++e) { if (e < pngNumEntries) { uint16_t texel = Convert8To5(cEntries[e].red) << 11; texel |= Convert8To6(cEntries[e].green) << 5; texel |= Convert8To5(cEntries[e].blue); data16[e] = hecl::SBig(texel); } else { data16[e] = 0; } } break; } case 2: { /* RGB5A3 */ uint16_t* data16 = (uint16_t*)data; for (int e = 0; e < numEntries; ++e) { uint16_t texel = 0; if (cEntries && cEntries[e].alpha == 0xff) { texel |= 0x8000; if (e < pngNumEntries) { texel |= Convert8To5(cEntries[e].red) << 10; texel |= Convert8To5(cEntries[e].green) << 5; texel |= Convert8To5(cEntries[e].blue); } } else { if (e < pngNumEntries) { texel |= Convert8To4(cEntries[e].red) << 8; texel |= Convert8To4(cEntries[e].green) << 4; texel |= Convert8To4(cEntries[e].blue); texel |= Convert8To3(cEntries[e].alpha << 12); } } data16[e] = hecl::SBig(texel); } break; } } data += numEntries * 2; return data; } static const png_color C4Colors[] = { {0, 0, 0}, {155, 0, 0}, {0, 155, 0}, {0, 0, 155}, {155, 155, 0}, {155, 0, 155}, {0, 155, 155}, {155, 155, 155}, {55, 55, 55}, {255, 0, 0}, {0, 255, 0}, {0, 0, 255}, {255, 255, 0}, {255, 0, 255}, {0, 255, 255}, {255, 255, 255}}; static void C4Palette(png_structp png, png_infop info) { png_set_PLTE(png, info, C4Colors, 16); } static void DecodeC4(png_structp png, png_infop info, const uint8_t* data, int width, int height) { png_set_IHDR(png, info, width, height, 8, PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); C4Palette(png, info); const uint8_t* texels = DecodePaletteSPLT(png, info, 16, data); png_write_info(png, info); std::unique_ptr buf(new uint8_t[width]); for (int y = 0; y < height; ++y) { for (int x = 0; x < width; ++x) buf[x] = Lookup4BPP(texels, width, x, y); png_write_row(png, buf.get()); } } static void EncodeC4(png_structp png, png_infop info, const uint8_t* rgbaIn, uint8_t* data, int width, int height) { uint8_t* texels = EncodePaletteSPLT(png, info, 16, data); for (int y = 0; y < height; ++y) { for (int x = 0; x < width; ++x) Set4BPP(texels, width, x, y, rgbaIn[x]); rgbaIn += width; } } static void DecodeC8(png_structp png, png_infop info, const uint8_t* data, int width, int height) { png_set_IHDR(png, info, width, height, 8, PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); const uint8_t* texels = DecodePalette(png, info, 256, data); png_write_info(png, info); std::unique_ptr buf(new uint8_t[width]); for (int y = 0; y < height; ++y) { for (int x = 0; x < width; ++x) buf[x] = Lookup8BPP(texels, width, x, y); png_write_row(png, buf.get()); } } static void EncodeC8(png_structp png, png_infop info, const uint8_t* rgbaIn, uint8_t* data, int width, int height) { uint8_t* texels = EncodePalette(png, info, 256, data); for (int y = 0; y < height; ++y) { for (int x = 0; x < width; ++x) Set8BPP(texels, width, x, y, rgbaIn[x]); rgbaIn += width; } } static void DecodeRGB565(png_structp png, png_infop info, const uint8_t* texels, int width, int height) { png_set_IHDR(png, info, width, height, 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); png_write_info(png, info); std::unique_ptr buf(new uint8_t[width * 3]); for (int y = height - 1; y >= 0; --y) { for (int x = 0; x < width; ++x) { uint16_t texel = hecl::SBig(Lookup16BPP(texels, width, x, y)); buf[x * 3] = Convert5To8(texel >> 11 & 0x1f); buf[x * 3 + 1] = Convert6To8(texel >> 5 & 0x3f); buf[x * 3 + 2] = Convert5To8(texel & 0x1f); } png_write_row(png, buf.get()); } } #if 0 static void EncodeRGB565(const uint8_t* rgbaIn, uint8_t* texels, int width, int height) { for (int y=height-1 ; y>=0 ; --y) { for (int x=0 ; x buf(new uint8_t[width * 4]); for (int y = height - 1; y >= 0; --y) { for (int x = 0; x < width; ++x) { uint16_t texel = hecl::SBig(Lookup16BPP(texels, width, x, y)); if (texel & 0x8000) { buf[x * 4] = Convert5To8(texel >> 10 & 0x1f); buf[x * 4 + 1] = Convert5To8(texel >> 5 & 0x1f); buf[x * 4 + 2] = Convert5To8(texel & 0x1f); buf[x * 4 + 3] = 0xff; } else { buf[x * 4] = Convert4To8(texel >> 8 & 0xf); buf[x * 4 + 1] = Convert4To8(texel >> 4 & 0xf); buf[x * 4 + 2] = Convert4To8(texel & 0xf); buf[x * 4 + 3] = Convert3To8(texel >> 12 & 0x7); } } png_write_row(png, buf.get()); } } #if 0 static void EncodeRGB5A3(const uint8_t* rgbaIn, uint8_t* texels, int width, int height) { for (int y=height-1 ; y>=0 ; --y) { for (int x=0 ; x buf(new uint8_t[width * 4]); for (int y = height - 1; y >= 0; --y) { for (int x = 0; x < width; ++x) LookupRGBA8(texels, width, x, y, &buf[x * 4], &buf[x * 4 + 1], &buf[x * 4 + 2], &buf[x * 4 + 3]); png_write_row(png, buf.get()); } } static void EncodeRGBA8(const uint8_t* rgbaIn, uint8_t* texels, int width, int height) { for (int y = height - 1; y >= 0; --y) { for (int x = 0; x < width; ++x) SetRGBA8(texels, width, x, y, rgbaIn[x * 4], rgbaIn[x * 4 + 1], rgbaIn[x * 4 + 2], rgbaIn[x * 4 + 3]); rgbaIn += width * 4; } } struct DXTBlock { uint16_t color1; uint16_t color2; uint8_t lines[4]; }; static void DecodeCMPR(png_structp png, png_infop info, const uint8_t* texels, int width, int height) { png_set_IHDR(png, info, width, height, 8, PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); png_write_info(png, info); /* Decode 8 rows at a time */ int bwidth = (width + 7) / 8; int bpwidth = bwidth * 8; std::unique_ptr buf(new uint32_t[bpwidth * 8]); uint32_t* bTargets[4] = {buf.get(), buf.get() + 4, buf.get() + 4 * width, buf.get() + 4 * width + 4}; for (int y = height / 8 - 1; y >= 0; --y) { const DXTBlock* blks = (DXTBlock*)(texels + 32 * bwidth * y); for (int x = 0; x < width; x += 8) { uint32_t blkOut[4][4][4]; squish::Decompress((uint8_t*)blkOut[0][0], blks++, squish::kDxt1GCN); squish::Decompress((uint8_t*)blkOut[1][0], blks++, squish::kDxt1GCN); squish::Decompress((uint8_t*)blkOut[2][0], blks++, squish::kDxt1GCN); squish::Decompress((uint8_t*)blkOut[3][0], blks++, squish::kDxt1GCN); for (int bt = 0; bt < 4; ++bt) for (int by = 0; by < 4; ++by) memcpy(bTargets[bt] + x + width * by, blkOut[bt][by], 16); } for (int r = 7; r >= 0; --r) png_write_row(png, (png_bytep)(bTargets[0] + width * r)); } } static void EncodeCMPR(const uint8_t* rgbaIn, uint8_t* texels, int width, int height) { /* Encode 8 rows at a time */ int bwidth = (width + 7) / 8; int bpwidth = bwidth * 8; std::unique_ptr buf(new uint32_t[bpwidth * 8]); uint32_t* bTargets[4] = {buf.get(), buf.get() + 4, buf.get() + 4 * width, buf.get() + 4 * width + 4}; for (int y = height / 8 - 1; y >= 0; --y) { for (int r = 7; r >= 0; --r) { memcpy(bTargets[0] + width * r, rgbaIn, width * 4); rgbaIn += width * 4; } DXTBlock* blks = (DXTBlock*)(texels + 32 * bwidth * y); for (int x = 0; x < width; x += 8) { uint32_t blkIn[4][4][4]; for (int bt = 0; bt < 4; ++bt) for (int by = 0; by < 4; ++by) memcpy(blkIn[bt][by], bTargets[bt] + x + width * by, 16); squish::Compress((uint8_t*)blkIn[0][0], blks++, squish::kDxt1GCN); squish::Compress((uint8_t*)blkIn[1][0], blks++, squish::kDxt1GCN); squish::Compress((uint8_t*)blkIn[2][0], blks++, squish::kDxt1GCN); squish::Compress((uint8_t*)blkIn[3][0], blks++, squish::kDxt1GCN); } } } static void PNGErr(png_structp png, png_const_charp msg) { Log.report(logvisor::Error, msg); } static void PNGWarn(png_structp png, png_const_charp msg) { Log.report(logvisor::Warning, msg); } bool TXTR::Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath) { uint32_t format = rs.readUint32Big(); uint16_t width = rs.readUint16Big(); uint16_t height = rs.readUint16Big(); uint32_t numMips = rs.readUint32Big(); FILE* fp = hecl::Fopen(outPath.getAbsolutePath().data(), _SYS_STR("wb")); if (!fp) { Log.report(logvisor::Error, _SYS_STR("Unable to open '%s' for writing"), outPath.getAbsolutePath().data()); return false; } png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, PNGErr, PNGWarn); png_init_io(png, fp); png_infop info = png_create_info_struct(png); png_text textStruct = {}; textStruct.key = png_charp("urde_nomip"); if (numMips == 1) png_set_text(png, info, &textStruct, 1); switch (format) { case 0: DecodeI4(png, info, rs.data() + 12, width, height); break; case 1: DecodeI8(png, info, rs.data() + 12, width, height); break; case 2: DecodeIA4(png, info, rs.data() + 12, width, height); break; case 3: DecodeIA8(png, info, rs.data() + 12, width, height); break; case 4: DecodeC4(png, info, rs.data() + 12, width, height); break; case 5: DecodeC8(png, info, rs.data() + 12, width, height); break; case 7: DecodeRGB565(png, info, rs.data() + 12, width, height); break; case 8: DecodeRGB5A3(png, info, rs.data() + 12, width, height); break; case 9: DecodeRGBA8(png, info, rs.data() + 12, width, height); break; case 10: DecodeCMPR(png, info, rs.data() + 12, width, height); break; } png_write_end(png, info); png_write_flush(png); png_destroy_write_struct(&png, &info); fclose(fp); return true; } static std::unique_ptr ReadPalette(png_structp png, png_infop info, size_t& szOut) { std::unique_ptr ret; png_sPLT_tp palettes; int paletteCount = png_get_sPLT(png, info, &palettes); if (paletteCount) { for (int i = 0; i < paletteCount; ++i) { png_sPLT_tp palette = &palettes[i]; if (!strncmp(palette->name, "GX_", 3)) { if (palette->nentries > 16) { /* This is a C8 palette */ ret.reset(new uint8_t[4 * 257]); szOut = 4 * 257; *reinterpret_cast(ret.get()) = hecl::SBig(256); uint8_t* cur = ret.get() + 4; for (int j = 0; j < 256; ++j) { if (j < palette->nentries) { png_sPLT_entryp entry = &palette->entries[j]; if (palette->depth == 16) { *cur++ = entry->red >> 8; *cur++ = entry->green >> 8; *cur++ = entry->blue >> 8; *cur++ = entry->alpha >> 8; } else { *cur++ = entry->red; *cur++ = entry->green; *cur++ = entry->blue; *cur++ = entry->alpha; } } else { *cur++ = 0; *cur++ = 0; *cur++ = 0; *cur++ = 0; } } } else { /* This is a C4 palette */ ret.reset(new uint8_t[4 * 17]); szOut = 4 * 17; *reinterpret_cast(ret.get()) = hecl::SBig(16); uint8_t* cur = ret.get() + 4; for (int j = 0; j < 16; ++j) { if (j < palette->nentries) { png_sPLT_entryp entry = &palette->entries[j]; if (palette->depth == 16) { *cur++ = entry->red >> 8; *cur++ = entry->green >> 8; *cur++ = entry->blue >> 8; *cur++ = entry->alpha >> 8; } else { *cur++ = entry->red; *cur++ = entry->green; *cur++ = entry->blue; *cur++ = entry->alpha; } } else { *cur++ = 0; *cur++ = 0; *cur++ = 0; *cur++ = 0; } } } break; } } } else { png_colorp palettes; int colorCount; if (png_get_PLTE(png, info, &palettes, &colorCount) == PNG_INFO_PLTE) { if (colorCount > 16) { /* This is a C8 palette */ ret.reset(new uint8_t[4 * 257]); szOut = 4 * 257; *reinterpret_cast(ret.get()) = hecl::SBig(256); uint8_t* cur = ret.get() + 4; for (int j = 0; j < 256; ++j) { if (j < colorCount) { png_colorp entry = &palettes[j]; *cur++ = entry->red; *cur++ = entry->green; *cur++ = entry->blue; *cur++ = 0xff; } else { *cur++ = 0; *cur++ = 0; *cur++ = 0; *cur++ = 0; } } } else { /* This is a C4 palette */ ret.reset(new uint8_t[4 * 17]); szOut = 4 * 17; *reinterpret_cast(ret.get()) = hecl::SBig(16); uint8_t* cur = ret.get() + 4; for (int j = 0; j < 16; ++j) { if (j < colorCount) { png_colorp entry = &palettes[j]; *cur++ = entry->red; *cur++ = entry->green; *cur++ = entry->blue; *cur++ = 0xff; } else { *cur++ = 0; *cur++ = 0; *cur++ = 0; *cur++ = 0; } } } } } return ret; } static int GetNumPaletteEntriesForGCN(png_structp png, png_infop info) { png_sPLT_tp palettes; int paletteCount = png_get_sPLT(png, info, &palettes); if (paletteCount) { for (int i = 0; i < paletteCount; ++i) { png_sPLT_tp palette = &palettes[i]; if (!strncmp(palette->name, "GX_", 3)) { if (palette->nentries > 16) { /* This is a C8 palette */ return 256; } else { /* This is a C4 palette */ return 16; } break; } } } else { png_colorp palettes; int colorCount; if (png_get_PLTE(png, info, &palettes, &colorCount) == PNG_INFO_PLTE) { if (colorCount > 16) { /* This is a C8 palette */ return 256; } else { /* This is a C4 palette */ return 16; } } } return 0; } bool TXTR::Cook(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outPath) { FILE* inf = hecl::Fopen(inPath.getAbsolutePath().data(), _SYS_STR("rb")); if (!inf) { Log.report(logvisor::Error, _SYS_STR("Unable to open '%s' for reading"), inPath.getAbsolutePath().data()); return false; } /* Validate PNG */ char header[8]; fread(header, 1, 8, inf); if (png_sig_cmp((png_const_bytep)header, 0, 8)) { Log.report(logvisor::Error, _SYS_STR("invalid PNG signature in '%s'"), inPath.getAbsolutePath().data()); fclose(inf); return false; } /* Setup PNG reader */ png_structp pngRead = png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr); if (!pngRead) { Log.report(logvisor::Error, "unable to initialize libpng"); fclose(inf); return false; } png_infop info = png_create_info_struct(pngRead); if (!info) { Log.report(logvisor::Error, "unable to initialize libpng info"); fclose(inf); png_destroy_read_struct(&pngRead, nullptr, nullptr); return false; } if (setjmp(png_jmpbuf(pngRead))) { Log.report(logvisor::Error, _SYS_STR("unable to initialize libpng I/O for '%s'"), inPath.getAbsolutePath().data()); fclose(inf); png_destroy_read_struct(&pngRead, &info, nullptr); return false; } png_init_io(pngRead, inf); png_set_sig_bytes(pngRead, 8); png_read_info(pngRead, info); png_uint_32 width = png_get_image_width(pngRead, info); png_uint_32 height = png_get_image_height(pngRead, info); png_byte colorType = png_get_color_type(pngRead, info); png_byte bitDepth = png_get_bit_depth(pngRead, info); if (width < 4 || height < 4) { Log.report(logvisor::Error, "image must be 4x4 or larger"); fclose(inf); png_destroy_read_struct(&pngRead, &info, nullptr); return false; } /* Disable mipmapping if urde_nomip embedded */ bool mipmap = true; png_text* textStruct; int numText; png_get_text(pngRead, info, &textStruct, &numText); for (int i = 0; i < numText; ++i) if (!strcmp(textStruct[i].key, "urde_nomip")) mipmap = false; if (colorType == PNG_COLOR_TYPE_PALETTE) mipmap = false; /* Compute mipmap levels */ size_t numMips = 1; if (mipmap && CountBits(width) == 1 && CountBits(height) == 1) { size_t index = std::min(width, height); while (index >>= 1) ++numMips; } if (bitDepth != 8) { Log.report(logvisor::Error, _SYS_STR("'%s' is not 8 bits-per-channel"), inPath.getAbsolutePath().data()); fclose(inf); png_destroy_read_struct(&pngRead, &info, nullptr); return false; } size_t rowSize = 0; size_t nComps = 4; int nPaletteEntries = 0; switch (colorType) { case PNG_COLOR_TYPE_GRAY: rowSize = width; nComps = 1; break; case PNG_COLOR_TYPE_GRAY_ALPHA: rowSize = width * 2; nComps = 2; break; case PNG_COLOR_TYPE_RGB: rowSize = width * 3; nComps = 4; break; case PNG_COLOR_TYPE_RGB_ALPHA: rowSize = width * 4; nComps = 4; break; case PNG_COLOR_TYPE_PALETTE: nPaletteEntries = GetNumPaletteEntriesForGCN(pngRead, info); rowSize = width; nComps = 1; break; default: Log.report(logvisor::Error, _SYS_STR("unsupported color type in '%s'"), inPath.getAbsolutePath().data()); fclose(inf); png_destroy_read_struct(&pngRead, &info, nullptr); return false; } /* Intermediate row-read buf (file components) */ std::unique_ptr rowBuf; if (colorType == PNG_COLOR_TYPE_RGB) rowBuf.reset(new uint8_t[rowSize]); /* Final mipmapped buf (RGBA components) */ std::unique_ptr bufOut; size_t bufLen = 0; if (numMips > 1) bufLen = ComputeMippedTexelCount(width, height) * nComps; else bufLen = width * height * nComps; bufOut.reset(new uint8_t[bufLen]); if (setjmp(png_jmpbuf(pngRead))) { Log.report(logvisor::Error, _SYS_STR("unable to read image in '%s'"), inPath.getAbsolutePath().data()); fclose(inf); png_destroy_read_struct(&pngRead, &info, nullptr); return false; } /* Track alpha values for DXT1 eligibility */ bool doDXT1 = (colorType == PNG_COLOR_TYPE_RGB || colorType == PNG_COLOR_TYPE_RGB_ALPHA) && width >= 4 && height >= 4; /* Read into mip0 image buffer */ for (int r = 0; r < height; ++r) { if (colorType == PNG_COLOR_TYPE_RGB) { png_read_row(pngRead, rowBuf.get(), nullptr); for (unsigned i = 0; i < width; ++i) { size_t inbase = i * 3; size_t outbase = (r * width + i) * 4; bufOut[outbase] = rowBuf[inbase]; bufOut[outbase + 1] = rowBuf[inbase + 1]; bufOut[outbase + 2] = rowBuf[inbase + 2]; bufOut[outbase + 3] = 0xff; } } else { png_read_row(pngRead, &bufOut[(r * width) * nComps], nullptr); if (colorType == PNG_COLOR_TYPE_RGB_ALPHA) { for (unsigned i = 0; i < width; ++i) { size_t outbase = (r * width + i) * nComps; if (bufOut[outbase + 3] != 0 && bufOut[outbase + 3] != 255) doDXT1 = false; } } } } png_destroy_read_struct(&pngRead, &info, nullptr); fclose(inf); /* Reduce mipmaps to minimum allowed dimensions */ int minDimX, minDimY; if (doDXT1) { minDimX = minDimY = 4; } else { switch (colorType) { case PNG_COLOR_TYPE_GRAY: minDimX = 8; minDimY = 4; break; case PNG_COLOR_TYPE_GRAY_ALPHA: case PNG_COLOR_TYPE_RGB: case PNG_COLOR_TYPE_RGB_ALPHA: default: minDimX = 4; minDimY = 4; break; case PNG_COLOR_TYPE_PALETTE: { if (nPaletteEntries == 256) { minDimX = 8; minDimY = 4; } else { minDimX = minDimY = 8; } break; } } } { unsigned totalPixels = 0; unsigned filterWidth = width; unsigned filterHeight = height; for (size_t i = 0; i < numMips; ++i) { totalPixels += filterWidth * filterHeight; if (filterWidth == minDimX || filterHeight == minDimY) { numMips = i + 1; break; } filterWidth /= 2; filterHeight /= 2; } bufLen = totalPixels * nComps; } /* Perform box-filter mipmap */ std::unique_ptr compOut; size_t compLen = 0; if (numMips > 1) { const uint8_t* filterIn = bufOut.get(); uint8_t* filterOut = bufOut.get() + width * height * nComps; unsigned filterWidth = width; unsigned filterHeight = height; for (size_t i = 1; i < numMips; ++i) { BoxFilter(filterIn, nComps, filterWidth, filterHeight, filterOut, doDXT1); filterIn += filterWidth * filterHeight * nComps; filterWidth /= 2; filterHeight /= 2; filterOut += filterWidth * filterHeight * nComps; } } /* Do DXT1 compression */ int format; if (doDXT1) { int filterWidth = width; int filterHeight = height; for (size_t i = 0; i < numMips; ++i) { compLen += squish::GetStorageRequirements(filterWidth, filterHeight, squish::kDxt1); if (filterWidth == 8 || filterHeight == 8) { numMips = i + 1; break; } filterWidth /= 2; filterHeight /= 2; } compOut.reset(new uint8_t[compLen]); filterWidth = width; filterHeight = height; const uint8_t* rgbaIn = bufOut.get(); uint8_t* blocksOut = compOut.get(); memset(blocksOut, 0, compLen); for (size_t i = 0; i < numMips; ++i) { int thisLen = squish::GetStorageRequirements(filterWidth, filterHeight, squish::kDxt1); EncodeCMPR(rgbaIn, blocksOut, filterWidth, filterHeight); rgbaIn += filterWidth * filterHeight * nComps; blocksOut += thisLen; filterWidth /= 2; filterHeight /= 2; } format = 10; } else { int filterWidth = width; int filterHeight = height; compLen = bufLen; if (colorType == PNG_COLOR_TYPE_PALETTE) { if (nPaletteEntries == 16) compLen /= 2; compLen += 8 + nPaletteEntries * 2; } compOut.reset(new uint8_t[compLen]); const uint8_t* rgbaIn = bufOut.get(); uint8_t* dataOut = compOut.get(); memset(dataOut, 0, compLen); for (size_t i = 0; i < numMips; ++i) { switch (colorType) { case PNG_COLOR_TYPE_GRAY: EncodeI8(rgbaIn, dataOut, filterWidth, filterHeight); format = 1; break; case PNG_COLOR_TYPE_GRAY_ALPHA: EncodeIA8(rgbaIn, dataOut, filterWidth, filterHeight); format = 3; break; case PNG_COLOR_TYPE_RGB: case PNG_COLOR_TYPE_RGB_ALPHA: EncodeRGBA8(rgbaIn, dataOut, filterWidth, filterHeight); format = 9; break; case PNG_COLOR_TYPE_PALETTE: { if (nPaletteEntries == 256) { EncodeC8(pngRead, info, rgbaIn, dataOut, filterWidth, filterHeight); format = 5; } else { EncodeC4(pngRead, info, rgbaIn, dataOut, filterWidth, filterHeight); format = 4; } break; } default: break; } rgbaIn += filterWidth * filterHeight * nComps; dataOut += filterWidth * filterHeight * nComps; filterWidth /= 2; filterHeight /= 2; } } /* Do write out */ athena::io::FileWriter outf(outPath.getAbsolutePath(), true, false); if (outf.hasError()) { Log.report(logvisor::Error, _SYS_STR("Unable to open '%s' for writing"), outPath.getAbsolutePath().data()); return false; } outf.writeInt32Big(format); outf.writeInt16Big(width); outf.writeInt16Big(height); outf.writeInt32Big(numMips); outf.writeUBytes(compOut.get(), compLen); return true; } bool TXTR::CookPC(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outPath) { FILE* inf = hecl::Fopen(inPath.getAbsolutePath().data(), _SYS_STR("rb")); if (!inf) { Log.report(logvisor::Error, _SYS_STR("Unable to open '%s' for reading"), inPath.getAbsolutePath().data()); return false; } /* Validate PNG */ char header[8]; fread(header, 1, 8, inf); if (png_sig_cmp((png_const_bytep)header, 0, 8)) { Log.report(logvisor::Error, _SYS_STR("invalid PNG signature in '%s'"), inPath.getAbsolutePath().data()); fclose(inf); return false; } /* Setup PNG reader */ png_structp pngRead = png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr); if (!pngRead) { Log.report(logvisor::Error, "unable to initialize libpng"); fclose(inf); return false; } png_infop info = png_create_info_struct(pngRead); if (!info) { Log.report(logvisor::Error, "unable to initialize libpng info"); fclose(inf); png_destroy_read_struct(&pngRead, nullptr, nullptr); return false; } if (setjmp(png_jmpbuf(pngRead))) { Log.report(logvisor::Error, _SYS_STR("unable to initialize libpng I/O for '%s'"), inPath.getAbsolutePath().data()); fclose(inf); png_destroy_read_struct(&pngRead, &info, nullptr); return false; } png_init_io(pngRead, inf); png_set_sig_bytes(pngRead, 8); png_read_info(pngRead, info); png_uint_32 width = png_get_image_width(pngRead, info); png_uint_32 height = png_get_image_height(pngRead, info); png_byte colorType = png_get_color_type(pngRead, info); png_byte bitDepth = png_get_bit_depth(pngRead, info); /* Disable mipmapping if urde_nomip embedded */ bool mipmap = true; png_text* textStruct; int numText; png_get_text(pngRead, info, &textStruct, &numText); for (int i = 0; i < numText; ++i) if (!strcmp(textStruct[i].key, "urde_nomip")) mipmap = false; if (colorType == PNG_COLOR_TYPE_PALETTE) mipmap = false; /* Compute mipmap levels */ size_t numMips = 1; if (mipmap && CountBits(width) == 1 && CountBits(height) == 1) { size_t index = std::min(width, height); while (index >>= 1) ++numMips; } if (bitDepth != 8) { Log.report(logvisor::Error, _SYS_STR("'%s' is not 8 bits-per-channel"), inPath.getAbsolutePath().data()); fclose(inf); png_destroy_read_struct(&pngRead, &info, nullptr); return false; } std::unique_ptr paletteBuf; size_t paletteSize = 0; size_t rowSize = 0; size_t nComps = 4; switch (colorType) { case PNG_COLOR_TYPE_GRAY: rowSize = width; break; case PNG_COLOR_TYPE_GRAY_ALPHA: rowSize = width * 2; break; case PNG_COLOR_TYPE_RGB: rowSize = width * 3; break; case PNG_COLOR_TYPE_RGB_ALPHA: rowSize = width * 4; break; case PNG_COLOR_TYPE_PALETTE: rowSize = width; nComps = 1; paletteBuf = ReadPalette(pngRead, info, paletteSize); break; default: Log.report(logvisor::Error, _SYS_STR("unsupported color type in '%s'"), inPath.getAbsolutePath().data()); fclose(inf); png_destroy_read_struct(&pngRead, &info, nullptr); return false; } /* Intermediate row-read buf (file components) */ std::unique_ptr rowBuf(new uint8_t[rowSize]); /* Final mipmapped buf (RGBA components) */ std::unique_ptr bufOut; size_t bufLen = 0; if (numMips > 1) bufLen = ComputeMippedTexelCount(width, height) * nComps; else bufLen = width * height * nComps; bufOut.reset(new uint8_t[bufLen]); if (setjmp(png_jmpbuf(pngRead))) { Log.report(logvisor::Error, _SYS_STR("unable to read image in '%s'"), inPath.getAbsolutePath().data()); fclose(inf); png_destroy_read_struct(&pngRead, &info, nullptr); return false; } /* Track alpha values for DXT1 eligibility */ bool doDXT1 = (colorType == PNG_COLOR_TYPE_RGB || colorType == PNG_COLOR_TYPE_RGB_ALPHA) && width >= 4 && height >= 4; /* Read and make RGBA */ for (int r = height - 1; r >= 0; --r) { png_read_row(pngRead, rowBuf.get(), nullptr); switch (colorType) { case PNG_COLOR_TYPE_GRAY: for (unsigned i = 0; i < width; ++i) { size_t outbase = (r * width + i) * 4; bufOut[outbase] = rowBuf[i]; bufOut[outbase + 1] = rowBuf[i]; bufOut[outbase + 2] = rowBuf[i]; bufOut[outbase + 3] = rowBuf[i]; } break; case PNG_COLOR_TYPE_GRAY_ALPHA: for (unsigned i = 0; i < width; ++i) { size_t inbase = i * 2; size_t outbase = (r * width + i) * 4; bufOut[outbase] = rowBuf[inbase]; bufOut[outbase + 1] = rowBuf[inbase]; bufOut[outbase + 2] = rowBuf[inbase]; bufOut[outbase + 3] = rowBuf[inbase + 1]; } break; case PNG_COLOR_TYPE_RGB: for (unsigned i = 0; i < width; ++i) { size_t inbase = i * 3; size_t outbase = (r * width + i) * 4; bufOut[outbase] = rowBuf[inbase]; bufOut[outbase + 1] = rowBuf[inbase + 1]; bufOut[outbase + 2] = rowBuf[inbase + 2]; bufOut[outbase + 3] = 0xff; } break; case PNG_COLOR_TYPE_RGB_ALPHA: for (unsigned i = 0; i < width; ++i) { size_t inbase = i * 4; size_t outbase = (r * width + i) * 4; bufOut[outbase] = rowBuf[inbase]; bufOut[outbase + 1] = rowBuf[inbase + 1]; bufOut[outbase + 2] = rowBuf[inbase + 2]; bufOut[outbase + 3] = rowBuf[inbase + 3]; if (rowBuf[inbase + 3] != 0 && rowBuf[inbase + 3] != 255) doDXT1 = false; } break; case PNG_COLOR_TYPE_PALETTE: for (unsigned i = 0; i < width; ++i) bufOut[r * width + i] = rowBuf[i]; break; default: break; } } png_destroy_read_struct(&pngRead, &info, nullptr); fclose(inf); /* Perform box-filter mipmap */ if (numMips > 1) { const uint8_t* filterIn = bufOut.get(); uint8_t* filterOut = bufOut.get() + width * height * nComps; unsigned filterWidth = width; unsigned filterHeight = height; for (size_t i = 1; i < numMips; ++i) { BoxFilter(filterIn, nComps, filterWidth, filterHeight, filterOut, doDXT1); filterIn += filterWidth * filterHeight * nComps; filterWidth /= 2; filterHeight /= 2; filterOut += filterWidth * filterHeight * nComps; } } /* Do DXT1 compression */ std::unique_ptr compOut; size_t compLen = 0; if (doDXT1) { int filterWidth = width; int filterHeight = height; size_t i; for (i = 0; i < numMips; ++i) { compLen += squish::GetStorageRequirements(filterWidth, filterHeight, squish::kDxt1); if (filterWidth == 4 || filterHeight == 4) { ++i; break; } filterWidth /= 2; filterHeight /= 2; } numMips = i; compOut.reset(new uint8_t[compLen]); filterWidth = width; filterHeight = height; const uint8_t* rgbaIn = bufOut.get(); uint8_t* blocksOut = compOut.get(); for (i = 0; i < numMips; ++i) { int thisLen = squish::GetStorageRequirements(filterWidth, filterHeight, squish::kDxt1); squish::CompressImage(rgbaIn, filterWidth, filterHeight, blocksOut, squish::kDxt1); rgbaIn += filterWidth * filterHeight * nComps; blocksOut += thisLen; filterWidth /= 2; filterHeight /= 2; } } /* Do write out */ athena::io::FileWriter outf(outPath.getAbsolutePath(), true, false); if (outf.hasError()) { Log.report(logvisor::Error, _SYS_STR("Unable to open '%s' for writing"), outPath.getAbsolutePath().data()); return false; } int format; if (paletteBuf && paletteSize) format = 17; else if (compOut) format = 18; else format = 16; outf.writeInt32Big(format); outf.writeInt16Big(width); outf.writeInt16Big(height); outf.writeInt32Big(numMips); if (paletteBuf && paletteSize) outf.writeUBytes(paletteBuf.get(), paletteSize); if (compOut) outf.writeUBytes(compOut.get(), compLen); else outf.writeUBytes(bufOut.get(), bufLen); return true; } static const atInt32 RetroToDol[11] { 0, 1, 2, 3, 8, 9, -1, 4, 5, 6, 14 }; std::string TXTR::CalculateDolphinName(DataSpec::PAKEntryReadStream& rs) { atUint32 format = RetroToDol[rs.readUint32Big()]; if (format == -1) return {}; atUint16 width = rs.readUint16Big(); atUint16 height = rs.readUint16Big(); atUint32 mips = rs.readUint32Big(); std::string res = hecl::Format("tex1_%dx%d%s", width, height, mips > 1 ? "_m" : ""); atUint64 palHash = 0; bool hasPalette = false; atUint32 textureSize = width * height; if (format == 8 || format == 9) { hasPalette = true; atUint32 paletteFormat = rs.readUint32Big(); atUint16 palWidth = rs.readUint16Big(); atUint16 palHeight = rs.readUint16Big(); atUint32 palSize = atUint32(palWidth * palHeight * 2); if (format == 4) textureSize /= 2; std::unique_ptr palData(new u8[palSize]); rs.readUBytesToBuf(palData.get(), palSize); palHash = XXH64(palData.get(), palSize, 0); } else { switch(format) { case 0: // I4 case 14: // DXT1 textureSize /= 2; break; case 3: case 4: case 5: textureSize *= 2; break; case 6: textureSize *= 4; break; default: break; } } std::unique_ptr textureData(new u8[textureSize]); rs.readUBytesToBuf(textureData.get(), textureSize); atUint64 texHash = XXH64(textureData.get(), textureSize, 0); res += hecl::Format("_%016" PRIx64, texHash); if (hasPalette) res += hecl::Format("_%016" PRIx64, palHash); res += hecl::Format("_%d", format); return res; } } // namespace DataSpec