From 996998785cf10394338f7a54ce54e324e1229e61 Mon Sep 17 00:00:00 2001 From: tobid7 Date: Sun, 4 May 2025 13:32:07 +0200 Subject: [PATCH] Public V0.0.1 --- .gitignore | 2 + .gitmodules | 6 + .vscode/c_cpp_properties.json | 19 + .vscode/settings.json | 91 ++ CMakeLists.txt | 46 + LICENSE | 9 + README.md | 46 + docs/bcstm_doku.md | 178 ++++ docs/bcwav_doku.md | 178 ++++ include/ctrff.hpp | 8 + include/ctrff/3dsx.hpp | 48 + include/ctrff/bcstm.hpp | 241 +++++ include/ctrff/bcwav.hpp | 188 ++++ include/ctrff/binutil.hpp | 43 + include/ctrff/helper.hpp | 16 + include/ctrff/lz11.hpp | 10 + include/ctrff/pd_p_api.hpp | 50 + include/ctrff/smdh.hpp | 143 +++ source/3dsx.cpp | 29 + source/bcstm.cpp | 189 ++++ source/bcwav.cpp | 142 +++ source/binutil.cpp | 41 + source/helper.cpp | 159 +++ source/lz11.cpp | 112 +++ source/smdh.cpp | 127 +++ tool/main.cpp | 502 ++++++++++ tool/test.cpp | 48 + vendor/cli-fancy | 1 + vendor/palladium | 1 + vendor/stb/stb_image_write.h | 1724 +++++++++++++++++++++++++++++++++ 30 files changed, 4397 insertions(+) create mode 100644 .gitignore create mode 100644 .gitmodules create mode 100644 .vscode/c_cpp_properties.json create mode 100644 .vscode/settings.json create mode 100644 CMakeLists.txt create mode 100644 LICENSE create mode 100644 README.md create mode 100644 docs/bcstm_doku.md create mode 100644 docs/bcwav_doku.md create mode 100644 include/ctrff.hpp create mode 100644 include/ctrff/3dsx.hpp create mode 100644 include/ctrff/bcstm.hpp create mode 100644 include/ctrff/bcwav.hpp create mode 100644 include/ctrff/binutil.hpp create mode 100644 include/ctrff/helper.hpp create mode 100644 include/ctrff/lz11.hpp create mode 100644 include/ctrff/pd_p_api.hpp create mode 100644 include/ctrff/smdh.hpp create mode 100644 source/3dsx.cpp create mode 100644 source/bcstm.cpp create mode 100644 source/bcwav.cpp create mode 100644 source/binutil.cpp create mode 100644 source/helper.cpp create mode 100644 source/lz11.cpp create mode 100644 source/smdh.cpp create mode 100644 tool/main.cpp create mode 100644 tool/test.cpp create mode 160000 vendor/cli-fancy create mode 160000 vendor/palladium create mode 100644 vendor/stb/stb_image_write.h diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9994ccd --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +build/ +.cache \ No newline at end of file diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..942f534 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,6 @@ +[submodule "vendor/cli-fancy"] + path = vendor/cli-fancy + url = https://dev.npid7.de/tobid7/cli-fancy +[submodule "vendor/palladium"] + path = vendor/palladium + url = https://dev.npid7.de/tobid7/palladium.git diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json new file mode 100644 index 0000000..e39086a --- /dev/null +++ b/.vscode/c_cpp_properties.json @@ -0,0 +1,19 @@ +{ + "configurations": [ + { + "name": "Win32", + "includePath": [ + "${workspaceFolder}/**" + ], + "defines": [ + "_DEBUG", + "UNICODE", + "_UNICODE" + ], + "intelliSenseMode": "windows-gcc-x64", + "cppStandard": "c++20", + "cStandard": "c17" + } + ], + "version": 4 +} \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..a2ea29a --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,91 @@ +{ + "editor.formatOnSave": true, + "files.associations": { + "xstring": "cpp", + "xiosbase": "cpp", + "iostream": "cpp", + "atomic": "cpp", + "bit": "cpp", + "cctype": "cpp", + "charconv": "cpp", + "clocale": "cpp", + "cmath": "cpp", + "codecvt": "cpp", + "compare": "cpp", + "concepts": "cpp", + "cstddef": "cpp", + "cstdint": "cpp", + "cstdio": "cpp", + "cstdlib": "cpp", + "cstring": "cpp", + "ctime": "cpp", + "cwchar": "cpp", + "exception": "cpp", + "format": "cpp", + "fstream": "cpp", + "initializer_list": "cpp", + "ios": "cpp", + "iosfwd": "cpp", + "istream": "cpp", + "iterator": "cpp", + "limits": "cpp", + "locale": "cpp", + "memory": "cpp", + "new": "cpp", + "ostream": "cpp", + "stdexcept": "cpp", + "streambuf": "cpp", + "string": "cpp", + "system_error": "cpp", + "tuple": "cpp", + "type_traits": "cpp", + "typeinfo": "cpp", + "utility": "cpp", + "vector": "cpp", + "xfacet": "cpp", + "xlocale": "cpp", + "xlocbuf": "cpp", + "xlocinfo": "cpp", + "xlocmes": "cpp", + "xlocmon": "cpp", + "xlocnum": "cpp", + "xloctime": "cpp", + "xmemory": "cpp", + "xtr1common": "cpp", + "xutility": "cpp", + "iomanip": "cpp", + "sstream": "cpp", + "*.tcc": "cpp", + "array": "cpp", + "cstdarg": "cpp", + "cwctype": "cpp", + "deque": "cpp", + "map": "cpp", + "unordered_map": "cpp", + "algorithm": "cpp", + "functional": "cpp", + "memory_resource": "cpp", + "numeric": "cpp", + "optional": "cpp", + "random": "cpp", + "string_view": "cpp", + "numbers": "cpp", + "span": "cpp", + "text_encoding": "cpp", + "cinttypes": "cpp", + "variant": "cpp", + "csignal": "cpp", + "chrono": "cpp", + "ratio": "cpp", + "any": "cpp", + "condition_variable": "cpp", + "forward_list": "cpp", + "mutex": "cpp", + "ranges": "cpp", + "semaphore": "cpp", + "stop_token": "cpp", + "thread": "cpp", + "valarray": "cpp" + }, + "C_Cpp.default.compilerPath": "c:\\devkitPro\\msys2\\mingw64\\bin\\g++.exe" +} \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..a6a8e4e --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,46 @@ +cmake_minimum_required(VERSION 3.22) + +project(ctrff) + +set(CMAKE_CXX_STANDARD 20) +set(CMAKE_CXX_STANDARD_REQUIRED true) + +option(CTRFF_DESKTOP OFF "Buid for Desktop Platform") +option(CTRFF_3DS OFF "Build lib for 3ds") + +if(${CTRFF_3DS}) + set(CTRFF_DESKTOP OFF CACHE BOOL) + set(CTRFF_BUILD_GUI OFF CACHE BOOL) + if(NOT DEFINED CMAKE_TOOLCHAIN_FILE) + if(DEFINED ENV{DEVKITPRO}) + set(CMAKE_TOOLCHAIN_FILE "$ENV{DEVKITPRO}/cmake/3DS.cmake" CACHE PATH "toolchain file") + else() + message(FATAL_ERROR "Please define DEVKITPRO to point to your SDK path!") + endif() + endif() + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wno-psabi -O3") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_C_FLAGS} -fno-rtti") +endif() + +add_library(ctrff STATIC + source/helper.cpp + source/lz11.cpp + source/smdh.cpp + source/binutil.cpp + source/bcstm.cpp + source/bcwav.cpp + source/3dsx.cpp +) +target_include_directories(ctrff PUBLIC include vendor/palladium/include) + +if(${CTRFF_DESKTOP}) + add_executable(ctrff-cli tool/main.cpp) + target_include_directories(ctrff-cli PUBLIC include vendor/stb vendor/cli-fancy/include) + target_link_libraries(ctrff-cli PUBLIC ctrff) + add_executable(test tool/test.cpp) + target_include_directories(test PUBLIC include vendor/stb vendor/cli-fancy/include) + target_link_libraries(test PUBLIC ctrff) +endif() + +install(TARGETS ctrff) +install(DIRECTORY include DESTINATION ".") diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..3813e7f --- /dev/null +++ b/LICENSE @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) 2024 René Amthor (tobid7) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..007e697 --- /dev/null +++ b/README.md @@ -0,0 +1,46 @@ +# ctrff + +Tool/Library to work with Nintendo 3ds File formats + +## Note + +**CTRFF Requires Palladium Headers from branch devel040 (as this is the branch the lib was latest tested with)** + +## Building + +- Desktop OS + +```bash +# Note that -DCTRFF_DESKTOP is not required to build the lib for desktop +cmake -B build . -DCTRFF_DESKTOP=ON -DCMAKE_BUILD_TYPE=Release +cd build +make +``` + +- Nintendo 3ds + +```bash +# Probably should go for Debug (to debug crashes) +# You could also do --toolchain path/to/debkitpro/cmake/3DS.cmake +# instead of -DCTRFF_3DS=ON +cmake -B build . -DCTRFF_3DS=ON -DCMAKE_BUILD_TYPE=Release +cd build +make +``` + +## File Formats + +Not all Planned formates are listed here yet + +| Format | State | Notes | +| ------ | ----- | ----- | +| 3dsx | Basic Loading and Viewing of Meta Data Smdh | | +| bcstm | Loading of almost every Data | Not capable of playing them yet (prefetch kernel panic) | +| bcwav | Basic Loading (not tested yet) | Not finished yet | +| bclim | Nothing done yet (Started creating header) | | +| lz11 | Encoder done, Decoder missing | Files are bit diffrent to the ones bannertool generates (don't know why) | +| romfs | Nothing Done yet (Started creating header) | | +| smdh | Almost done | missing safetey checks | +| cbmd | Nothing done yet | | +| cgfx | Nothing Done yet | | +| darc | Nothing done yet | | diff --git a/docs/bcstm_doku.md b/docs/bcstm_doku.md new file mode 100644 index 0000000..e7323e5 --- /dev/null +++ b/docs/bcstm_doku.md @@ -0,0 +1,178 @@ +# BCSTM File Format + +**Note that this Docs are based on Current State of development and are very unfinished** + +## Contents + +- 1 [Header](#header) +- 2 [Reference](#reference) + - 2.1 [Sized Reference](#sized-reference) + - 2.2 [Reference Table](#reference-table) + - 2.3 [Reference Types](#reference-types) +- 3 [Block Header](#block-header) +- 4 [Info Block](#info-block) + - 4.1 [Stream Info](#stream-info) + - 4.2 [Channel Info](#channel-info) +- 5 [DSP ADPCM Info](#dsp-adpcm-info) + - 5.1 [DSP ADPCM Param](#dsp-adpcm-param) + - 5.2 [DSP ADPCM Context](#dsp-adpcm-context) +- 6 [Basic Data Types](#basic-datatypes) +- 7 [Tools Devices used for Research](#tools--devices--file-sources-used-for-research) + +## Header + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 4 | [u32](#u32) | Magic **'CSTM'** `0x4D545343` | +| 0x04 | 2 | [u16](#u16) | Endianness `Big == 0xfffe` `Little == 0xfeff` | +| 0x06 | 2 | [u16](#u16) | Header Size `0x40` | +| 0x08 | 4 | [u32](#u32) | Version | +| 0x0c | 4 | [u32](#u32) | File Size | +| 0x10 | 2 | [u16](#u16) | Num Blocks (Should be 3) | +| 0x12 | 2 | [u16](#u16) | Reserved | +| 0x14 | 12 | [Sized Reference](#sized-reference) | Info Block Sized Reference | +| 0x20 | 12 | [Sized Reference](#sized-reference) | Seek Block Sized Reference | +| 0x2c | 12| [Sized Reference](#sized-reference) | Data Block Sized Reference | + +## Reference + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 2 | [Reference Type](#reference-types) | TypeID | +| 0x02 | 2 | [u16](u16) | Padding | +| 0x04 | 4 | [u32](u32) | Offset **(0xffffffff represents null)** | + +### Sized Reference + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 8 | [Reference](#reference) | Reference | +| 0x08 | 4 | [u32](u32) | Size | + +### Reference Table + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 4 | [u32](#u32) | Count | +| 0x04 | Count*8 | [Reference](#reference) | References | + +### Reference Types + +| ID | Type | +|---|---| +| 0x0100 | Byte Table | +| 0x0101 | [Reference Table](#reference-table) | +| 0x0300 | [DSP ADPCM Info](#dsp-adpcm-info) | +| 0x0301 | IMA ADPCM Info | +| 0x1f00 | Sample Data | +| 0x4000 | [Info Block](#info-block) | +| 0x4001 | Seek Block | +| 0x4002 | Data Block | +| 0x4100 | [Stream Info](#stream-info) | +| 0x4101 | Track Info | +| 0x4102 | [Channel Info](#channel-info) | + +## Block Header + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 4 | [u32](#u32) | Magic | +| 0x04 | 4 | [u32](#u32) | Size | + +## Info Block + +All Reference Offsets at the beginning of Info Block are Relative to the **Infoblock + 0x08 (size of Block Header) Position** + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 8 | [Block Header](#block-header) | Block Header | +| 0x08 | 8 | [Reference](#reference) | Stream Info Reference | +| 0x10 | 8 | [Reference](#reference) | Track Info Reference Table Reference | +| 0x18 | 8 | [Reference](#reference) | Channel Info Reference Table Table Reference | +| 0x20 | 56 | [Stream Info](#stream-info) | Stream Info | + +### Stream Info + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 1 | [u8](#u8) | Encoding | +| 0x01 | 1 | [u8](#u8) | Loop `1 == true -- 0 == false` | +| 0x02 | 1 | [u8](#u8) | Num Channels | +| 0x03 | 1 | [u8](#u8) | Padding | +| 0x04 | 4 | [u32](#u32) | Sample Rate | +| 0x04 | 4 | [u32](#u32) | Loop Start | +| 0x04 | 4 | [u32](#u32) | Loop End | +| 0x04 | 4 | [u32](#u32) | Sample Blocks | +| 0x04 | 4 | [u32](#u32) | Sample Block Size | +| 0x04 | 4 | [u32](#u32) | Sample Block Samples | +| 0x04 | 4 | [u32](#u32) | Last Sample Block Size | +| 0x04 | 4 | [u32](#u32) | Last Sample Block Samples | +| 0x04 | 4 | [u32](#u32) | Last Sample Block Padded Size | +| 0x04 | 4 | [u32](#u32) | Seek Data Size | +| 0x04 | 4 | [u32](#u32) | Seek Interval Samples | +| 0x04 | 4 | [Reference](#reference) | Sample Data Reference | + +### Channel Info + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 8 | [Reference](#reference) | Reference to [DSP ADPCM Info](#dsp-adpcm-info) **!!! The Offsets are Relative to the start Pos of the Channel Info Object !!!** | + +## DSP ADPCM Info + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 32 | [Param](#dsp-adpcm-param) | Coefficients | +| 0x20 | 6 | [DSP Context](#dsp-adpcm-context) | Context | +| 0x26 | 6 | [DSP Context](#dsp-adpcm-context) | Loop Context | +| 0x2c | 2 | [u16](#u16) | Padding | + +### DSP ADPCM Param + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 32 | [u16](#u16) | 16 Bit Coefficients | + +### DSP ADPCM Context + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 1 | [u8](#u8) | 4Bit Predictor and 4Bit Scale | +| 0x01 | 1 | [u8](#u8) | Reserved | +| 0x02 | 2 | [16](#u16) | Previous Sample | +| 0x02 | 2 | [16](#u16) | Second Previous Sample | + +## Basic Datatypes + +### u32 + +```cpp +using u32 = unsigned int; // or uint32_t +``` + +### u16 + +```cpp +using u16 = unsigned short; // or uint16_t +``` + +### u8 + +```cpp +using u8 = unsigned char; // or uint8_t +``` + +## Tools / Devices / File SOurces used for research + +| Name | Description | +|---|---| +| Visual Studio Code | Used for creating ctrff c++ code for bcstm | +| ImHex | Used to Analyze the Hex Code of the bcstm Files | +| Citra | Fast way to generate Log files when developing ctrff | +| ctrff-cli | Tool to generate Debug Output on Desktop OS like seen in BCSTM-Player File inspector | +| New 3ds XL | Testing on Real Hardware (BCSTM-Player) | +| Mario Kart 7 (Cartridge) | Used to get Test files | +| CTGP 7 | Used to get Test files | +| Super Mario Maker 3ds (Cartridge) | Used to get Test files | +| Mario and Luigi Bowsers inside story (Cartridge) | Used to get Test files | +| Donkey Kong Country Returns 3D | Used to get Test files | diff --git a/docs/bcwav_doku.md b/docs/bcwav_doku.md new file mode 100644 index 0000000..1561418 --- /dev/null +++ b/docs/bcwav_doku.md @@ -0,0 +1,178 @@ +# BCWAV File Format + +**Note that this Docs are based on Current State of development and are very unfinished** + +**This file can be very incorect due to copying from bcstm_doku.md** + +## Contents + +- 1 [Header](#header) +- 2 [Reference](#reference) + - 2.1 [Sized Reference](#sized-reference) + - 2.2 [Reference Table](#reference-table) + - 2.3 [Reference Types](#reference-types) +- 3 [Block Header](#block-header) +- 4 [Info Block](#info-block) + - 4.1 [Stream Info](#stream-info) + - 4.2 [Channel Info](#channel-info) +- 5 [DSP ADPCM Info](#dsp-adpcm-info) + - 5.1 [DSP ADPCM Param](#dsp-adpcm-param) + - 5.2 [DSP ADPCM Context](#dsp-adpcm-context) +- 6 [Basic Data Types](#basic-datatypes) +- 7 [Tools Devices used for Research](#tools--devices--file-sources-used-for-research) + +## Header + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 4 | [u32](#u32) | Magic **'CWAV'** `0x56415743` | +| 0x04 | 2 | [u16](#u16) | Endianness `Big == 0xfffe` `Little == 0xfeff` | +| 0x06 | 2 | [u16](#u16) | Header Size `0x40` | +| 0x08 | 4 | [u32](#u32) | Version | +| 0x0c | 4 | [u32](#u32) | File Size | +| 0x10 | 2 | [u16](#u16) | Num Blocks (Should be 2) | +| 0x12 | 2 | [u16](#u16) | Reserved | +| 0x14 | 12 | [Sized Reference](#sized-reference) | Info Block Sized Reference | +| 0x20 | 12| [Sized Reference](#sized-reference) | Data Block Sized Reference | + +## Reference + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 2 | [Reference Type](#reference-types) | TypeID | +| 0x02 | 2 | [u16](u16) | Padding | +| 0x04 | 4 | [u32](u32) | Offset **(0xffffffff represents null)** | + +### Sized Reference + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 8 | [Reference](#reference) | Reference | +| 0x08 | 4 | [u32](u32) | Size | + +### Reference Table + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 4 | [u32](#u32) | Count | +| 0x04 | Count*8 | [Reference](#reference) | References | + +### Reference Types + +| ID | Type | +|---|---| +| 0x0300 | [DSP ADPCM Info](#dsp-adpcm-info) | +| 0x0301 | IMA ADPCM Info | +| 0x1f00 | Sample Data | +| 0x7000 | [Info Block](#info-block) | +| 0x7001 | Data Block | +| 0x7100 | [Channel Info](#channel-info) | + +## Block Header + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 4 | [u32](#u32) | Magic | +| 0x04 | 4 | [u32](#u32) | Size | + +## Info Block + +All Reference Offsets at the beginning of Info Block are Relative to the **Infoblock + 0x08 (size of Block Header) Position** + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 8 | [Block Header](#block-header) | Block Header | +| 0x08 | 1 | [u8](#u8) | Encoding | +| 0x09 | 1 | [u8](#u8) | Loop `1 == true -- 0 == false` | +| 0x0a | 1 | [u16](#u16) | Padding | +| 0x0c | 4 | [u32](#u32) | Sample Rate | +| 0x10 | 4 | [u32](#u32) | Loop Start | +| 0x14 | 4 | [u32](#u32) | Loop End | +| 0x18 | 4 | [u32](#u32) | Reserved | +| 0x18 | 8 | [Reference Table](#reference-table) | Channel Info Reference Table | + +### Stream Info + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 1 | [u8](#u8) | Encoding | +| 0x01 | 1 | [u8](#u8) | Loop `1 == true -- 0 == false` | +| 0x02 | 1 | [u8](#u8) | Num Channels | +| 0x03 | 1 | [u8](#u8) | Padding | +| 0x04 | 4 | [u32](#u32) | Sample Rate | +| 0x04 | 4 | [u32](#u32) | Loop Start | +| 0x04 | 4 | [u32](#u32) | Loop End | +| 0x04 | 4 | [u32](#u32) | Sample Blocks | +| 0x04 | 4 | [u32](#u32) | Sample Block Size | +| 0x04 | 4 | [u32](#u32) | Sample Block Samples | +| 0x04 | 4 | [u32](#u32) | Last Sample Block Size | +| 0x04 | 4 | [u32](#u32) | Last Sample Block Samples | +| 0x04 | 4 | [u32](#u32) | Last Sample Block Padded Size | +| 0x04 | 4 | [u32](#u32) | Seek Data Size | +| 0x04 | 4 | [u32](#u32) | Seek Interval Samples | +| 0x04 | 4 | [Reference](#reference) | Sample Data Reference | + +### Channel Info + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 8 | [Reference](#reference) | Reference to [DSP ADPCM Info](#dsp-adpcm-info) **!!! The Offsets are Relative to the start Pos of the Channel Info Object !!!** | + +## DSP ADPCM Info + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 32 | [Param](#dsp-adpcm-param) | Coefficients | +| 0x20 | 6 | [DSP Context](#dsp-adpcm-context) | Context | +| 0x26 | 6 | [DSP Context](#dsp-adpcm-context) | Loop Context | +| 0x2c | 2 | [u16](#u16) | Padding | + +### DSP ADPCM Param + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 32 | [u16](#u16) | 16 Bit Coefficients | + +### DSP ADPCM Context + +| Offset | Size | Datatype | Description | +|---|---|---|---| +| 0x00 | 1 | [u8](#u8) | 4Bit Predictor and 4Bit Scale | +| 0x01 | 1 | [u8](#u8) | Reserved | +| 0x02 | 2 | [16](#u16) | Previous Sample | +| 0x02 | 2 | [16](#u16) | Second Previous Sample | + +## Basic Datatypes + +### u32 + +```cpp +using u32 = unsigned int; // or uint32_t +``` + +### u16 + +```cpp +using u16 = unsigned short; // or uint16_t +``` + +### u8 + +```cpp +using u8 = unsigned char; // or uint8_t +``` + +## Tools / Devices / File SOurces used for research + +| Name | Description | +|---|---| +| Visual Studio Code | Used for creating ctrff c++ code for bcstm | +| ImHex | Used to Analyze the Hex Code of the bcstm Files | +| Citra | Fast way to generate Log files when developing ctrff | +| ctrff-cli | Tool to generate Debug Output on Desktop OS like seen in BCSTM-Player File inspector | +| New 3ds XL | Testing on Real Hardware (BCSTM-Player) | +| Mario Kart 7 (Cartridge) | Used to get Test files | +| CTGP 7 | Used to get Test files | +| Super Mario Maker 3ds (Cartridge) | Used to get Test files | +| Mario and Luigi Bowsers inside story (Cartridge) | Used to get Test files | +| Donkey Kong Country Returns 3D | Used to get Test files | diff --git a/include/ctrff.hpp b/include/ctrff.hpp new file mode 100644 index 0000000..57a40f2 --- /dev/null +++ b/include/ctrff.hpp @@ -0,0 +1,8 @@ +#pragma once + +#include +#include +#include +#include +#include +#include diff --git a/include/ctrff/3dsx.hpp b/include/ctrff/3dsx.hpp new file mode 100644 index 0000000..b660f22 --- /dev/null +++ b/include/ctrff/3dsx.hpp @@ -0,0 +1,48 @@ +#pragma once + +#include +#include +#include +#include + +namespace ctrff { +class CTRFF_API _3dsx : public BinFile { + public: + _3dsx() {} + ~_3dsx() {} + + void Load(const std::string& path) { + std::fstream f(path, std::ios::in | std::ios::binary); + Read(f); + f.close(); + } + + bool HasMeta() { return SMDHSize == SMDH_Size; } + + /** Write not supported btw */ + void Write(std::fstream& f) const override; + void Read(std::fstream& f) override; + + PD::u32 Magic; + PD::u16 HeaderSize; + PD::u16 RelocHeaderSize; + PD::u32 FormatVersion; + PD::u32 Flags; + // Sizes of the code, rodata and data segments + + // size of the BSS section (uninitialized latter half of the data segment) + PD::u32 CodeSegSize; + PD::u32 RodataSegSize; + PD::u32 DataSegSize; + PD::u32 BssSize; + /// Extended Header /// + // smdh offset + PD::u32 SMDHOff; + // smdh size + PD::u32 SMDHSize; + // fs offset + PD::u32 FsOff; + SMDH Meta; +}; +/** Probably only germen people will understand */ +using DreiDSX = _3dsx; +} // namespace ctrff \ No newline at end of file diff --git a/include/ctrff/bcstm.hpp b/include/ctrff/bcstm.hpp new file mode 100644 index 0000000..ffac6a9 --- /dev/null +++ b/include/ctrff/bcstm.hpp @@ -0,0 +1,241 @@ +#pragma once + +#include +#include +#include + +namespace ctrff { +class CTRFF_API BCSTM { + public: + BCSTM() : pReader(pFile) {} + ~BCSTM() { CleanUp(); } + + void LoadFile(const std::string& path); + void CleanUp(); + void ReadGotoBeginning(bool use_loop_beg = false); + void ReadBlock(PD::u32 block, PD::u8* ref); + PD::u32 LeseZeiger() { return pFile.tellg(); } + + /** Some useful Getters */ + PD::u8 GetNumChannels() const { return pInfoBlock.StreamInfo.ChannelCount; } + PD::u32 GetSampleRate() const { return pInfoBlock.StreamInfo.SampleRate; } + PD::u32 GetBlockSize() const { return pInfoBlock.StreamInfo.SampleBlockSize; } + PD::u32 GetNumBlocks() const { return pInfoBlock.StreamInfo.SampleBlockNum; } + PD::u32 GetBlockSamples() const { + return pInfoBlock.StreamInfo.SampleBlockSampleNum; + } + PD::u32 GetLastBlockSamples() const { + return pInfoBlock.StreamInfo.LastSampleBlockSampleNum; + } + bool IsLooping() const { return pInfoBlock.StreamInfo.Loop; } + PD::u32 GetLoopStart() const { + return pInfoBlock.StreamInfo.LoopStartFrame / GetNumBlocks(); + } + PD::u32 GetLoopEnd() const { + /** Get temp references for better readability */ + const PD::u32& loop_end = pInfoBlock.StreamInfo.LoopEndFrame; + const PD::u32& block_samples = GetNumBlocks(); + return (loop_end % block_samples ? block_samples + : loop_end / block_samples); + } + + /** Internal Data (can be made private with private: but public by default) */ + enum Endianness : PD::u16 { + Big = 0xfffe, ///< Big Endian + Little = 0xfeff, ///< Little Endian + }; + + enum ReferenceTypes : PD::u16 { + Ref_ByteTable = 0x0100, + Ref_ReferenceTable = 0x0101, + Ref_DSP_ADPCM_Info = 0x0300, + Ref_IMA_ADPCM_Info = 0x0301, + Ref_SampleData = 0x1f00, + Ref_InfoBlock = 0x4000, + Ref_SeekBlock = 0x4001, + Ref_DataBlock = 0x4002, + Ref_StreamInfo = 0x4100, + Ref_TrackInfo = 0x4101, + Ref_ChannelInfo = 0x4102, + }; + + enum Encoding : PD::u8 { + PCM8 = 0, + PCM16 = 1, + /** Only supported encoding in BCSTM-Player */ + DSP_ADPCM = 2, + IMA_ADPCM = 3, + }; + + struct Reference { + PD::u16 TypeID; + PD::u16 Padding; + PD::u32 Offset; /** null -> uint32_max */ + }; + + struct ReferenceTable { + PD::u32 Count; + PD::Vec Refs; + }; + + struct SizedReference { + Reference Ref; + PD::u32 Size; + }; + + struct StreamInfo { + PD::u8 Encoding; + PD::u8 Loop; + PD::u8 ChannelCount; + PD::u8 Padding; + PD::u32 SampleRate; + PD::u32 LoopStartFrame; + PD::u32 LoopEndFrame; + PD::u32 SampleBlockNum; + PD::u32 SampleBlockSize; + PD::u32 SampleBlockSampleNum; + PD::u32 LastSampleBlockSize; + PD::u32 LastSampleBlockSampleNum; + PD::u32 LastSampleBlockPaddedSize; + PD::u32 SeekDataSize; + PD::u32 SeekIntervalSampleNum; + Reference SampleDataRef; + }; + + struct BlockHeader { + PD::u32 Magic; + PD::u32 Size; + }; + + struct InfoBlock { + BlockHeader Header; + Reference StreamInfoRef; + Reference TrackInfoTabRef; + Reference ChannelInfoTabRef; + BCSTM::StreamInfo StreamInfo; + ReferenceTable TrackInfoTab; + ReferenceTable ChannelInfoTab; + PD::Vec ChannelInfoRefs; /** The refs of the refs ?? */ + }; + + /** SeekDataBlock cause they are the same struct */ + struct SD_Block { + BlockHeader Header; + PD::Vec Data; + }; + + struct DSP_ADPCM_Param { + PD::u16 Coefficients[0x10]; + }; + struct DSP_ADPCM_Context { + PD::u8 PredictorScale; + PD::u8 Reserved; + PD::u16 PreviousSample; + PD::u16 SecondPreviousSample; + }; + + struct DSP_ADPCM_Info { + DSP_ADPCM_Param Param; + DSP_ADPCM_Context Context; + DSP_ADPCM_Context LoopContext; + PD::u16 Padding; + }; + + struct ByteTable { + PD::u32 Size; + PD::Vec Table; + }; + + struct TrackInfo { + PD::u8 Volume; + PD::u8 Pan; + PD::u16 Padding; + Reference ChennelIndexTabRef; + ByteTable ChannelIndexTab; + }; + + struct Header { + PD::u32 Magic; /** CSTM */ + PD::u16 Endianness = Little; /** Default */ + PD::u16 HeaderSize; /** Header Size probably */ + PD::u32 Version; /** Format Version? */ + PD::u32 FileSize; /** File Size */ + PD::u16 NumBlocks; /** Number of blocks */ + PD::u16 Reserved; /** Reserved */ + }; + + Header pHeader; + SizedReference pInfoBlockRef; + SizedReference pSeekBlockRef; + SizedReference pDataBlockRef; + InfoBlock pInfoBlock; + SD_Block pSeekBlock; + SD_Block pDataBlock; + PD::Vec pDSP_ADPCM_Info; + /** File Stream */ + std::fstream pFile; + /** Endianness based reader */ + BinUtil pReader; + + void ReadReference(Reference& ref); + void ReadSizedReference(SizedReference& ref); + void ReadInfoBlock(InfoBlock& block); + void ReadSeekBlock(SD_Block& block); + void ReadReferenceTab(ReferenceTable& tab); + + static std::string Endianness2String(const Endianness& e) { + switch (e) { + case Little: + return "Little"; + case Big: + return "Big"; + default: + return "Unknown"; + } + } + + static std::string ReferenceType2String(const ReferenceTypes& e) { + switch (e) { + case Ref_ByteTable: + return "ByteTable"; + case Ref_ReferenceTable: + return "ReferenceTable"; + case Ref_DSP_ADPCM_Info: + return "DSP_ADPCM_Info"; + case Ref_IMA_ADPCM_Info: + return "IMA_ADPCM_Info"; + case Ref_SampleData: + return "SampleData"; + case Ref_InfoBlock: + return "InfoBlock"; + case Ref_SeekBlock: + return "SeekBlock"; + case Ref_DataBlock: + return "DataBlock"; + case Ref_StreamInfo: + return "StreamInfo"; + case Ref_TrackInfo: + return "TrackInfo"; + case Ref_ChannelInfo: + return "ChannelInfo"; + default: + return "Unknown"; + } + } + + static std::string Encoding2String(const Encoding& e) { + switch (e) { + case PCM8: + return "PCM8"; + case PCM16: + return "PCM16"; + case DSP_ADPCM: + return "DSP ADPCM"; + case IMA_ADPCM: + return "IMA ADPCM"; + default: + return "Unknown"; + } + } +}; +} // namespace ctrff diff --git a/include/ctrff/bcwav.hpp b/include/ctrff/bcwav.hpp new file mode 100644 index 0000000..5b84d69 --- /dev/null +++ b/include/ctrff/bcwav.hpp @@ -0,0 +1,188 @@ +#pragma once + +#include +#include +#include + +namespace ctrff { +class CTRFF_API BCWAV { + public: + BCWAV() : pReader(pFile) {} + ~BCWAV() { CleanUp(); } + + void LoadFile(const std::string& path); + void CleanUp(); + void ReadGotoBeginning(bool use_loop_beg = false); + void ReadBlock(PD::u32 block, PD::u8* ref); + + /** Internal Data (can be made private with private: but public by default) */ + enum Endianness : PD::u16 { + Big = 0xfffe, ///< Big Endian + Little = 0xfeff, ///< Little Endian + }; + + enum ReferenceTypes : PD::u16 { + Ref_DSP_ADPCM_Info = 0x0300, + Ref_IMA_ADPCM_Info = 0x0301, + Ref_SampleData = 0x1f00, + Ref_InfoBlock = 0x7000, + Ref_DataBlock = 0x7001, + Ref_ChannelInfo = 0x7100, + }; + + enum Encoding : PD::u8 { + PCM8 = 0, + PCM16 = 1, + /** Only supported encoding in BCSTM-Player */ + DSP_ADPCM = 2, + IMA_ADPCM = 3, + }; + + struct Reference { + PD::u16 TypeID; + PD::u16 Padding; + PD::u32 Offset; /** null -> uint32_max */ + }; + + struct ReferenceTable { + PD::u32 Count; + PD::Vec Refs; + }; + + struct SizedReference { + Reference Ref; + PD::u32 Size; + }; + + struct StreamInfo { + PD::u8 Encoding; + PD::u8 Loop; + PD::u8 ChannelCount; + PD::u8 Padding; + PD::u32 SampleRate; + PD::u32 LoopStartFrame; + PD::u32 LoopEndFrame; + PD::u32 SampleBlockNum; + PD::u32 SampleBlockSize; + PD::u32 SampleBlockSampleNum; + PD::u32 LastSampleBlockSize; + PD::u32 LastSampleBlockSampleNum; + PD::u32 LastSampleBlockPaddedSize; + PD::u32 SeekDataSize; + PD::u32 SeekIntervalSampleNum; + Reference SampleDataRef; + }; + + struct BlockHeader { + PD::u32 Magic; + PD::u32 Size; + }; + + struct InfoBlock { + BlockHeader Header; + PD::u8 Encoding; + PD::u8 Loop; + PD::u16 Padding; + PD::u32 SampleRate; + PD::u32 LoopStartFrame; + PD::u32 LoopEndFrame; + PD::u32 Reserved; + ReferenceTable ChannelInfoTab; + PD::Vec ChannelInfoRefs; /** The refs of the refs ?? */ + }; + + struct DataBlock { + BlockHeader Header; + PD::u32 Padding[3]; + PD::Vec Data; + }; + + struct DSP_ADPCM_Param { + PD::u16 Coefficients[0x10]; + }; + struct DSP_ADPCM_Context { + PD::u8 PredictorScale; + PD::u8 Reserved; + PD::u16 PreviousSample; + PD::u16 SecondPreviousSample; + }; + + struct DSP_ADPCM_Info { + DSP_ADPCM_Param Param; + DSP_ADPCM_Context Context; + DSP_ADPCM_Context LoopContext; + PD::u16 Padding; + }; + + struct Header { + PD::u32 Magic; /** CWAV */ + PD::u16 Endianness = Little; /** Default */ + PD::u16 HeaderSize; /** Header Size probably */ + PD::u32 Version; /** Format Version? */ + PD::u32 FileSize; /** File Size */ + PD::u16 NumBlocks; /** Number of blocks */ + PD::u16 Reserved; /** Reserved */ + }; + + Header pHeader; + SizedReference pInfoBlockRef; + SizedReference pDataBlockRef; + InfoBlock pInfoBlock; + DataBlock pDataBlock; + PD::Vec pDSP_ADPCM_Info; + /** File Stream */ + std::fstream pFile; + /** Endianness based reader */ + BinUtil pReader; + + void ReadReference(Reference& ref); + void ReadSizedReference(SizedReference& ref); + void ReadInfoBlock(InfoBlock& block); + void ReadReferenceTab(ReferenceTable& tab); + + static std::string Endianness2String(const Endianness& e) { + switch (e) { + case Little: + return "Little"; + case Big: + return "Big"; + default: + return "Unknown"; + } + } + + static std::string ReferenceType2String(const ReferenceTypes& e) { + switch (e) { + case Ref_DSP_ADPCM_Info: + return "DSP_ADPCM_Info"; + case Ref_IMA_ADPCM_Info: + return "IMA_ADPCM_Info"; + case Ref_SampleData: + return "SampleData"; + case Ref_InfoBlock: + return "InfoBlock"; + case Ref_DataBlock: + return "DataBlock"; + case Ref_ChannelInfo: + return "ChannelInfo"; + default: + return "Unknown"; + } + } + + static std::string Encoding2String(const Encoding& e) { + switch (e) { + case PCM8: + return "PCM8"; + case PCM16: + return "PCM16"; + case DSP_ADPCM: + return "DSP ADPCM"; + case IMA_ADPCM: + return "IMA ADPCM"; + default: + return "Unknown"; + } + } +}; +} // namespace ctrff \ No newline at end of file diff --git a/include/ctrff/binutil.hpp b/include/ctrff/binutil.hpp new file mode 100644 index 0000000..b08a3b9 --- /dev/null +++ b/include/ctrff/binutil.hpp @@ -0,0 +1,43 @@ +#pragma once + +#include +#include + +namespace ctrff { +class BinFile { + public: + BinFile() = default; + ~BinFile() = default; + + virtual void Write(std::fstream& s) const = 0; + virtual void Read(std::fstream& s) = 0; +}; + +class CTRFF_API BinUtil { + public: + BinUtil(std::fstream& f, bool big = false) : m_file(f), m_big(big) {} + ~BinUtil() = default; + + void SetEndianess(bool big) { m_big = big; } + + template + void Read(T& v); + template + void Write(const T& v); + /** Note that this func ignores Endianness */ + template + void ReadEx(T& v) { + static_assert(std::is_trivially_copyable_v, "Cannot Read type T"); + m_file.read(reinterpret_cast(&v), sizeof(T)); + } + /** Note that this func ignores Endianness */ + template + void WriteEx(T& v) { + m_file.write(reinterpret_cast(&v), sizeof(T)); + } + + private: + std::fstream& m_file; + bool m_big; +}; +} // namespace ctrff \ No newline at end of file diff --git a/include/ctrff/helper.hpp b/include/ctrff/helper.hpp new file mode 100644 index 0000000..6fc33d2 --- /dev/null +++ b/include/ctrff/helper.hpp @@ -0,0 +1,16 @@ +#pragma once + +#include +#include + +namespace ctrff { +CTRFF_API void String2U16(PD::u16 *res, const std::string &src, size_t max); +CTRFF_API std::string U16toU8(PD::u16 *in, size_t max); +CTRFF_API void RGB565toRGBA(std::vector &img, PD::u16 *icon, + const int &w, const int &h); +// Image can only be rgba8888 +CTRFF_API void RGBA2RGB565(PD::u16 *out, const std::vector &img, + const int &w, const int &h); +CTRFF_API std::vector DownscaleImage(const std::vector &img, + int w, int h, int scale); +} // namespace ctrff \ No newline at end of file diff --git a/include/ctrff/lz11.hpp b/include/ctrff/lz11.hpp new file mode 100644 index 0000000..de13c69 --- /dev/null +++ b/include/ctrff/lz11.hpp @@ -0,0 +1,10 @@ +#pragma once + +#include +#include + +namespace ctrff { +namespace LZ11 { +CTRFF_API std::vector Compress(const std::vector& in); +} +} // namespace ctrff \ No newline at end of file diff --git a/include/ctrff/pd_p_api.hpp b/include/ctrff/pd_p_api.hpp new file mode 100644 index 0000000..ebd393e --- /dev/null +++ b/include/ctrff/pd_p_api.hpp @@ -0,0 +1,50 @@ +#pragma once + +/* +MIT License + +Copyright (c) 2024 - 2025 tobid7 + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifdef _WIN32 // Windows (MSVC Tested) +#ifdef CTRFF_BUILD_SHARED +#define CTRFF_API __declspec(dllexport) +#else +#define CTRFF_API __declspec(dllimport) +#endif +#elif defined(__APPLE__) // macOS (untested yet) +#ifdef CTRFF_BUILD_SHARED +#define CTRFF_API __attribute__((visibility("default"))) +#else +#define CTRFF_API +#endif +#elif defined(__linux__) // Linux (untested yet) +#ifdef CTRFF_BUILD_SHARED +#define CTRFF_API __attribute__((visibility("default"))) +#else +#define CTRFF_API +#endif +#elif defined(__3DS__) // 3ds Specific +// Only Static supported +#define CTRFF_API +#else +#define CTRFF_API +#endif \ No newline at end of file diff --git a/include/ctrff/smdh.hpp b/include/ctrff/smdh.hpp new file mode 100644 index 0000000..68a3b90 --- /dev/null +++ b/include/ctrff/smdh.hpp @@ -0,0 +1,143 @@ +#pragma once + +#include +#include +#include +#include + +// Basic Info +// language_slots: 16 +// valid_language_slots: 12 +// rating_slots: 16 +// small_icon: 24 +// large_icon = 48 + +namespace ctrff { +// SMDH Size (Note that this needs to be declared here as +// a sizeof(SMDH) will not return the expected size due to +// use of Serializable) +constexpr PD::u32 SMDH_Size = 0x36C0; +struct CTRFF_API SMDH { + SMDH() { + std::fill_n(Magic, PD::ArraySize(Magic), 0); + std::fill_n(IconSmall, PD::ArraySize(IconSmall), 0); + std::fill_n(IconLarge, PD::ArraySize(IconLarge), 0); + } + ~SMDH() = default; + static SMDH Default(); + PD_SMART_CTOR(SMDH); + + enum Language { + Language_Japanese, + Language_English, + Language_French, + Language_German, + Language_Italian, + Language_Spanish, + Language_Chinese_Simplified, + Language_Korean, + Language_Dutch, + Language_Portuguese, + Language_Russian, + Language_Chinese_Traditional, + // To Overrite Aall Languages + // returns japanese on get funcs + Language_All = 0x47, + }; + enum Rating { + Rating_CERO = 0, + Rating_ESRB = 1, + Rating_USK = 3, + Rating_PEGI_GEN = 4, + Rating_PEGI_PTR = 6, + Rating_PEGI_BBFC = 7, + Rating_COB = 8, + Rating_GRB = 9, + Rating_CGSRR = 10, + }; + enum Region { + Region_JAPAN = 1 << 0, + Region_NORTH_AMERICA = 1 << 1, + Region_EUROPE = 1 << 2, + Region_AUSTRALIA = 1 << 3, + Region_CHINA = 1 << 4, + Region_KOREA = 1 << 5, + Region_TAIWAN = 1 << 6, + // Not a bitmask, but a value. + Region_FREE = 0x7FFFFFFF, + }; + + enum Flag { + Flag_VISIBLE = 1 << 0, + Flag_AUTO_BOOT = 1 << 1, + Flag_ALLOW_3D = 1 << 2, + Flag_REQUIRE_EULA = 1 << 3, + Flag_AUTO_SAVE_ON_EXIT = 1 << 4, + Flag_USE_EXTENDED_BANNER = 1 << 5, + Flag_RATING_REQUIED = 1 << 6, + Flag_USE_SAVE_DATA = 1 << 7, + Flag_RECORD_USAGE = 1 << 8, + Flag_DISABLE_SAVE_BACKUPS = 1 << 10, + Flag_NEW_3DS = 1 << 12, + Flag_DEFAULT = Flag_VISIBLE | Flag_ALLOW_3D | Flag_RECORD_USAGE, + }; + + void Load(const std::string &path) { + std::fstream f(path, std::ios::in | std::ios::binary); + Read(f); + f.close(); + } + + void Save(const std::string &path) { + std::fstream f(path, std::ios::out | std::ios::binary); + Write(f); + f.close(); + } + + void Write(std::fstream &f) const; + void Read(std::fstream &f); + + void SetIcon(const std::vector &buf); + std::vector GetIcon(); + void SetShortTitle(const std::string &t, Language l = Language_All); + void SetLongTitle(const std::string &t, Language l = Language_All); + void SetAuthor(const std::string &t, Language l = Language_All); + std::string GetShortTitle(Language l = Language_All); + std::string GetLongTitle(Language l = Language_All); + std::string GetAuthor(Language l = Language_All); + + struct CTRFF_API Title { + Title() { + std::fill_n(ShortTitle, PD::ArraySize(ShortTitle), 0); + std::fill_n(LongTitle, PD::ArraySize(LongTitle), 0); + std::fill_n(Author, PD::ArraySize(Author), 0); + }; + + PD::u16 ShortTitle[0x40]; + PD::u16 LongTitle[0x80]; + PD::u16 Author[0x40]; + }; + + struct CTRFF_API Settings { + Settings() { std::fill_n(Ratings, PD::ArraySize(Ratings), 0); }; + PD::u8 Ratings[16]; + PD::u32 RegionLock = 0; + PD::u32 MatchmakerID = 0; + PD::u64 MatchmakerBitID = 0; + PD::u32 Flags = 0; + PD::u16 EulaVersion = 0; + PD::u16 Reserved = 0; + PD::u32 OptimalBannerFrame = 0; + PD::u32 StreetpassID = 0; + }; + + char Magic[4]; + PD::u16 Version = 0; + PD::u16 Reserved = 0; + Title Titles[16]; + Settings Settings; + PD::u64 Reserved1 = 0; + PD::u16 IconSmall[0x240]; // 24x24 + PD::u16 IconLarge[0x900]; // 48x48 +}; +} // namespace ctrff \ No newline at end of file diff --git a/source/3dsx.cpp b/source/3dsx.cpp new file mode 100644 index 0000000..3a93a25 --- /dev/null +++ b/source/3dsx.cpp @@ -0,0 +1,29 @@ +#include +#include + +namespace ctrff { +CTRFF_API void _3dsx::Write(std::fstream& f) const { + // To be written +} + +CTRFF_API void _3dsx::Read(std::fstream& f) { + BinUtil r(f); + r.ReadEx(Magic); + r.ReadEx(HeaderSize); + r.ReadEx(RelocHeaderSize); + r.ReadEx(FormatVersion); + r.ReadEx(Flags); + r.ReadEx(CodeSegSize); + r.ReadEx(RodataSegSize); + r.ReadEx(DataSegSize); + r.ReadEx(BssSize); + r.ReadEx(SMDHOff); + r.ReadEx(SMDHSize); + r.ReadEx(FsOff); + + if (HasMeta()) { + f.seekg(SMDHOff, std::ios::beg); + Meta.Read(f); + } +} +} // namespace ctrff \ No newline at end of file diff --git a/source/bcstm.cpp b/source/bcstm.cpp new file mode 100644 index 0000000..c5de545 --- /dev/null +++ b/source/bcstm.cpp @@ -0,0 +1,189 @@ +#include + +/** Using this a single time so inline it */ +inline PD::u32 Swap32(PD::u32 in) { + return (in >> 24) | ((in >> 8) & 0x0000FF00) | ((in << 8) & 0x00FF0000) | + (in << 24); +} + +namespace ctrff { +CTRFF_API void BCSTM::LoadFile(const std::string& path) { + CleanUp(); + pFile.open(path, std::ios::in | std::ios::binary); + if (!pFile.is_open()) { + throw std::runtime_error("BCSTM Error: File not found!"); + } + + pReader.Read(pHeader.Magic); + pReader.Read(pHeader.Endianness); + if (pHeader.Endianness == Big) { + pHeader.Magic = Swap32(pHeader.Magic); + } + /** Check for 'CSTM' */ + if (pHeader.Magic != 0x4D545343) { + throw std::runtime_error("BCSTM Error: Invalid File!"); + } + pReader.Read(pHeader.HeaderSize); + pReader.Read(pHeader.Version); + pReader.Read(pHeader.FileSize); + pReader.Read(pHeader.NumBlocks); + pReader.Read(pHeader.Reserved); + for (PD::u16 i = 0; i < pHeader.NumBlocks; i++) { + SizedReference ref; + ReadSizedReference(ref); + if (ref.Ref.TypeID == Ref_InfoBlock) { + pInfoBlockRef = ref; + } else if (ref.Ref.TypeID == Ref_SeekBlock) { + pSeekBlockRef = ref; + } else if (ref.Ref.TypeID == Ref_DataBlock) { + pDataBlockRef = ref; + } + } + pFile.seekg(pInfoBlockRef.Ref.Offset); + ReadInfoBlock(pInfoBlock); + ReadGotoBeginning(); +} + +CTRFF_API void BCSTM::ReadReference(Reference& ref) { + pReader.Read(ref.TypeID); + pReader.Read(ref.Padding); + pReader.Read(ref.Offset); +} +CTRFF_API void BCSTM::ReadSizedReference(SizedReference& ref) { + ReadReference(ref.Ref); + pReader.Read(ref.Size); +} + +CTRFF_API void BCSTM::ReadInfoBlock(InfoBlock& block) { + pReader.Read(block.Header.Magic); + pReader.Read(block.Header.Size); + ReadReference(block.StreamInfoRef); + ReadReference(block.TrackInfoTabRef); + ReadReference(block.ChannelInfoTabRef); + pReader.Read(block.StreamInfo.Encoding); + if (block.StreamInfo.Encoding != DSP_ADPCM) { + throw std::runtime_error("Only DSP ADPCM is supported yet!"); + } + pReader.Read(block.StreamInfo.Loop); + pReader.Read(block.StreamInfo.ChannelCount); + pReader.Read(block.StreamInfo.Padding); + pReader.Read(block.StreamInfo.SampleRate); + pReader.Read(block.StreamInfo.LoopStartFrame); + pReader.Read(block.StreamInfo.LoopEndFrame); + pReader.Read(block.StreamInfo.SampleBlockNum); + pReader.Read(block.StreamInfo.SampleBlockSize); + pReader.Read(block.StreamInfo.SampleBlockSampleNum); + pReader.Read(block.StreamInfo.LastSampleBlockSize); + pReader.Read(block.StreamInfo.LastSampleBlockSampleNum); + pReader.Read(block.StreamInfo.LastSampleBlockPaddedSize); + pReader.Read(block.StreamInfo.SeekDataSize); + pReader.Read(block.StreamInfo.SeekIntervalSampleNum); + ReadReference(block.StreamInfo.SampleDataRef); + if (block.TrackInfoTabRef.Offset != 0xffffffff) { + pFile.seekg(pInfoBlockRef.Ref.Offset + sizeof(BlockHeader) + + block.TrackInfoTabRef.Offset, + std::ios::beg); + ReadReferenceTab(block.TrackInfoTab); + } + if (block.ChannelInfoTabRef.Offset != 0xffffffff) { + pFile.seekg(pInfoBlockRef.Ref.Offset + sizeof(BlockHeader) + + block.ChannelInfoTabRef.Offset, + std::ios::beg); + ReadReferenceTab(block.ChannelInfoTab); + } + for (auto& it : block.ChannelInfoTab.Refs) { + pFile.seekg(pInfoBlockRef.Ref.Offset + sizeof(BlockHeader) + + block.ChannelInfoTabRef.Offset + it.Offset, + std::ios::beg); + Reference r; + ReadReference(r); + block.ChannelInfoRefs.Add(r); + } + for (size_t i = 0; i < block.ChannelInfoRefs.Size(); i++) { + size_t off = pInfoBlockRef.Ref.Offset; + off += sizeof(BlockHeader); + off += block.ChannelInfoTabRef.Offset; + off += block.ChannelInfoTab.Refs[i].Offset; + off += block.ChannelInfoRefs[i].Offset; + pFile.seekg(off, std::ios::beg); + DSP_ADPCM_Info t; /** temp */ + pReader.ReadEx(t); /** This Section gets read normally */ + pDSP_ADPCM_Info.Add(t); + } +} + +CTRFF_API void BCSTM::ReadSeekBlock(SD_Block& block) { + pReader.Read(pSeekBlock.Header.Magic); + pReader.Read(pSeekBlock.Header.Size); + if ((pSeekBlock.Header.Size % 20) != 0) { + throw std::runtime_error("BCSTM: SeekBlock Size is not 0x20 aligned!"); + } + + pSeekBlock.Data.Reserve(pSeekBlock.Header.Size + 1); + for (PD::u32 i = 0; i < pSeekBlock.Header.Size; i++) { + PD::u8 v; + pReader.Read(v); + pSeekBlock.Data.Add(v); + } +} + +CTRFF_API void BCSTM::ReadReferenceTab(ReferenceTable& tab) { + pReader.Read(tab.Count); + tab.Refs.Reserve(tab.Count + 1); + for (PD::u32 i = 0; i < tab.Count; i++) { + Reference r; + pReader.Read(r.TypeID); + pReader.Read(r.Padding); + pReader.Read(r.Offset); + tab.Refs.Add(r); + } +} + +CTRFF_API void BCSTM::ReadGotoBeginning(bool use_loop_beg) { + /** + * Go Up by 0x20 to skip header and empty section + * due to 0x20 alignment + */ + size_t off = pDataBlockRef.Ref.Offset + 0x20; + /** Shift to loop start if enabled */ + if (use_loop_beg) { + off += GetNumBlocks() * GetNumChannels() * GetLoopStart(); + // off += GetNumChannels() * pInfoBlock.StreamInfo.LoopStartFrame; + } + // block_size * channel_count * loop_start + try { + pFile.seekg(off, std::ios::beg); + } catch (const std::exception& e) { + throw std::runtime_error(e.what()); + } + if (pFile.tellg() > pHeader.FileSize) { + throw std::runtime_error("BCSTM: Seeked Out of range!"); + } +} + +CTRFF_API void BCSTM::ReadBlock(PD::u32 block, PD::u8* ref) { + if (pFile.tellg() > pHeader.FileSize || block >= GetNumBlocks()) { + throw std::runtime_error("BCSTM: Decode block Out of range!"); + } + pFile.read( + reinterpret_cast(ref), + (block == (GetNumBlocks() - 1) ? pInfoBlock.StreamInfo.LastSampleBlockSize + : GetBlockSize())); +} + +CTRFF_API void BCSTM::CleanUp() { + if (pFile.is_open()) { + try { + pFile.close(); + } catch (const std::exception& e) { + throw std::runtime_error(e.what()); + } + } + pInfoBlock.ChannelInfoRefs.Clear(); + pInfoBlock.ChannelInfoTab.Refs.Clear(); + pInfoBlock.ChannelInfoTab.Count = 0; + pInfoBlock.TrackInfoTab.Refs.Clear(); + pInfoBlock.TrackInfoTab.Count = 0; + pDSP_ADPCM_Info.Clear(); +} +} // namespace ctrff diff --git a/source/bcwav.cpp b/source/bcwav.cpp new file mode 100644 index 0000000..509877f --- /dev/null +++ b/source/bcwav.cpp @@ -0,0 +1,142 @@ +#include + +/** Using this a single time so inline it */ +inline PD::u32 Swap32(PD::u32 in) { + return (in >> 24) | ((in >> 8) & 0x0000FF00) | ((in << 8) & 0x00FF0000) | + (in << 24); +} + +namespace ctrff { +CTRFF_API void BCWAV::LoadFile(const std::string& path) { + CleanUp(); + pFile.open(path, std::ios::in | std::ios::binary); + if (!pFile.is_open()) { + throw std::runtime_error("BCWAV Error: File not found!"); + } + + pReader.Read(pHeader.Magic); + pReader.Read(pHeader.Endianness); + if (pHeader.Endianness == Big) { + pHeader.Magic = Swap32(pHeader.Magic); + } + /** Check for 'CWAV' */ + if (pHeader.Magic != 0x56415743) { + throw std::runtime_error("BCWAV Error: Invalid File!"); + } + pReader.Read(pHeader.HeaderSize); + pReader.Read(pHeader.Version); + pReader.Read(pHeader.FileSize); + pReader.Read(pHeader.NumBlocks); + pReader.Read(pHeader.Reserved); + for (PD::u16 i = 0; i < pHeader.NumBlocks; i++) { + SizedReference ref; + ReadSizedReference(ref); + if (ref.Ref.TypeID == Ref_InfoBlock) { + pInfoBlockRef = ref; + } else if (ref.Ref.TypeID == Ref_DataBlock) { + pDataBlockRef = ref; + } + } + pFile.seekg(pInfoBlockRef.Ref.Offset); + ReadInfoBlock(pInfoBlock); +} + +CTRFF_API void BCWAV::ReadReference(Reference& ref) { + pReader.Read(ref.TypeID); + pReader.Read(ref.Padding); + pReader.Read(ref.Offset); +} +CTRFF_API void BCWAV::ReadSizedReference(SizedReference& ref) { + ReadReference(ref.Ref); + pReader.Read(ref.Size); +} + +CTRFF_API void BCWAV::ReadInfoBlock(InfoBlock& block) { + pReader.Read(block.Header.Magic); + pReader.Read(block.Header.Size); + pReader.Read(block.Encoding); + pReader.Read(block.Loop); + pReader.Read(block.Padding); + pReader.Read(block.SampleRate); + pReader.Read(block.LoopStartFrame); + pReader.Read(block.LoopEndFrame); + pReader.Read(block.Reserved); + ReadReferenceTab(block.ChannelInfoTab); + for (auto& it : block.ChannelInfoTab.Refs) { + pFile.seekg(pInfoBlockRef.Ref.Offset + sizeof(BlockHeader) + it.Offset, + std::ios::beg); + Reference r; + ReadReference(r); + block.ChannelInfoRefs.Add(r); + } + for (size_t i = 0; i < block.ChannelInfoRefs.Size(); i++) { + size_t off = pInfoBlockRef.Ref.Offset; + off += sizeof(BlockHeader); + off += block.ChannelInfoTab.Refs[i].Offset; + off += block.ChannelInfoRefs[i].Offset; + pFile.seekg(off, std::ios::beg); + DSP_ADPCM_Info t; /** temp */ + pReader.ReadEx(t); /** This Section gets read normally */ + pDSP_ADPCM_Info.Add(t); + } +} + +CTRFF_API void BCWAV::ReadReferenceTab(ReferenceTable& tab) { + pReader.Read(tab.Count); + tab.Refs.Reserve(tab.Count + 1); + for (PD::u32 i = 0; i < tab.Count; i++) { + Reference r; + pReader.Read(r.TypeID); + pReader.Read(r.Padding); + pReader.Read(r.Offset); + tab.Refs.Add(r); + } +} + +CTRFF_API void BCWAV::ReadGotoBeginning(bool use_loop_beg) { + /** + * Go Up by 0x20 to skip header and empty section + * due to 0x20 alignment + */ + size_t off = pDataBlockRef.Ref.Offset + 0x20; + /** Shift to loop start if enabled */ + if (use_loop_beg) { + // off += GetNumBlocks() * GetNumChannels() * GetLoopStart(); + // off += GetNumChannels() * pInfoBlock.StreamInfo.LoopStartFrame; + } + // block_size * channel_count * loop_start + try { + pFile.seekg(off, std::ios::beg); + } catch (const std::exception& e) { + throw std::runtime_error(e.what()); + } + if (pFile.tellg() > pHeader.FileSize) { + throw std::runtime_error("BCWAV: Seeked Out of range!"); + } +} + +CTRFF_API void BCWAV::ReadBlock(PD::u32 block, PD::u8* ref) { + // if (pFile.tellg() > pHeader.FileSize || block >= GetNumBlocks()) { + // throw std::runtime_error("BCWAV: Decode block Out of range!"); + // } + // pFile.read( + // reinterpret_cast(ref), + // (block == (GetNumBlocks() - 1) ? + // pInfoBlock.StreamInfo.LastSampleBlockSize + // : GetBlockSize())); +} + +CTRFF_API void BCWAV::CleanUp() { + if (pFile.is_open()) { + try { + pFile.close(); + } catch (const std::exception& e) { + throw std::runtime_error(e.what()); + } + } + pInfoBlock.ChannelInfoRefs.Clear(); + pInfoBlock.ChannelInfoTab.Refs.Clear(); + pInfoBlock.ChannelInfoTab.Count = 0; + pDSP_ADPCM_Info.Clear(); +} +} // namespace ctrff diff --git a/source/binutil.cpp b/source/binutil.cpp new file mode 100644 index 0000000..1eed924 --- /dev/null +++ b/source/binutil.cpp @@ -0,0 +1,41 @@ +#include + +namespace ctrff { +/** Supported reads */ +template CTRFF_API void BinUtil::Read(PD::u8&); +template CTRFF_API void BinUtil::Read(PD::u16&); +template CTRFF_API void BinUtil::Read(PD::u32&); +template CTRFF_API void BinUtil::Read(PD::u64&); +/** Supported writes */ +template CTRFF_API void BinUtil::Write(const PD::u8&); +template CTRFF_API void BinUtil::Write(const PD::u16&); +template CTRFF_API void BinUtil::Write(const PD::u32&); +template CTRFF_API void BinUtil::Write(const PD::u64&); + +template +void BinUtil::Read(T& v) { + // Check if Value could be Read + static_assert(std::is_integral::value, "Cannot Read type T"); + v = 0; // Set value to 0 (most cases a windows problem) + std::vector buf(sizeof(T), 0); // declare buffer + // Read data into buffer + m_file.read(reinterpret_cast(buf.data()), sizeof(T)); + // Loop or in be reverse loop and chift the values + for (int i = 0; i < sizeof(T); i++) { + v |= static_cast(buf[m_big ? sizeof(T) - 1 - i : i]) << (8 * i); + } +} +template +void BinUtil::Write(const T& v) { + // Check if Value could Write + static_assert(std::is_integral::value, "Cannot Write type T"); + std::vector buf(sizeof(T), 0); // declare buffer + // Loop or in be reverse loop and write the values + 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] = + static_cast((v >> (8 * i)) & 0xFF); + } + // Write buffer into file + m_file.write(reinterpret_cast(buf.data()), sizeof(T)); +} +} // namespace ctrff \ No newline at end of file diff --git a/source/helper.cpp b/source/helper.cpp new file mode 100644 index 0000000..e3ad894 --- /dev/null +++ b/source/helper.cpp @@ -0,0 +1,159 @@ +#include +#include +#include + +void MakePixelRGBA(PD::u8 &r, PD::u8 &g, PD::u8 &b, PD::u8 &a, PD::u16 px) { + b = (px & 0x1f) << 3; + g = ((px >> 0x5) & 0x3f) << 2; + r = ((px >> 0xb) & 0x1f) << 3; + a = 0xff; +} + +CTRFF_API PD::u16 MakePixel565(const PD::u8 &r, const PD::u8 &g, + const PD::u8 &b) { + PD::u16 res = 0; + res |= (r & ~0x7) << 8; + res |= (g & ~0x3) << 3; + res |= (b) >> 3; + return res; +} + +CTRFF_API PD::u32 TileIndex(const int &x, const int &y, const int &w) { + return (((y >> 3) * (w >> 3) + (x >> 3)) << 6) + + ((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) | ((y & 2) << 2) | + ((x & 4) << 2) | ((y & 4) << 3)); +} + +// TODO: Fix colors +CTRFF_API void ctrff::RGB565toRGBA(std::vector &img, PD::u16 *icon, + const int &w, const int &h) { + if (img.size() != (48 * 48 * 4)) { + img.resize(48 * 48 * 4); + img.clear(); + } + for (PD::u32 y = 0; y < h; y++) { + for (PD::u32 x = 0; x < w; x++) { + auto idx = TileIndex(x, y, w); + PD::u32 pos = (y * w + x) * 4; + MakePixelRGBA(img[pos + 0], img[pos + 1], img[pos + 2], img[pos + 3], + icon[idx]); + } + } +} + +CTRFF_API void ctrff::RGBA2RGB565(PD::u16 *out, const std::vector &img, + const int &w, const int &h) { + if (img.size() != size_t(w * h * 4)) return; + std::vector px8 = img; + for (PD::u32 y = 0; y < h; y++) { + for (PD::u32 x = 0; x < w; x++) { + auto idx = TileIndex(x, y, w); + PD::u32 pos = (y * w + x) * 4; + out[idx] = MakePixel565(img[pos], img[pos + 1], img[pos + 2]); + } + } +} + +CTRFF_API std::vector ctrff::DownscaleImage( + const std::vector &img, int w, int h, int scale) { + std::vector res(((w / scale) * (h / scale)) * 4); + int samples = scale * scale; + for (int y = 0; y < h; y += scale) { + for (int x = 0; x < w; x += scale) { + PD::u32 r = 0; + PD::u32 g = 0; + PD::u32 b = 0; + PD::u32 a = 0; + for (int oy = 0; oy < scale; oy++) { + for (int ox = 0; ox < scale; ox++) { + int pos = ((y + oy) * w + (x + ox)) * 4; + r += img[pos++]; + g += img[pos++]; + b += img[pos++]; + a += img[pos++]; + } + } + int pos = ((y / scale) * (w / scale) + (x / scale)) * 4; + res[pos++] = (PD::u8)(r / samples); + res[pos++] = (PD::u8)(g / samples); + res[pos++] = (PD::u8)(b / samples); + res[pos++] = (PD::u8)(a / samples); + } + } + return res; +} + +CTRFF_API void ctrff::String2U16(PD::u16 *res, const std::string &src, + size_t max) { + /// GOT FORCED TO REPLACE std::wstring_convert by some + /// manual work as it got removed in cxx20 + /// TODO /// + /// ADD SOME ERROR API IN HERE + if (max == 0) return; + size_t len = 0; + size_t i = 0; + while (i < src.size() && len < max) { + PD::u8 c = src[i]; + + if (c < 0x80) { + // 1byte + res[len++] = c; + i++; + } else if ((c >> 5) == 0x6) { + // 2byte + if (i + 1 >= src.size()) + throw std::invalid_argument("Invalid UTF-8 sequence"); + res[len++] = ((c & 0x1F) << 6) | (src[i + 1] & 0x3F); + i += 2; + } else if ((c >> 4) == 0xE) { + // 3byte + if (i + 2 >= src.size()) + throw std::invalid_argument("Invalid UTF-8 sequence"); + res[len++] = + ((c & 0x0F) << 12) | ((src[i + 1] & 0x3F) << 6) | (src[i + 2] & 0x3F); + i += 3; + } else if ((c >> 3) == 0x1E) { + // 4byte + if (i + 3 >= src.size()) + throw std::invalid_argument("Invalid UTF-8 sequence"); + PD::u32 codepoint = ((c & 0x07) << 18) | ((src[i + 1] & 0x3F) << 12) | + ((src[i + 2] & 0x3F) << 6) | (src[i + 3] & 0x3F); + codepoint -= 0x10000; + res[len++] = 0xD800 | ((codepoint >> 10) & 0x3FF); + res[len++] = 0xDC00 | (codepoint & 0x3FF); + i += 4; + } else { + return; + } + } +} + +CTRFF_API std::string ctrff::U16toU8(PD::u16 *in, size_t max) { + /// GOT FORCED TO REPLACE std::wstring_convert by some + /// manual work as it got removed in cxx20 + if (!in || max == 0) { + return ""; + } + + std::string result; + result.reserve(max * 3); + + for (size_t i = 0; i < max; i++) { + uint16_t c = in[i]; + + if (c < 0x80) { + result.push_back(static_cast(c)); + } else if (c < 0x800) { + result.push_back(static_cast(0xC0 | (c >> 6))); + result.push_back(static_cast(0x80 | (c & 0x3F))); + } else if (c < 0x10000) { + result.push_back(static_cast(0xE0 | (c >> 12))); + result.push_back(static_cast(0x80 | ((c >> 6) & 0x3F))); + result.push_back(static_cast(0x80 | (c & 0x3F))); + } else { + continue; + } + } + + return result; +} \ No newline at end of file diff --git a/source/lz11.cpp b/source/lz11.cpp new file mode 100644 index 0000000..5b36eb6 --- /dev/null +++ b/source/lz11.cpp @@ -0,0 +1,112 @@ +#include +#include + +/// REWRITTEN CODE FROM BANNERTOOL !!!!!! + +namespace ctrff { +namespace LZ11 { +PD::u32 GetOccurenceLength(const PD::u8* new_ptr, size_t new_len, + const PD::u8* old_ptr, size_t old_len, + PD::u32& disp) { + disp = 0; + if (new_len == 0) { + return 0; + } + PD::u32 res = 0; + if (old_len > 0) { + for (size_t i = 0; i < old_len - 1; i++) { + auto ref = old_ptr + i; + size_t len = 0; + for (size_t j = 0; j < new_len; j++) { + if (*(ref + j) != (*new_ptr + j)) { + break; + } + len++; + } + if (len > res) { + res = len; + disp = old_len - i; + if (res == new_len) { + break; + } + } + } + } + return res; +} + +CTRFF_API std::vector Compress(const std::vector& in) { + if (in.size() > 0xFFFFFF) { + std::cout << "ERROR: LZ11 input is too large!" << std::endl; + return std::vector(); + } + std::stringstream s; + // SETUP HEADER // + s << static_cast(0x11); + s << static_cast(in.size() & 0xFF); + s << static_cast((in.size() >> 8) & 0xFF); + s << static_cast((in.size() >> 16) & 0xFF); + + size_t res_len = 4; // 4-byte header + PD::u8 out_buf[0x21]; // 33 bytes + out_buf[0] = 0; + size_t obl = 1; // out_buf_len + size_t buf_blocks = 0; + size_t rb = 0; + + while (rb < in.size()) { + if (buf_blocks == 8 || obl >= sizeof(out_buf) - 3) { + s.write(reinterpret_cast(out_buf), obl); + res_len += obl; + out_buf[0] = 0; + obl = 1; + buf_blocks = 0; + } + + PD::u32 disp = 0; + size_t old_len = std::min(rb, static_cast(0x1000)); + size_t len = LZ11::GetOccurenceLength( + in.data() + rb, std::min(in.size() - rb, static_cast(0x10110)), + in.data() + rb - old_len, old_len, disp); + + if (len < 3) { + out_buf[obl++] = in[rb++]; + } else { + rb += len; + out_buf[0] |= static_cast(1 << (7 - buf_blocks)); + if (len > 0x110) { + out_buf[obl++] = + 0x10 | static_cast(((len - 0x111) >> 12) & 0x0F); + out_buf[obl++] = static_cast(((len - 0x111) >> 4) & 0xFF); + out_buf[obl] = static_cast(((len - 0x111) << 4) & 0xF0); + } else if (len > 0x10) { + out_buf[obl++] = 0x00 | static_cast(((len - 0x11) >> 4) & 0x0F); + out_buf[obl] = static_cast(((len - 0x11) << 4) & 0xF0); + } else { + out_buf[obl] |= static_cast(((len - 1) << 4) & 0xF0); + } + obl++; + out_buf[obl++] = static_cast(((disp - 1) >> 8) & 0x0F); + out_buf[obl++] = static_cast((disp - 1) & 0xFF); + } + buf_blocks++; + } + + if (buf_blocks > 0) { + s.write(reinterpret_cast(out_buf), obl); + res_len += obl; + } + + if (res_len % 4 != 0) { + PD::u32 pad_len = 4 - (res_len % 4); + PD::u8 pad[4] = {0}; + s.write(reinterpret_cast(pad), pad_len); + res_len += pad_len; + } + + std::vector res(res_len); + s.read(reinterpret_cast(res.data()), res.size()); + return res; +} +} // namespace LZ11 +} // namespace ctrff \ No newline at end of file diff --git a/source/smdh.cpp b/source/smdh.cpp new file mode 100644 index 0000000..0edb7a0 --- /dev/null +++ b/source/smdh.cpp @@ -0,0 +1,127 @@ +#include +#include + +// magic +static const std::string smdh_magic = "SMDH"; + +CTRFF_API void ctrff::SMDH::Write(std::fstream &f) const { + f.write(reinterpret_cast(Magic), sizeof(Magic)); + f.write(reinterpret_cast(&Version), sizeof(Version)); + f.write(reinterpret_cast(&Reserved), sizeof(Reserved)); + for (size_t i = 0; i < 16; i++) { + f.write(reinterpret_cast(&Titles[i]), sizeof(Title)); + } + f.write(reinterpret_cast(&Settings), sizeof(Settings)); + f.write(reinterpret_cast(&Reserved1), sizeof(Reserved1)); + f.write(reinterpret_cast(&IconSmall), sizeof(IconSmall)); + f.write(reinterpret_cast(&IconLarge), sizeof(IconLarge)); +} + +CTRFF_API void ctrff::SMDH::Read(std::fstream &f) { + f.seekg(0, std::ios::end); + if (f.tellg() != SMDH_Size) { + throw std::runtime_error( + "SMDH: File size does not match the SMDH Header size!"); + } + f.seekg(0, std::ios::beg); + f.read(reinterpret_cast(Magic), sizeof(Magic)); + if (std::string(Magic) != smdh_magic) { + throw std::runtime_error("SMDH: Invalid SMDH file!"); + } + f.read(reinterpret_cast(&Version), sizeof(Version)); + f.read(reinterpret_cast(&Reserved), sizeof(Reserved)); + for (size_t i = 0; i < 16; i++) { + f.read(reinterpret_cast(&Titles[i]), sizeof(Title)); + } + f.read(reinterpret_cast(&Settings), sizeof(Settings)); + f.read(reinterpret_cast(&Reserved1), sizeof(Reserved1)); + f.read(reinterpret_cast(&IconSmall), sizeof(IconSmall)); + f.read(reinterpret_cast(&IconLarge), sizeof(IconLarge)); +} + +CTRFF_API void ctrff::SMDH::SetIcon(const std::vector &buf) { + RGBA2RGB565(IconLarge, buf, 48, 48); + auto small_icon = DownscaleImage(buf, 48, 48, 2); + RGBA2RGB565(IconSmall, small_icon, 24, 24); +} + +CTRFF_API std::vector ctrff::SMDH::GetIcon() { + std::vector res(48 * 48 * 4); + ctrff::RGB565toRGBA(res, IconLarge, 48, 48); + return res; +} + +CTRFF_API void ctrff::SMDH::SetShortTitle(const std::string &t, Language l) { + if (l == Language_All) { + for (int i = 0; i < 16; i++) { + ctrff::String2U16(Titles[i].ShortTitle, t, 0x40); + } + return; + } + ctrff::String2U16(Titles[l].ShortTitle, t, 0x40); +} + +CTRFF_API void ctrff::SMDH::SetLongTitle(const std::string &t, Language l) { + if (l == Language_All) { + for (int i = 0; i < 16; i++) { + ctrff::String2U16(Titles[i].LongTitle, t, 0x80); + } + return; + } + ctrff::String2U16(Titles[l].LongTitle, t, 0x80); +} + +CTRFF_API void ctrff::SMDH::SetAuthor(const std::string &t, Language l) { + if (l == Language_All) { + for (int i = 0; i < 16; i++) { + ctrff::String2U16(Titles[i].Author, t, 0x40); + } + return; + } + ctrff::String2U16(Titles[l].Author, t, 0x40); +} + +CTRFF_API std::string ctrff::SMDH::GetShortTitle(Language l) { + if (l == Language_All) { + return ctrff::U16toU8(Titles[0].ShortTitle, 0x40); + } + return ctrff::U16toU8(Titles[l].ShortTitle, 0x40); +} + +CTRFF_API std::string ctrff::SMDH::GetLongTitle(Language l) { + if (l == Language_All) { + return ctrff::U16toU8(Titles[0].LongTitle, 0x80); + } + return ctrff::U16toU8(Titles[l].LongTitle, 0x80); +} + +CTRFF_API std::string ctrff::SMDH::GetAuthor(Language l) { + if (l == Language_All) { + return ctrff::U16toU8(Titles[0].Author, 0x40); + } + return ctrff::U16toU8(Titles[l].Author, 0x40); +} + +CTRFF_API ctrff::SMDH ctrff::SMDH::Default() { + SMDH n3w; /** new */ + for (int i = 0; i < 4; i++) { + n3w.Magic[i] = smdh_magic[i]; + } + // Set Defaults + n3w.Settings.MatchmakerID = 0; + n3w.Settings.MatchmakerBitID = 0; + n3w.Settings.EulaVersion = 0; + n3w.Settings.OptimalBannerFrame = 0; + n3w.Settings.StreetpassID = 0; + for (size_t i = 0; i < 16; i++) { + n3w.Settings.Ratings[i] = 0; + } + n3w.Version = 0; + n3w.Reserved = 0; + n3w.Reserved1 = 0; + n3w.Settings.Flags = Flag_DEFAULT; + n3w.Settings.RegionLock = Region_FREE; + std::fill_n(n3w.IconSmall, 0x240, 0); + std::fill_n(n3w.IconLarge, 0x900, 0); + return n3w; +} \ No newline at end of file diff --git a/tool/main.cpp b/tool/main.cpp new file mode 100644 index 0000000..bb45e81 --- /dev/null +++ b/tool/main.cpp @@ -0,0 +1,502 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/** Import palladium stb image */ +#define STB_IMAGE_IMPLEMENTATION +#include +#define STB_IMAGE_WRITE_IMPLEMENTATION +#include +/** Could not use the palladium func due to only using headers */ +const std::string FormatBytes(unsigned long long bytes) { + if (bytes == 1) { + // Only one Byte + return std::format("{} Byte", bytes); + } else if (bytes < 1024) { + // less than one kilobyte + return std::format("{} Bytes", bytes); + } else if (bytes < 1048576) { + // less than one megabyte + return std::format("{:.1f} KB", (float)bytes / 1024.f); + } else if (bytes < 1073741824) { + // less than one gigabyte + return std::format("{:.1f} MB", (float)bytes / 1048576.f); + } else { + // gigabyte + return std::format("{:.1f} GB", (float)bytes / 1073741824.f); + } +} + +const std::map smdh_lang_table = { + {ctrff::SMDH::Language_Japanese, "Japanese"}, + {ctrff::SMDH::Language_English, "English"}, + {ctrff::SMDH::Language_French, "French"}, + {ctrff::SMDH::Language_German, "German"}, + {ctrff::SMDH::Language_Italian, "Italian"}, + {ctrff::SMDH::Language_Spanish, "Spanish"}, + {ctrff::SMDH::Language_Chinese_Simplified, "Chinese Simplified"}, + {ctrff::SMDH::Language_Korean, "Korean"}, + {ctrff::SMDH::Language_Dutch, "Dutch"}, + {ctrff::SMDH::Language_Portuguese, "Portuguese"}, + {ctrff::SMDH::Language_Russian, "Russian"}, + {ctrff::SMDH::Language_Chinese_Traditional, "Chinese Traditional"}, +}; + +const std::map smdh_rating_table = { + {ctrff::SMDH::Rating_CERO, "CERO"}, + {ctrff::SMDH::Rating_ESRB, "ESRB"}, + {ctrff::SMDH::Rating_USK, "USK"}, + {ctrff::SMDH::Rating_PEGI_GEN, "PEGI_GEN"}, + {ctrff::SMDH::Rating_PEGI_PTR, "PEGI_PTR"}, + {ctrff::SMDH::Rating_PEGI_BBFC, "PEGI_BBFC"}, + {ctrff::SMDH::Rating_COB, "COB"}, + {ctrff::SMDH::Rating_GRB, "GRB"}, + {ctrff::SMDH::Rating_CGSRR, "CGSRR"}, +}; + +const std::map smdh_region_table = { + {ctrff::SMDH::Region_JAPAN, "Japan"}, + {ctrff::SMDH::Region_NORTH_AMERICA, "North America"}, + {ctrff::SMDH::Region_EUROPE, "Europe"}, + {ctrff::SMDH::Region_AUSTRALIA, "Australia"}, + {ctrff::SMDH::Region_CHINA, "China"}, + {ctrff::SMDH::Region_KOREA, "Korea"}, + {ctrff::SMDH::Region_TAIWAN, "Taiwan"}, + {ctrff::SMDH::Region_FREE, "Free"}, +}; + +const std::map smdh_flag_table{ + {ctrff::SMDH::Flag_VISIBLE, "Visible"}, + {ctrff::SMDH::Flag_AUTO_BOOT, "Auto Boot"}, + {ctrff::SMDH::Flag_ALLOW_3D, "Allow 3D"}, + {ctrff::SMDH::Flag_REQUIRE_EULA, "Require EULA"}, + {ctrff::SMDH::Flag_AUTO_SAVE_ON_EXIT, "Auto Save on Exit"}, + {ctrff::SMDH::Flag_USE_EXTENDED_BANNER, "Use Extended Banner"}, + {ctrff::SMDH::Flag_RATING_REQUIED, "Rating required"}, + {ctrff::SMDH::Flag_USE_SAVE_DATA, "Use Save Data"}, + {ctrff::SMDH::Flag_RECORD_USAGE, "Record usage"}, + {ctrff::SMDH::Flag_DISABLE_SAVE_BACKUPS, "Disable Save backups"}, + {ctrff::SMDH::Flag_NEW_3DS, "New 3DS"}, +}; + +const std::map smdh_lang_stropts = { + {"", ctrff::SMDH::Language_All}, + {"jp", ctrff::SMDH::Language_Japanese}, + {"en", ctrff::SMDH::Language_English}, + {"fr", ctrff::SMDH::Language_French}, + {"de", ctrff::SMDH::Language_German}, + {"it", ctrff::SMDH::Language_Italian}, + {"es", ctrff::SMDH::Language_Spanish}, + {"cs", ctrff::SMDH::Language_Chinese_Simplified}, + {"ko", ctrff::SMDH::Language_Korean}, + {"du", ctrff::SMDH::Language_Dutch}, + {"po", ctrff::SMDH::Language_Portuguese}, + {"ru", ctrff::SMDH::Language_Russian}, + {"ct", ctrff::SMDH::Language_Chinese_Traditional}, +}; + +void MakeSMDH(const cf7::command::ArgumentList &data) { + std::string l = cf7::command::GetArg(data, "long"); + std::string s = cf7::command::GetArg(data, "short"); + std::string a = cf7::command::GetArg(data, "author"); + std::string i = cf7::command::GetArg(data, "icon"); + std::string o = cf7::command::GetArg(data, "output"); + if (l.empty() || s.empty() || a.empty() || i.empty() || o.empty()) { + cf7::PrintFancy({ + std::make_pair("Error", cf7::col(190, 0, 0)), + std::make_pair("One or more Arguments are not set!", + cf7::col(130, 0, 0)), + }); + return; + } + ctrff::SMDH smdh = ctrff::SMDH::Default(); + smdh.SetLongTitle(l); + smdh.SetShortTitle(s); + smdh.SetAuthor(a); + std::vector img; + int w, h, c; + PD::u8 *buf = stbi_load(i.c_str(), &w, &h, &c, 4); + if (buf == nullptr) { + cf7::PrintFancy({ + std::make_pair("Error", cf7::col(190, 0, 0)), + std::make_pair("Can't open icon File!", cf7::col(130, 0, 0)), + }); + return; + } + if (w != 48 || h != 48) { + cf7::PrintFancy({ + std::make_pair("Error", cf7::col(190, 0, 0)), + std::make_pair("Icon is not 48x48 pixels!", cf7::col(130, 0, 0)), + }); + return; + } + img.assign(buf, buf + (w * h * 4)); + smdh.SetIcon(img); + std::fstream f(o, std::ios::out | std::ios::binary); + smdh.Write(f); + cf7::PrintFancy({ + std::make_pair("File Generated", cf7::col(0, 190, 0)), + }); +} + +void ReadSMDH(const cf7::command::ArgumentList &data) { + ctrff::SMDH smdh; + if (cf7::command::GetArg(data, "input").empty()) { + cf7::PrintFancy({ + std::make_pair("Error", cf7::col(190, 0, 0)), + std::make_pair("Input Argument not found!", cf7::col(130, 0, 0)), + }); + return; + } + try { + smdh.Load(cf7::command::GetArg(data, "input")); + } catch (const std::exception &e) { + cf7::PrintFancy({ + std::make_pair("Error", cf7::col(190, 0, 0)), + std::make_pair(e.what(), cf7::col(130, 0, 0)), + }); + return; + } + cf7::PrintFancy({ + std::make_pair("CTRFF", cf7::col(220, 160, 0)), + std::make_pair("SMDH-Parser", cf7::col(240, 200, 0)), + }); + cf7::PrintFancy({ + std::make_pair("Language", cf7::col(220, 160, 0)), + std::make_pair("Short", cf7::col(240, 200, 0)), + std::make_pair("Long", cf7::col(255, 230, 0)), + std::make_pair("Author", cf7::col(255, 255, 0)), + }); + for (auto &e : smdh_lang_table) { + cf7::PrintFancy({ + std::make_pair(" " + e.second, cf7::col(220, 160, 0)), + std::make_pair(smdh.GetShortTitle(e.first), cf7::col(240, 200, 0)), + std::make_pair(smdh.GetLongTitle(e.first), cf7::col(255, 230, 0)), + std::make_pair(smdh.GetAuthor(e.first), cf7::col(255, 255, 0)), + }); + } + cf7::PrintFancy({ + std::make_pair("Version", cf7::col(220, 160, 0)), + std::make_pair(std::to_string(smdh.Version), cf7::col(240, 200, 0)), + }); + cf7::PrintFancy({ + std::make_pair("Ratings", cf7::col(220, 160, 0)), + }); + cf7::PrintFancy({ + std::make_pair("Flags", cf7::col(220, 160, 0)), + }); + for (auto &e : smdh_flag_table) { + cf7::PrintFancy({ + std::make_pair(" " + e.second, cf7::col(220, 160, 0)), + std::make_pair( + std::string((smdh.Settings.Flags & e.first) ? "true" : "false"), + (smdh.Settings.Flags & e.first) ? cf7::col(0, 190, 0) + : cf7::col(190, 0, 0)), + }); + } + if (smdh.Settings.RegionLock == ctrff::SMDH::Region_FREE) { + cf7::PrintFancy({ + std::make_pair("Region", cf7::col(220, 160, 0)), + std::make_pair("Free", cf7::col(240, 200, 0)), + }); + } else { + for (auto &e : smdh_region_table) { + cf7::PrintFancy({ + std::make_pair("Regions", cf7::col(220, 160, 0)), + }); + cf7::PrintFancy({ + std::make_pair(e.second, cf7::col(220, 160, 0)), + std::make_pair( + std::string(smdh.Settings.RegionLock & e.first ? "true" + : "false"), + smdh.Settings.RegionLock & e.first ? cf7::col(0, 190, 0) + : cf7::col(190, 0, 0)), + }); + } + } + cf7::PrintFancy({ + std::make_pair("MatchmakerID", cf7::col(220, 160, 0)), + std::make_pair(std::to_string(smdh.Settings.MatchmakerID), + cf7::col(240, 200, 0)), + }); + std::string icon_path = cf7::command::GetArg(data, "extract-icon"); + if (!icon_path.empty()) { + auto icon = smdh.GetIcon(); + stbi_write_png(icon_path.c_str(), 48, 48, 4, icon.data(), 48 * 4); + /* if (res) { + // Error + } else {*/ + cf7::PrintFancy({ + std::make_pair("Export", cf7::col(0, 190, 0)), + std::make_pair(icon_path, cf7::col(0, 130, 0)), + std::make_pair("Success", cf7::col(0, 80, 0)), + }); + // } + } +} + +void Read3DSX(const cf7::command::ArgumentList &data) { + ctrff::_3dsx _3dsx; + if (cf7::command::GetArg(data, "input").empty()) { + cf7::PrintFancy({ + std::make_pair("Error", cf7::col(190, 0, 0)), + std::make_pair("Input Argument not found!", cf7::col(130, 0, 0)), + }); + return; + } + /*if (!*/ _3dsx.Load(cf7::command::GetArg(data, "input")); /*) { + cf7::PrintFancy({ + std::make_pair("Error", cf7::col(190, 0, 0)), + std::make_pair("Could not load 3dsx!", cf7::col(130, 0, 0)), + }); + return; + }*/ + if (!_3dsx.HasMeta()) { + cf7::PrintFancy({ + std::make_pair("Error", cf7::col(190, 0, 0)), + std::make_pair("3dsx has no meta!", cf7::col(130, 0, 0)), + }); + return; + } + ctrff::SMDH smdh = _3dsx.Meta; + cf7::PrintFancy({ + std::make_pair("CTRFF", cf7::col(220, 160, 0)), + std::make_pair("SMDH-Parser", cf7::col(240, 200, 0)), + }); + cf7::PrintFancy({ + std::make_pair("Language", cf7::col(220, 160, 0)), + std::make_pair("Short", cf7::col(240, 200, 0)), + std::make_pair("Long", cf7::col(255, 230, 0)), + std::make_pair("Author", cf7::col(255, 255, 0)), + }); + for (auto &e : smdh_lang_table) { + cf7::PrintFancy({ + std::make_pair(" " + e.second, cf7::col(220, 160, 0)), + std::make_pair(smdh.GetShortTitle(e.first), cf7::col(240, 200, 0)), + std::make_pair(smdh.GetLongTitle(e.first), cf7::col(255, 230, 0)), + std::make_pair(smdh.GetAuthor(e.first), cf7::col(255, 255, 0)), + }); + } + cf7::PrintFancy({ + std::make_pair("Version", cf7::col(220, 160, 0)), + std::make_pair(std::to_string(smdh.Version), cf7::col(240, 200, 0)), + }); + cf7::PrintFancy({ + std::make_pair("Ratings", cf7::col(220, 160, 0)), + }); + cf7::PrintFancy({ + std::make_pair("Flags", cf7::col(220, 160, 0)), + }); + for (auto &e : smdh_flag_table) { + cf7::PrintFancy({ + std::make_pair(" " + e.second, cf7::col(220, 160, 0)), + std::make_pair( + std::string((smdh.Settings.Flags & e.first) ? "true" : "false"), + (smdh.Settings.Flags & e.first) ? cf7::col(0, 190, 0) + : cf7::col(190, 0, 0)), + }); + } + if (smdh.Settings.RegionLock == ctrff::SMDH::Region_FREE) { + cf7::PrintFancy({ + std::make_pair("Region", cf7::col(220, 160, 0)), + std::make_pair("Free", cf7::col(240, 200, 0)), + }); + } else { + for (auto &e : smdh_region_table) { + cf7::PrintFancy({ + std::make_pair("Regions", cf7::col(220, 160, 0)), + }); + cf7::PrintFancy({ + std::make_pair(e.second, cf7::col(220, 160, 0)), + std::make_pair( + std::string(smdh.Settings.RegionLock & e.first ? "true" + : "false"), + smdh.Settings.RegionLock & e.first ? cf7::col(0, 190, 0) + : cf7::col(190, 0, 0)), + }); + } + } + cf7::PrintFancy({ + std::make_pair("MatchmakerID", cf7::col(220, 160, 0)), + std::make_pair(std::to_string(smdh.Settings.MatchmakerID), + cf7::col(240, 200, 0)), + }); + std::string icon_path = cf7::command::GetArg(data, "extract-icon"); + if (!icon_path.empty()) { + auto icon = smdh.GetIcon(); + stbi_write_png(icon_path.c_str(), 48, 48, 4, icon.data(), 48 * 4); + /* if (res) { + // Error + } else {*/ + cf7::PrintFancy({ + std::make_pair("Export", cf7::col(0, 190, 0)), + std::make_pair(icon_path, cf7::col(0, 130, 0)), + std::make_pair("Success", cf7::col(0, 80, 0)), + }); + // } + } +} + +void Hex(const cf7::command::ArgumentList &data) { + if (cf7::command::GetArg(data, "input").empty()) { + cf7::PrintFancy({ + std::make_pair("Error", cf7::col(190, 0, 0)), + std::make_pair("Input Argument not found!", cf7::col(130, 0, 0)), + }); + return; + } + std::ifstream fr(data[0].second, std::ios::binary); + if (!fr.is_open()) { + cf7::PrintFancy({ + std::make_pair("Error", cf7::col(190, 0, 0)), + std::make_pair("Failed to open Input File!", cf7::col(130, 0, 0)), + }); + return; + } + std::vector buf(std::istreambuf_iterator(fr), {}); + fr.close(); + cf7::PrintFancy({ + std::make_pair("CTRFF HEXDUMP", cf7::col(255, 165, 0)), + std::make_pair(data[0].second, cf7::col(255, 210, 0)), + std::make_pair(FormatBytes(buf.size()), cf7::col(255, 255, 0)), + }); + std::cout << "+----------+-------------------------------------------------+-" + "-----------------+" + << std::endl; + std::cout << "| Adress | 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F | " + "ASCII |" + << std::endl; + std::cout << "+----------+-------------------------------------------------+-" + "-----------------+" + << std::endl; + std::cout << "| " << std::hex << std::setw(8) << std::setfill('0') + << (unsigned int)0 << " | "; + std::vector ascii; + int lidx = 0; + for (size_t i = 0; i < buf.size(); i++) { + lidx++; + ascii.push_back((char)buf[i]); + std::cout << std::hex << std::setw(2) << std::setfill('0') << std::uppercase + << (int)buf[i] << " "; + if (((i + 1) % 0x10) == 0 && i > 14) { + std::cout << "| "; + for (auto &it : ascii) + std::cout << std::dec + << (((int)it >= 32) && ((int)it <= 126) ? it : '.'); + ascii.clear(); + std::cout << " |" << std::endl; + std::cout << "| " << std::hex << std::setw(8) << std::setfill('0') + << (unsigned int)i + 1 << " | "; + lidx = 0; + } + } + if (lidx < 16) { + for (int i = lidx; i < 16; i++) { + ascii.push_back('X'); + std::cout << "XX "; + if (i == 15) { + std::cout << "| "; + for (auto &it : ascii) + std::cout << std::dec + << (((int)it >= 32) && ((int)it <= 126) ? it : '.'); + ascii.clear(); + std::cout << " |" << std::endl; + } + } + std::cout + << "+----------+-------------------------------------------------+-" + "-----------------+" + << std::endl; + } +} + +void LZ11Compress(const cf7::command::ArgumentList &data) { + std::string i = cf7::command::GetArg(data, "input"); + std::string o = cf7::command::GetArg(data, "output"); + std::fstream in(i, std::ios::in | std::ios::binary); + in.seekg(0, std::ios::end); + size_t s = in.tellg(); + in.seekg(0, std::ios::beg); + std::vector buf(s); + in.read(reinterpret_cast(buf.data()), s); + in.close(); + cf7::PrintFancy({ + std::make_pair("Input", cf7::col(255, 165, 0)), + std::make_pair(i, cf7::col(255, 210, 0)), + std::make_pair(FormatBytes(buf.size()), cf7::col(255, 255, 0)), + }); + auto res = ctrff::LZ11::Compress(buf); + cf7::PrintFancy({ + std::make_pair("Output", cf7::col(255, 165, 0)), + std::make_pair(o, cf7::col(255, 210, 0)), + std::make_pair(FormatBytes(res.size()), cf7::col(255, 255, 0)), + }); + std::fstream out(o, std::ios::out | std::ios::binary); + out.write(reinterpret_cast(res.data()), res.size()); + out.close(); +} + +int main(int argc, char *argv[]) { + cf7::fancy_print = true; + cf7::colors_supported = true; + cf7::arg_mgr mgr(argc, argv); + mgr.SetAppInfo("ctrff", "1.0.0"); + auto makesmdh_cmd = cf7::command("makesmdh", "Create a SMDH File"); + makesmdh_cmd.AddSubEntry( + cf7::command::sub("i", "icon", "Icon file path (48x48)", true)); + makesmdh_cmd.AddSubEntry( + cf7::command::sub("o", "output", "Output smdh path", true)); + for (auto &it : smdh_lang_stropts) { + if (it.first.empty()) { + makesmdh_cmd.AddSubEntry(cf7::command::sub( + "s", "short", "Short Title (All Languages)", false)); + makesmdh_cmd.AddSubEntry( + cf7::command::sub("l", "long", "Long Title (All Languages)", false)); + makesmdh_cmd.AddSubEntry( + cf7::command::sub("a", "author", "Author (All Languages)", false)); + } else { + makesmdh_cmd.AddSubEntry(cf7::command::sub( + "s-" + it.first, "short-" + it.first, + "Short Title " + smdh_lang_table.at(it.second), false)); + makesmdh_cmd.AddSubEntry(cf7::command::sub( + "l-" + it.first, "long-" + it.first, + "Long Title " + smdh_lang_table.at(it.second), false)); + makesmdh_cmd.AddSubEntry( + cf7::command::sub("a-" + it.first, "author-" + it.first, + "Author " + smdh_lang_table.at(it.second), false)); + } + } + makesmdh_cmd.SetFunction(MakeSMDH); + mgr.AddCommand(makesmdh_cmd); + mgr.AddCommand( + cf7::command("readsmdh", "Reads a smdh file and can extract icon") + .AddSubEntry( + cf7::command::sub("i", "input", "Input smdh path!", true)) + .AddSubEntry(cf7::command::sub("e", "extract-icon", + "Path to Extract Icon to", false)) + .SetFunction(ReadSMDH)); + mgr.AddCommand(cf7::command("read3dsx", "Read Data of a 3dsx file") + .AddSubEntry(cf7::command::sub("i", "input", + "Input 3dsx path!", true)) + .AddSubEntry(cf7::command::sub("e", "extract-icon", + "Output icon path!", false)) + .SetFunction(Read3DSX)); + mgr.AddCommand( + cf7::command("lz11", "Creates a LZ11 Compressed File") + .AddSubEntry(cf7::command::sub("i", "input", "Input file path", true)) + .AddSubEntry( + cf7::command::sub("o", "output", "Output file path", true)) + .SetFunction(LZ11Compress)); + mgr.AddCommand( + cf7::command("hex", "Show Hex view of a File") + .AddSubEntry(cf7::command::sub("i", "input", "Input File path", true)) + .SetFunction(Hex)); + mgr.Execute(); + return 0; +} \ No newline at end of file diff --git a/tool/test.cpp b/tool/test.cpp new file mode 100644 index 0000000..221fe43 --- /dev/null +++ b/tool/test.cpp @@ -0,0 +1,48 @@ +#include +#include + +template +void Result(const std::string& name, T a, T b) { + std::cout << "Test: " << typeid(a).name() << " > "; + std::cout << "0x" << std::hex << std::setw(sizeof(a) * 2) << std::setfill('0') + << a; + std::cout << std::dec << " - "; + std::cout << "0x" << std::hex << std::setw(sizeof(a) * 2) << std::setfill('0') + << b; + std::cout << std::dec << std::endl; + std::cout << "Test " << name << " " << (a == b ? "passed" : "failed") << "!" + << std::endl; +} + +void BinTest(bool be) { + std::fstream s("test.bin", std::ios::out | std::ios::binary); + PD::u8 t8 = 0xdf; + PD::u16 t16 = 0x4564; + PD::u32 t32 = 0x58464743; + PD::u64 t64 = 1234567890123456789ULL; + ctrff::BinUtil u(s, be); + u.Write(t8); + u.Write(t16); + u.Write(t32); + u.Write(t64); + s.close(); + PD::u8 r8 = 0; + PD::u16 r16 = 0; + PD::u32 r32 = 0; + PD::u64 r64 = 0; + s.open("test.bin", std::ios::in | std::ios::binary); + u.Read(r8); + u.Read(r16); + u.Read(r32); + u.Read(r64); + Result("u8 " + std::string(be ? "big" : "little"), r8, t8); + Result("u16 " + std::string(be ? "big" : "little"), r16, t16); + Result("u32 " + std::string(be ? "big" : "little"), r32, t32); + Result("u64 " + std::string(be ? "big" : "little"), r64, t64); +} + +int main() { + BinTest(false); + BinTest(true); + return 0; +} \ No newline at end of file diff --git a/vendor/cli-fancy b/vendor/cli-fancy new file mode 160000 index 0000000..fa035da --- /dev/null +++ b/vendor/cli-fancy @@ -0,0 +1 @@ +Subproject commit fa035daae1074a5ce808fdb746de00f3727a49b0 diff --git a/vendor/palladium b/vendor/palladium new file mode 160000 index 0000000..f75f706 --- /dev/null +++ b/vendor/palladium @@ -0,0 +1 @@ +Subproject commit f75f7067ffe44ffafc852691b1bb56867842bb6f diff --git a/vendor/stb/stb_image_write.h b/vendor/stb/stb_image_write.h new file mode 100644 index 0000000..023d71e --- /dev/null +++ b/vendor/stb/stb_image_write.h @@ -0,0 +1,1724 @@ +/* stb_image_write - v1.16 - public domain - http://nothings.org/stb + writes out PNG/BMP/TGA/JPEG/HDR images to C stdio - Sean Barrett 2010-2015 + no warranty implied; use at your own risk + + Before #including, + + #define STB_IMAGE_WRITE_IMPLEMENTATION + + in the file that you want to have the implementation. + + Will probably not work correctly with strict-aliasing optimizations. + +ABOUT: + + This header file is a library for writing images to C stdio or a callback. + + The PNG output is not optimal; it is 20-50% larger than the file + written by a decent optimizing implementation; though providing a custom + zlib compress function (see STBIW_ZLIB_COMPRESS) can mitigate that. + This library is designed for source code compactness and simplicity, + not optimal image file size or run-time performance. + +BUILDING: + + You can #define STBIW_ASSERT(x) before the #include to avoid using assert.h. + You can #define STBIW_MALLOC(), STBIW_REALLOC(), and STBIW_FREE() to replace + malloc,realloc,free. + You can #define STBIW_MEMMOVE() to replace memmove() + You can #define STBIW_ZLIB_COMPRESS to use a custom zlib-style compress function + for PNG compression (instead of the builtin one), it must have the following signature: + unsigned char * my_compress(unsigned char *data, int data_len, int *out_len, int quality); + The returned data will be freed with STBIW_FREE() (free() by default), + so it must be heap allocated with STBIW_MALLOC() (malloc() by default), + +UNICODE: + + If compiling for Windows and you wish to use Unicode filenames, compile + with + #define STBIW_WINDOWS_UTF8 + and pass utf8-encoded filenames. Call stbiw_convert_wchar_to_utf8 to convert + Windows wchar_t filenames to utf8. + +USAGE: + + There are five functions, one for each image file format: + + int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes); + int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data); + int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data); + int stbi_write_jpg(char const *filename, int w, int h, int comp, const void *data, int quality); + int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data); + + void stbi_flip_vertically_on_write(int flag); // flag is non-zero to flip data vertically + + There are also five equivalent functions that use an arbitrary write function. You are + expected to open/close your file-equivalent before and after calling these: + + int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes); + int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); + int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); + int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data); + int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality); + + where the callback is: + void stbi_write_func(void *context, void *data, int size); + + You can configure it with these global variables: + int stbi_write_tga_with_rle; // defaults to true; set to 0 to disable RLE + int stbi_write_png_compression_level; // defaults to 8; set to higher for more compression + int stbi_write_force_png_filter; // defaults to -1; set to 0..5 to force a filter mode + + + You can define STBI_WRITE_NO_STDIO to disable the file variant of these + functions, so the library will not use stdio.h at all. However, this will + also disable HDR writing, because it requires stdio for formatted output. + + Each function returns 0 on failure and non-0 on success. + + The functions create an image file defined by the parameters. The image + is a rectangle of pixels stored from left-to-right, top-to-bottom. + Each pixel contains 'comp' channels of data stored interleaved with 8-bits + per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is + monochrome color.) The rectangle is 'w' pixels wide and 'h' pixels tall. + The *data pointer points to the first byte of the top-left-most pixel. + For PNG, "stride_in_bytes" is the distance in bytes from the first byte of + a row of pixels to the first byte of the next row of pixels. + + PNG creates output files with the same number of components as the input. + The BMP format expands Y to RGB in the file format and does not + output alpha. + + PNG supports writing rectangles of data even when the bytes storing rows of + data are not consecutive in memory (e.g. sub-rectangles of a larger image), + by supplying the stride between the beginning of adjacent rows. The other + formats do not. (Thus you cannot write a native-format BMP through the BMP + writer, both because it is in BGR order and because it may have padding + at the end of the line.) + + PNG allows you to set the deflate compression level by setting the global + variable 'stbi_write_png_compression_level' (it defaults to 8). + + HDR expects linear float data. Since the format is always 32-bit rgb(e) + data, alpha (if provided) is discarded, and for monochrome data it is + replicated across all three channels. + + TGA supports RLE or non-RLE compressed data. To use non-RLE-compressed + data, set the global variable 'stbi_write_tga_with_rle' to 0. + + JPEG does ignore alpha channels in input data; quality is between 1 and 100. + Higher quality looks better but results in a bigger image. + JPEG baseline (no JPEG progressive). + +CREDITS: + + + Sean Barrett - PNG/BMP/TGA + Baldur Karlsson - HDR + Jean-Sebastien Guay - TGA monochrome + Tim Kelsey - misc enhancements + Alan Hickman - TGA RLE + Emmanuel Julien - initial file IO callback implementation + Jon Olick - original jo_jpeg.cpp code + Daniel Gibson - integrate JPEG, allow external zlib + Aarni Koskela - allow choosing PNG filter + + bugfixes: + github:Chribba + Guillaume Chereau + github:jry2 + github:romigrou + Sergio Gonzalez + Jonas Karlsson + Filip Wasil + Thatcher Ulrich + github:poppolopoppo + Patrick Boettcher + github:xeekworx + Cap Petschulat + Simon Rodriguez + Ivan Tikhonov + github:ignotion + Adam Schackart + Andrew Kensler + +LICENSE + + See end of file for license information. + +*/ + +#ifndef INCLUDE_STB_IMAGE_WRITE_H +#define INCLUDE_STB_IMAGE_WRITE_H + +#include + +// if STB_IMAGE_WRITE_STATIC causes problems, try defining STBIWDEF to 'inline' or 'static inline' +#ifndef STBIWDEF +#ifdef STB_IMAGE_WRITE_STATIC +#define STBIWDEF static +#else +#ifdef __cplusplus +#define STBIWDEF extern "C" +#else +#define STBIWDEF extern +#endif +#endif +#endif + +#ifndef STB_IMAGE_WRITE_STATIC // C++ forbids static forward declarations +STBIWDEF int stbi_write_tga_with_rle; +STBIWDEF int stbi_write_png_compression_level; +STBIWDEF int stbi_write_force_png_filter; +#endif + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes); +STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data); +STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality); + +#ifdef STBIW_WINDOWS_UTF8 +STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif +#endif + +typedef void stbi_write_func(void *context, void *data, int size); + +STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes); +STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data); +STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality); + +STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean); + +#endif//INCLUDE_STB_IMAGE_WRITE_H + +#ifdef STB_IMAGE_WRITE_IMPLEMENTATION + +#ifdef _WIN32 + #ifndef _CRT_SECURE_NO_WARNINGS + #define _CRT_SECURE_NO_WARNINGS + #endif + #ifndef _CRT_NONSTDC_NO_DEPRECATE + #define _CRT_NONSTDC_NO_DEPRECATE + #endif +#endif + +#ifndef STBI_WRITE_NO_STDIO +#include +#endif // STBI_WRITE_NO_STDIO + +#include +#include +#include +#include + +#if defined(STBIW_MALLOC) && defined(STBIW_FREE) && (defined(STBIW_REALLOC) || defined(STBIW_REALLOC_SIZED)) +// ok +#elif !defined(STBIW_MALLOC) && !defined(STBIW_FREE) && !defined(STBIW_REALLOC) && !defined(STBIW_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBIW_MALLOC, STBIW_FREE, and STBIW_REALLOC (or STBIW_REALLOC_SIZED)." +#endif + +#ifndef STBIW_MALLOC +#define STBIW_MALLOC(sz) malloc(sz) +#define STBIW_REALLOC(p,newsz) realloc(p,newsz) +#define STBIW_FREE(p) free(p) +#endif + +#ifndef STBIW_REALLOC_SIZED +#define STBIW_REALLOC_SIZED(p,oldsz,newsz) STBIW_REALLOC(p,newsz) +#endif + + +#ifndef STBIW_MEMMOVE +#define STBIW_MEMMOVE(a,b,sz) memmove(a,b,sz) +#endif + + +#ifndef STBIW_ASSERT +#include +#define STBIW_ASSERT(x) assert(x) +#endif + +#define STBIW_UCHAR(x) (unsigned char) ((x) & 0xff) + +#ifdef STB_IMAGE_WRITE_STATIC +static int stbi_write_png_compression_level = 8; +static int stbi_write_tga_with_rle = 1; +static int stbi_write_force_png_filter = -1; +#else +int stbi_write_png_compression_level = 8; +int stbi_write_tga_with_rle = 1; +int stbi_write_force_png_filter = -1; +#endif + +static int stbi__flip_vertically_on_write = 0; + +STBIWDEF void stbi_flip_vertically_on_write(int flag) +{ + stbi__flip_vertically_on_write = flag; +} + +typedef struct +{ + stbi_write_func *func; + void *context; + unsigned char buffer[64]; + int buf_used; +} stbi__write_context; + +// initialize a callback-based context +static void stbi__start_write_callbacks(stbi__write_context *s, stbi_write_func *c, void *context) +{ + s->func = c; + s->context = context; +} + +#ifndef STBI_WRITE_NO_STDIO + +static void stbi__stdio_write(void *context, void *data, int size) +{ + fwrite(data,1,size,(FILE*) context); +} + +#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8) +#ifdef __cplusplus +#define STBIW_EXTERN extern "C" +#else +#define STBIW_EXTERN extern +#endif +STBIW_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +STBIW_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); + +STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbiw__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) + return 0; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + +static int stbi__start_write_file(stbi__write_context *s, const char *filename) +{ + FILE *f = stbiw__fopen(filename, "wb"); + stbi__start_write_callbacks(s, stbi__stdio_write, (void *) f); + return f != NULL; +} + +static void stbi__end_write_file(stbi__write_context *s) +{ + fclose((FILE *)s->context); +} + +#endif // !STBI_WRITE_NO_STDIO + +typedef unsigned int stbiw_uint32; +typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1]; + +static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_list v) +{ + while (*fmt) { + switch (*fmt++) { + case ' ': break; + case '1': { unsigned char x = STBIW_UCHAR(va_arg(v, int)); + s->func(s->context,&x,1); + break; } + case '2': { int x = va_arg(v,int); + unsigned char b[2]; + b[0] = STBIW_UCHAR(x); + b[1] = STBIW_UCHAR(x>>8); + s->func(s->context,b,2); + break; } + case '4': { stbiw_uint32 x = va_arg(v,int); + unsigned char b[4]; + b[0]=STBIW_UCHAR(x); + b[1]=STBIW_UCHAR(x>>8); + b[2]=STBIW_UCHAR(x>>16); + b[3]=STBIW_UCHAR(x>>24); + s->func(s->context,b,4); + break; } + default: + STBIW_ASSERT(0); + return; + } + } +} + +static void stbiw__writef(stbi__write_context *s, const char *fmt, ...) +{ + va_list v; + va_start(v, fmt); + stbiw__writefv(s, fmt, v); + va_end(v); +} + +static void stbiw__write_flush(stbi__write_context *s) +{ + if (s->buf_used) { + s->func(s->context, &s->buffer, s->buf_used); + s->buf_used = 0; + } +} + +static void stbiw__putc(stbi__write_context *s, unsigned char c) +{ + s->func(s->context, &c, 1); +} + +static void stbiw__write1(stbi__write_context *s, unsigned char a) +{ + if ((size_t)s->buf_used + 1 > sizeof(s->buffer)) + stbiw__write_flush(s); + s->buffer[s->buf_used++] = a; +} + +static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char b, unsigned char c) +{ + int n; + if ((size_t)s->buf_used + 3 > sizeof(s->buffer)) + stbiw__write_flush(s); + n = s->buf_used; + s->buf_used = n+3; + s->buffer[n+0] = a; + s->buffer[n+1] = b; + s->buffer[n+2] = c; +} + +static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d) +{ + unsigned char bg[3] = { 255, 0, 255}, px[3]; + int k; + + if (write_alpha < 0) + stbiw__write1(s, d[comp - 1]); + + switch (comp) { + case 2: // 2 pixels = mono + alpha, alpha is written separately, so same as 1-channel case + case 1: + if (expand_mono) + stbiw__write3(s, d[0], d[0], d[0]); // monochrome bmp + else + stbiw__write1(s, d[0]); // monochrome TGA + break; + case 4: + if (!write_alpha) { + // composite against pink background + for (k = 0; k < 3; ++k) + px[k] = bg[k] + ((d[k] - bg[k]) * d[3]) / 255; + stbiw__write3(s, px[1 - rgb_dir], px[1], px[1 + rgb_dir]); + break; + } + /* FALLTHROUGH */ + case 3: + stbiw__write3(s, d[1 - rgb_dir], d[1], d[1 + rgb_dir]); + break; + } + if (write_alpha > 0) + stbiw__write1(s, d[comp - 1]); +} + +static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad, int expand_mono) +{ + stbiw_uint32 zero = 0; + int i,j, j_end; + + if (y <= 0) + return; + + if (stbi__flip_vertically_on_write) + vdir *= -1; + + if (vdir < 0) { + j_end = -1; j = y-1; + } else { + j_end = y; j = 0; + } + + for (; j != j_end; j += vdir) { + for (i=0; i < x; ++i) { + unsigned char *d = (unsigned char *) data + (j*x+i)*comp; + stbiw__write_pixel(s, rgb_dir, comp, write_alpha, expand_mono, d); + } + stbiw__write_flush(s); + s->func(s->context, &zero, scanline_pad); + } +} + +static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, int expand_mono, void *data, int alpha, int pad, const char *fmt, ...) +{ + if (y < 0 || x < 0) { + return 0; + } else { + va_list v; + va_start(v, fmt); + stbiw__writefv(s, fmt, v); + va_end(v); + stbiw__write_pixels(s,rgb_dir,vdir,x,y,comp,data,alpha,pad, expand_mono); + return 1; + } +} + +static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data) +{ + if (comp != 4) { + // write RGB bitmap + int pad = (-x*3) & 3; + return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *) data,0,pad, + "11 4 22 4" "4 44 22 444444", + 'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40, // file header + 40, x,y, 1,24, 0,0,0,0,0,0); // bitmap header + } else { + // RGBA bitmaps need a v4 header + // use BI_BITFIELDS mode with 32bpp and alpha mask + // (straight BI_RGB with alpha mask doesn't work in most readers) + return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *)data,1,0, + "11 4 22 4" "4 44 22 444444 4444 4 444 444 444 444", + 'B', 'M', 14+108+x*y*4, 0, 0, 14+108, // file header + 108, x,y, 1,32, 3,0,0,0,0,0, 0xff0000,0xff00,0xff,0xff000000u, 0, 0,0,0, 0,0,0, 0,0,0, 0,0,0); // bitmap V4 header + } +} + +STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_bmp_core(&s, x, y, comp, data); +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_bmp_core(&s, x, y, comp, data); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif //!STBI_WRITE_NO_STDIO + +static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, void *data) +{ + int has_alpha = (comp == 2 || comp == 4); + int colorbytes = has_alpha ? comp-1 : comp; + int format = colorbytes < 2 ? 3 : 2; // 3 color channels (RGB/RGBA) = 2, 1 color channel (Y/YA) = 3 + + if (y < 0 || x < 0) + return 0; + + if (!stbi_write_tga_with_rle) { + return stbiw__outfile(s, -1, -1, x, y, comp, 0, (void *) data, has_alpha, 0, + "111 221 2222 11", 0, 0, format, 0, 0, 0, 0, 0, x, y, (colorbytes + has_alpha) * 8, has_alpha * 8); + } else { + int i,j,k; + int jend, jdir; + + stbiw__writef(s, "111 221 2222 11", 0,0,format+8, 0,0,0, 0,0,x,y, (colorbytes + has_alpha) * 8, has_alpha * 8); + + if (stbi__flip_vertically_on_write) { + j = 0; + jend = y; + jdir = 1; + } else { + j = y-1; + jend = -1; + jdir = -1; + } + for (; j != jend; j += jdir) { + unsigned char *row = (unsigned char *) data + j * x * comp; + int len; + + for (i = 0; i < x; i += len) { + unsigned char *begin = row + i * comp; + int diff = 1; + len = 1; + + if (i < x - 1) { + ++len; + diff = memcmp(begin, row + (i + 1) * comp, comp); + if (diff) { + const unsigned char *prev = begin; + for (k = i + 2; k < x && len < 128; ++k) { + if (memcmp(prev, row + k * comp, comp)) { + prev += comp; + ++len; + } else { + --len; + break; + } + } + } else { + for (k = i + 2; k < x && len < 128; ++k) { + if (!memcmp(begin, row + k * comp, comp)) { + ++len; + } else { + break; + } + } + } + } + + if (diff) { + unsigned char header = STBIW_UCHAR(len - 1); + stbiw__write1(s, header); + for (k = 0; k < len; ++k) { + stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin + k * comp); + } + } else { + unsigned char header = STBIW_UCHAR(len - 129); + stbiw__write1(s, header); + stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin); + } + } + } + stbiw__write_flush(s); + } + return 1; +} + +STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_tga_core(&s, x, y, comp, (void *) data); +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_tga_core(&s, x, y, comp, (void *) data); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR writer +// by Baldur Karlsson + +#define stbiw__max(a, b) ((a) > (b) ? (a) : (b)) + +#ifndef STBI_WRITE_NO_STDIO + +static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear) +{ + int exponent; + float maxcomp = stbiw__max(linear[0], stbiw__max(linear[1], linear[2])); + + if (maxcomp < 1e-32f) { + rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0; + } else { + float normalize = (float) frexp(maxcomp, &exponent) * 256.0f/maxcomp; + + rgbe[0] = (unsigned char)(linear[0] * normalize); + rgbe[1] = (unsigned char)(linear[1] * normalize); + rgbe[2] = (unsigned char)(linear[2] * normalize); + rgbe[3] = (unsigned char)(exponent + 128); + } +} + +static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte) +{ + unsigned char lengthbyte = STBIW_UCHAR(length+128); + STBIW_ASSERT(length+128 <= 255); + s->func(s->context, &lengthbyte, 1); + s->func(s->context, &databyte, 1); +} + +static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data) +{ + unsigned char lengthbyte = STBIW_UCHAR(length); + STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code + s->func(s->context, &lengthbyte, 1); + s->func(s->context, data, length); +} + +static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp, unsigned char *scratch, float *scanline) +{ + unsigned char scanlineheader[4] = { 2, 2, 0, 0 }; + unsigned char rgbe[4]; + float linear[3]; + int x; + + scanlineheader[2] = (width&0xff00)>>8; + scanlineheader[3] = (width&0x00ff); + + /* skip RLE for images too small or large */ + if (width < 8 || width >= 32768) { + for (x=0; x < width; x++) { + switch (ncomp) { + case 4: /* fallthrough */ + case 3: linear[2] = scanline[x*ncomp + 2]; + linear[1] = scanline[x*ncomp + 1]; + linear[0] = scanline[x*ncomp + 0]; + break; + default: + linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0]; + break; + } + stbiw__linear_to_rgbe(rgbe, linear); + s->func(s->context, rgbe, 4); + } + } else { + int c,r; + /* encode into scratch buffer */ + for (x=0; x < width; x++) { + switch(ncomp) { + case 4: /* fallthrough */ + case 3: linear[2] = scanline[x*ncomp + 2]; + linear[1] = scanline[x*ncomp + 1]; + linear[0] = scanline[x*ncomp + 0]; + break; + default: + linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0]; + break; + } + stbiw__linear_to_rgbe(rgbe, linear); + scratch[x + width*0] = rgbe[0]; + scratch[x + width*1] = rgbe[1]; + scratch[x + width*2] = rgbe[2]; + scratch[x + width*3] = rgbe[3]; + } + + s->func(s->context, scanlineheader, 4); + + /* RLE each component separately */ + for (c=0; c < 4; c++) { + unsigned char *comp = &scratch[width*c]; + + x = 0; + while (x < width) { + // find first run + r = x; + while (r+2 < width) { + if (comp[r] == comp[r+1] && comp[r] == comp[r+2]) + break; + ++r; + } + if (r+2 >= width) + r = width; + // dump up to first run + while (x < r) { + int len = r-x; + if (len > 128) len = 128; + stbiw__write_dump_data(s, len, &comp[x]); + x += len; + } + // if there's a run, output it + if (r+2 < width) { // same test as what we break out of in search loop, so only true if we break'd + // find next byte after run + while (r < width && comp[r] == comp[x]) + ++r; + // output run up to r + while (x < r) { + int len = r-x; + if (len > 127) len = 127; + stbiw__write_run_data(s, len, comp[x]); + x += len; + } + } + } + } + } +} + +static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data) +{ + if (y <= 0 || x <= 0 || data == NULL) + return 0; + else { + // Each component is stored separately. Allocate scratch space for full output scanline. + unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4); + int i, len; + char buffer[128]; + char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n"; + s->func(s->context, header, sizeof(header)-1); + +#ifdef __STDC_LIB_EXT1__ + len = sprintf_s(buffer, sizeof(buffer), "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x); +#else + len = sprintf(buffer, "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x); +#endif + s->func(s->context, buffer, len); + + for(i=0; i < y; i++) + stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*x*(stbi__flip_vertically_on_write ? y-1-i : i)); + STBIW_FREE(scratch); + return 1; + } +} + +STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const float *data) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_hdr_core(&s, x, y, comp, (float *) data); +} + +STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_hdr_core(&s, x, y, comp, (float *) data); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif // STBI_WRITE_NO_STDIO + + +////////////////////////////////////////////////////////////////////////////// +// +// PNG writer +// + +#ifndef STBIW_ZLIB_COMPRESS +// stretchy buffer; stbiw__sbpush() == vector<>::push_back() -- stbiw__sbcount() == vector<>::size() +#define stbiw__sbraw(a) ((int *) (void *) (a) - 2) +#define stbiw__sbm(a) stbiw__sbraw(a)[0] +#define stbiw__sbn(a) stbiw__sbraw(a)[1] + +#define stbiw__sbneedgrow(a,n) ((a)==0 || stbiw__sbn(a)+n >= stbiw__sbm(a)) +#define stbiw__sbmaybegrow(a,n) (stbiw__sbneedgrow(a,(n)) ? stbiw__sbgrow(a,n) : 0) +#define stbiw__sbgrow(a,n) stbiw__sbgrowf((void **) &(a), (n), sizeof(*(a))) + +#define stbiw__sbpush(a, v) (stbiw__sbmaybegrow(a,1), (a)[stbiw__sbn(a)++] = (v)) +#define stbiw__sbcount(a) ((a) ? stbiw__sbn(a) : 0) +#define stbiw__sbfree(a) ((a) ? STBIW_FREE(stbiw__sbraw(a)),0 : 0) + +static void *stbiw__sbgrowf(void **arr, int increment, int itemsize) +{ + int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1; + void *p = STBIW_REALLOC_SIZED(*arr ? stbiw__sbraw(*arr) : 0, *arr ? (stbiw__sbm(*arr)*itemsize + sizeof(int)*2) : 0, itemsize * m + sizeof(int)*2); + STBIW_ASSERT(p); + if (p) { + if (!*arr) ((int *) p)[1] = 0; + *arr = (void *) ((int *) p + 2); + stbiw__sbm(*arr) = m; + } + return *arr; +} + +static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount) +{ + while (*bitcount >= 8) { + stbiw__sbpush(data, STBIW_UCHAR(*bitbuffer)); + *bitbuffer >>= 8; + *bitcount -= 8; + } + return data; +} + +static int stbiw__zlib_bitrev(int code, int codebits) +{ + int res=0; + while (codebits--) { + res = (res << 1) | (code & 1); + code >>= 1; + } + return res; +} + +static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit) +{ + int i; + for (i=0; i < limit && i < 258; ++i) + if (a[i] != b[i]) break; + return i; +} + +static unsigned int stbiw__zhash(unsigned char *data) +{ + stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16); + hash ^= hash << 3; + hash += hash >> 5; + hash ^= hash << 4; + hash += hash >> 17; + hash ^= hash << 25; + hash += hash >> 6; + return hash; +} + +#define stbiw__zlib_flush() (out = stbiw__zlib_flushf(out, &bitbuf, &bitcount)) +#define stbiw__zlib_add(code,codebits) \ + (bitbuf |= (code) << bitcount, bitcount += (codebits), stbiw__zlib_flush()) +#define stbiw__zlib_huffa(b,c) stbiw__zlib_add(stbiw__zlib_bitrev(b,c),c) +// default huffman tables +#define stbiw__zlib_huff1(n) stbiw__zlib_huffa(0x30 + (n), 8) +#define stbiw__zlib_huff2(n) stbiw__zlib_huffa(0x190 + (n)-144, 9) +#define stbiw__zlib_huff3(n) stbiw__zlib_huffa(0 + (n)-256,7) +#define stbiw__zlib_huff4(n) stbiw__zlib_huffa(0xc0 + (n)-280,8) +#define stbiw__zlib_huff(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : (n) <= 255 ? stbiw__zlib_huff2(n) : (n) <= 279 ? stbiw__zlib_huff3(n) : stbiw__zlib_huff4(n)) +#define stbiw__zlib_huffb(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : stbiw__zlib_huff2(n)) + +#define stbiw__ZHASH 16384 + +#endif // STBIW_ZLIB_COMPRESS + +STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality) +{ +#ifdef STBIW_ZLIB_COMPRESS + // user provided a zlib compress implementation, use that + return STBIW_ZLIB_COMPRESS(data, data_len, out_len, quality); +#else // use builtin + static unsigned short lengthc[] = { 3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258, 259 }; + static unsigned char lengtheb[]= { 0,0,0,0,0,0,0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0 }; + static unsigned short distc[] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577, 32768 }; + static unsigned char disteb[] = { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13 }; + unsigned int bitbuf=0; + int i,j, bitcount=0; + unsigned char *out = NULL; + unsigned char ***hash_table = (unsigned char***) STBIW_MALLOC(stbiw__ZHASH * sizeof(unsigned char**)); + if (hash_table == NULL) + return NULL; + if (quality < 5) quality = 5; + + stbiw__sbpush(out, 0x78); // DEFLATE 32K window + stbiw__sbpush(out, 0x5e); // FLEVEL = 1 + stbiw__zlib_add(1,1); // BFINAL = 1 + stbiw__zlib_add(1,2); // BTYPE = 1 -- fixed huffman + + for (i=0; i < stbiw__ZHASH; ++i) + hash_table[i] = NULL; + + i=0; + while (i < data_len-3) { + // hash next 3 bytes of data to be compressed + int h = stbiw__zhash(data+i)&(stbiw__ZHASH-1), best=3; + unsigned char *bestloc = 0; + unsigned char **hlist = hash_table[h]; + int n = stbiw__sbcount(hlist); + for (j=0; j < n; ++j) { + if (hlist[j]-data > i-32768) { // if entry lies within window + int d = stbiw__zlib_countm(hlist[j], data+i, data_len-i); + if (d >= best) { best=d; bestloc=hlist[j]; } + } + } + // when hash table entry is too long, delete half the entries + if (hash_table[h] && stbiw__sbn(hash_table[h]) == 2*quality) { + STBIW_MEMMOVE(hash_table[h], hash_table[h]+quality, sizeof(hash_table[h][0])*quality); + stbiw__sbn(hash_table[h]) = quality; + } + stbiw__sbpush(hash_table[h],data+i); + + if (bestloc) { + // "lazy matching" - check match at *next* byte, and if it's better, do cur byte as literal + h = stbiw__zhash(data+i+1)&(stbiw__ZHASH-1); + hlist = hash_table[h]; + n = stbiw__sbcount(hlist); + for (j=0; j < n; ++j) { + if (hlist[j]-data > i-32767) { + int e = stbiw__zlib_countm(hlist[j], data+i+1, data_len-i-1); + if (e > best) { // if next match is better, bail on current match + bestloc = NULL; + break; + } + } + } + } + + if (bestloc) { + int d = (int) (data+i - bestloc); // distance back + STBIW_ASSERT(d <= 32767 && best <= 258); + for (j=0; best > lengthc[j+1]-1; ++j); + stbiw__zlib_huff(j+257); + if (lengtheb[j]) stbiw__zlib_add(best - lengthc[j], lengtheb[j]); + for (j=0; d > distc[j+1]-1; ++j); + stbiw__zlib_add(stbiw__zlib_bitrev(j,5),5); + if (disteb[j]) stbiw__zlib_add(d - distc[j], disteb[j]); + i += best; + } else { + stbiw__zlib_huffb(data[i]); + ++i; + } + } + // write out final bytes + for (;i < data_len; ++i) + stbiw__zlib_huffb(data[i]); + stbiw__zlib_huff(256); // end of block + // pad with 0 bits to byte boundary + while (bitcount) + stbiw__zlib_add(0,1); + + for (i=0; i < stbiw__ZHASH; ++i) + (void) stbiw__sbfree(hash_table[i]); + STBIW_FREE(hash_table); + + // store uncompressed instead if compression was worse + if (stbiw__sbn(out) > data_len + 2 + ((data_len+32766)/32767)*5) { + stbiw__sbn(out) = 2; // truncate to DEFLATE 32K window and FLEVEL = 1 + for (j = 0; j < data_len;) { + int blocklen = data_len - j; + if (blocklen > 32767) blocklen = 32767; + stbiw__sbpush(out, data_len - j == blocklen); // BFINAL = ?, BTYPE = 0 -- no compression + stbiw__sbpush(out, STBIW_UCHAR(blocklen)); // LEN + stbiw__sbpush(out, STBIW_UCHAR(blocklen >> 8)); + stbiw__sbpush(out, STBIW_UCHAR(~blocklen)); // NLEN + stbiw__sbpush(out, STBIW_UCHAR(~blocklen >> 8)); + memcpy(out+stbiw__sbn(out), data+j, blocklen); + stbiw__sbn(out) += blocklen; + j += blocklen; + } + } + + { + // compute adler32 on input + unsigned int s1=1, s2=0; + int blocklen = (int) (data_len % 5552); + j=0; + while (j < data_len) { + for (i=0; i < blocklen; ++i) { s1 += data[j+i]; s2 += s1; } + s1 %= 65521; s2 %= 65521; + j += blocklen; + blocklen = 5552; + } + stbiw__sbpush(out, STBIW_UCHAR(s2 >> 8)); + stbiw__sbpush(out, STBIW_UCHAR(s2)); + stbiw__sbpush(out, STBIW_UCHAR(s1 >> 8)); + stbiw__sbpush(out, STBIW_UCHAR(s1)); + } + *out_len = stbiw__sbn(out); + // make returned pointer freeable + STBIW_MEMMOVE(stbiw__sbraw(out), out, *out_len); + return (unsigned char *) stbiw__sbraw(out); +#endif // STBIW_ZLIB_COMPRESS +} + +static unsigned int stbiw__crc32(unsigned char *buffer, int len) +{ +#ifdef STBIW_CRC32 + return STBIW_CRC32(buffer, len); +#else + static unsigned int crc_table[256] = + { + 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, + 0x0eDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, + 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, + 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, + 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, + 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, + 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, + 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, + 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, + 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, + 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, + 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, + 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, + 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, + 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, + 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, + 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, + 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, + 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, + 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, + 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, + 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, + 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, + 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, + 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, + 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, + 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, + 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, + 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, + 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, + 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, + 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D + }; + + unsigned int crc = ~0u; + int i; + for (i=0; i < len; ++i) + crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)]; + return ~crc; +#endif +} + +#define stbiw__wpng4(o,a,b,c,d) ((o)[0]=STBIW_UCHAR(a),(o)[1]=STBIW_UCHAR(b),(o)[2]=STBIW_UCHAR(c),(o)[3]=STBIW_UCHAR(d),(o)+=4) +#define stbiw__wp32(data,v) stbiw__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v)); +#define stbiw__wptag(data,s) stbiw__wpng4(data, s[0],s[1],s[2],s[3]) + +static void stbiw__wpcrc(unsigned char **data, int len) +{ + unsigned int crc = stbiw__crc32(*data - len - 4, len+4); + stbiw__wp32(*data, crc); +} + +static unsigned char stbiw__paeth(int a, int b, int c) +{ + int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c); + if (pa <= pb && pa <= pc) return STBIW_UCHAR(a); + if (pb <= pc) return STBIW_UCHAR(b); + return STBIW_UCHAR(c); +} + +// @OPTIMIZE: provide an option that always forces left-predict or paeth predict +static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int width, int height, int y, int n, int filter_type, signed char *line_buffer) +{ + static int mapping[] = { 0,1,2,3,4 }; + static int firstmap[] = { 0,1,0,5,6 }; + int *mymap = (y != 0) ? mapping : firstmap; + int i; + int type = mymap[filter_type]; + unsigned char *z = pixels + stride_bytes * (stbi__flip_vertically_on_write ? height-1-y : y); + int signed_stride = stbi__flip_vertically_on_write ? -stride_bytes : stride_bytes; + + if (type==0) { + memcpy(line_buffer, z, width*n); + return; + } + + // first loop isn't optimized since it's just one pixel + for (i = 0; i < n; ++i) { + switch (type) { + case 1: line_buffer[i] = z[i]; break; + case 2: line_buffer[i] = z[i] - z[i-signed_stride]; break; + case 3: line_buffer[i] = z[i] - (z[i-signed_stride]>>1); break; + case 4: line_buffer[i] = (signed char) (z[i] - stbiw__paeth(0,z[i-signed_stride],0)); break; + case 5: line_buffer[i] = z[i]; break; + case 6: line_buffer[i] = z[i]; break; + } + } + switch (type) { + case 1: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-n]; break; + case 2: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-signed_stride]; break; + case 3: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - ((z[i-n] + z[i-signed_stride])>>1); break; + case 4: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], z[i-signed_stride], z[i-signed_stride-n]); break; + case 5: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - (z[i-n]>>1); break; + case 6: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], 0,0); break; + } +} + +STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len) +{ + int force_filter = stbi_write_force_png_filter; + int ctype[5] = { -1, 0, 4, 2, 6 }; + unsigned char sig[8] = { 137,80,78,71,13,10,26,10 }; + unsigned char *out,*o, *filt, *zlib; + signed char *line_buffer; + int j,zlen; + + if (stride_bytes == 0) + stride_bytes = x * n; + + if (force_filter >= 5) { + force_filter = -1; + } + + filt = (unsigned char *) STBIW_MALLOC((x*n+1) * y); if (!filt) return 0; + line_buffer = (signed char *) STBIW_MALLOC(x * n); if (!line_buffer) { STBIW_FREE(filt); return 0; } + for (j=0; j < y; ++j) { + int filter_type; + if (force_filter > -1) { + filter_type = force_filter; + stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, force_filter, line_buffer); + } else { // Estimate the best filter by running through all of them: + int best_filter = 0, best_filter_val = 0x7fffffff, est, i; + for (filter_type = 0; filter_type < 5; filter_type++) { + stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, filter_type, line_buffer); + + // Estimate the entropy of the line using this filter; the less, the better. + est = 0; + for (i = 0; i < x*n; ++i) { + est += abs((signed char) line_buffer[i]); + } + if (est < best_filter_val) { + best_filter_val = est; + best_filter = filter_type; + } + } + if (filter_type != best_filter) { // If the last iteration already got us the best filter, don't redo it + stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, best_filter, line_buffer); + filter_type = best_filter; + } + } + // when we get here, filter_type contains the filter type, and line_buffer contains the data + filt[j*(x*n+1)] = (unsigned char) filter_type; + STBIW_MEMMOVE(filt+j*(x*n+1)+1, line_buffer, x*n); + } + STBIW_FREE(line_buffer); + zlib = stbi_zlib_compress(filt, y*( x*n+1), &zlen, stbi_write_png_compression_level); + STBIW_FREE(filt); + if (!zlib) return 0; + + // each tag requires 12 bytes of overhead + out = (unsigned char *) STBIW_MALLOC(8 + 12+13 + 12+zlen + 12); + if (!out) return 0; + *out_len = 8 + 12+13 + 12+zlen + 12; + + o=out; + STBIW_MEMMOVE(o,sig,8); o+= 8; + stbiw__wp32(o, 13); // header length + stbiw__wptag(o, "IHDR"); + stbiw__wp32(o, x); + stbiw__wp32(o, y); + *o++ = 8; + *o++ = STBIW_UCHAR(ctype[n]); + *o++ = 0; + *o++ = 0; + *o++ = 0; + stbiw__wpcrc(&o,13); + + stbiw__wp32(o, zlen); + stbiw__wptag(o, "IDAT"); + STBIW_MEMMOVE(o, zlib, zlen); + o += zlen; + STBIW_FREE(zlib); + stbiw__wpcrc(&o, zlen); + + stbiw__wp32(o,0); + stbiw__wptag(o, "IEND"); + stbiw__wpcrc(&o,0); + + STBIW_ASSERT(o == out + *out_len); + + return out; +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes) +{ + FILE *f; + int len; + unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len); + if (png == NULL) return 0; + + f = stbiw__fopen(filename, "wb"); + if (!f) { STBIW_FREE(png); return 0; } + fwrite(png, 1, len, f); + fclose(f); + STBIW_FREE(png); + return 1; +} +#endif + +STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes) +{ + int len; + unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len); + if (png == NULL) return 0; + func(context, png, len); + STBIW_FREE(png); + return 1; +} + + +/* *************************************************************************** + * + * JPEG writer + * + * This is based on Jon Olick's jo_jpeg.cpp: + * public domain Simple, Minimalistic JPEG writer - http://www.jonolick.com/code.html + */ + +static const unsigned char stbiw__jpg_ZigZag[] = { 0,1,5,6,14,15,27,28,2,4,7,13,16,26,29,42,3,8,12,17,25,30,41,43,9,11,18, + 24,31,40,44,53,10,19,23,32,39,45,52,54,20,22,33,38,46,51,55,60,21,34,37,47,50,56,59,61,35,36,48,49,57,58,62,63 }; + +static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP, const unsigned short *bs) { + int bitBuf = *bitBufP, bitCnt = *bitCntP; + bitCnt += bs[1]; + bitBuf |= bs[0] << (24 - bitCnt); + while(bitCnt >= 8) { + unsigned char c = (bitBuf >> 16) & 255; + stbiw__putc(s, c); + if(c == 255) { + stbiw__putc(s, 0); + } + bitBuf <<= 8; + bitCnt -= 8; + } + *bitBufP = bitBuf; + *bitCntP = bitCnt; +} + +static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p, float *d6p, float *d7p) { + float d0 = *d0p, d1 = *d1p, d2 = *d2p, d3 = *d3p, d4 = *d4p, d5 = *d5p, d6 = *d6p, d7 = *d7p; + float z1, z2, z3, z4, z5, z11, z13; + + float tmp0 = d0 + d7; + float tmp7 = d0 - d7; + float tmp1 = d1 + d6; + float tmp6 = d1 - d6; + float tmp2 = d2 + d5; + float tmp5 = d2 - d5; + float tmp3 = d3 + d4; + float tmp4 = d3 - d4; + + // Even part + float tmp10 = tmp0 + tmp3; // phase 2 + float tmp13 = tmp0 - tmp3; + float tmp11 = tmp1 + tmp2; + float tmp12 = tmp1 - tmp2; + + d0 = tmp10 + tmp11; // phase 3 + d4 = tmp10 - tmp11; + + z1 = (tmp12 + tmp13) * 0.707106781f; // c4 + d2 = tmp13 + z1; // phase 5 + d6 = tmp13 - z1; + + // Odd part + tmp10 = tmp4 + tmp5; // phase 2 + tmp11 = tmp5 + tmp6; + tmp12 = tmp6 + tmp7; + + // The rotator is modified from fig 4-8 to avoid extra negations. + z5 = (tmp10 - tmp12) * 0.382683433f; // c6 + z2 = tmp10 * 0.541196100f + z5; // c2-c6 + z4 = tmp12 * 1.306562965f + z5; // c2+c6 + z3 = tmp11 * 0.707106781f; // c4 + + z11 = tmp7 + z3; // phase 5 + z13 = tmp7 - z3; + + *d5p = z13 + z2; // phase 6 + *d3p = z13 - z2; + *d1p = z11 + z4; + *d7p = z11 - z4; + + *d0p = d0; *d2p = d2; *d4p = d4; *d6p = d6; +} + +static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) { + int tmp1 = val < 0 ? -val : val; + val = val < 0 ? val-1 : val; + bits[1] = 1; + while(tmp1 >>= 1) { + ++bits[1]; + } + bits[0] = val & ((1<0)&&(DU[end0pos]==0); --end0pos) { + } + // end0pos = first element in reverse order !=0 + if(end0pos == 0) { + stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB); + return DU[0]; + } + for(i = 1; i <= end0pos; ++i) { + int startpos = i; + int nrzeroes; + unsigned short bits[2]; + for (; DU[i]==0 && i<=end0pos; ++i) { + } + nrzeroes = i-startpos; + if ( nrzeroes >= 16 ) { + int lng = nrzeroes>>4; + int nrmarker; + for (nrmarker=1; nrmarker <= lng; ++nrmarker) + stbiw__jpg_writeBits(s, bitBuf, bitCnt, M16zeroes); + nrzeroes &= 15; + } + stbiw__jpg_calcBits(DU[i], bits); + stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTAC[(nrzeroes<<4)+bits[1]]); + stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits); + } + if(end0pos != 63) { + stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB); + } + return DU[0]; +} + +static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp, const void* data, int quality) { + // Constants that don't pollute global namespace + static const unsigned char std_dc_luminance_nrcodes[] = {0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0}; + static const unsigned char std_dc_luminance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11}; + static const unsigned char std_ac_luminance_nrcodes[] = {0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d}; + static const unsigned char std_ac_luminance_values[] = { + 0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08, + 0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16,0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28, + 0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59, + 0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89, + 0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6, + 0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2, + 0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa + }; + static const unsigned char std_dc_chrominance_nrcodes[] = {0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0}; + static const unsigned char std_dc_chrominance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11}; + static const unsigned char std_ac_chrominance_nrcodes[] = {0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,0x77}; + static const unsigned char std_ac_chrominance_values[] = { + 0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91, + 0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34,0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26, + 0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58, + 0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87, + 0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4, + 0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda, + 0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa + }; + // Huffman tables + static const unsigned short YDC_HT[256][2] = { {0,2},{2,3},{3,3},{4,3},{5,3},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9}}; + static const unsigned short UVDC_HT[256][2] = { {0,2},{1,2},{2,2},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9},{1022,10},{2046,11}}; + static const unsigned short YAC_HT[256][2] = { + {10,4},{0,2},{1,2},{4,3},{11,4},{26,5},{120,7},{248,8},{1014,10},{65410,16},{65411,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {12,4},{27,5},{121,7},{502,9},{2038,11},{65412,16},{65413,16},{65414,16},{65415,16},{65416,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {28,5},{249,8},{1015,10},{4084,12},{65417,16},{65418,16},{65419,16},{65420,16},{65421,16},{65422,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {58,6},{503,9},{4085,12},{65423,16},{65424,16},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {59,6},{1016,10},{65430,16},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {122,7},{2039,11},{65438,16},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {123,7},{4086,12},{65446,16},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {250,8},{4087,12},{65454,16},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {504,9},{32704,15},{65462,16},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {505,9},{65470,16},{65471,16},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {506,9},{65479,16},{65480,16},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {1017,10},{65488,16},{65489,16},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {1018,10},{65497,16},{65498,16},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {2040,11},{65506,16},{65507,16},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {65515,16},{65516,16},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{0,0},{0,0},{0,0},{0,0},{0,0}, + {2041,11},{65525,16},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0} + }; + static const unsigned short UVAC_HT[256][2] = { + {0,2},{1,2},{4,3},{10,4},{24,5},{25,5},{56,6},{120,7},{500,9},{1014,10},{4084,12},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {11,4},{57,6},{246,8},{501,9},{2038,11},{4085,12},{65416,16},{65417,16},{65418,16},{65419,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {26,5},{247,8},{1015,10},{4086,12},{32706,15},{65420,16},{65421,16},{65422,16},{65423,16},{65424,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {27,5},{248,8},{1016,10},{4087,12},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{65430,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {58,6},{502,9},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{65438,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {59,6},{1017,10},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{65446,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {121,7},{2039,11},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{65454,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {122,7},{2040,11},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{65462,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {249,8},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{65470,16},{65471,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {503,9},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{65479,16},{65480,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {504,9},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{65488,16},{65489,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {505,9},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{65497,16},{65498,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {506,9},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{65506,16},{65507,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {2041,11},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{65515,16},{65516,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {16352,14},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{65525,16},{0,0},{0,0},{0,0},{0,0},{0,0}, + {1018,10},{32707,15},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0} + }; + static const int YQT[] = {16,11,10,16,24,40,51,61,12,12,14,19,26,58,60,55,14,13,16,24,40,57,69,56,14,17,22,29,51,87,80,62,18,22, + 37,56,68,109,103,77,24,35,55,64,81,104,113,92,49,64,78,87,103,121,120,101,72,92,95,98,112,100,103,99}; + static const int UVQT[] = {17,18,24,47,99,99,99,99,18,21,26,66,99,99,99,99,24,26,56,99,99,99,99,99,47,66,99,99,99,99,99,99, + 99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99}; + static const float aasf[] = { 1.0f * 2.828427125f, 1.387039845f * 2.828427125f, 1.306562965f * 2.828427125f, 1.175875602f * 2.828427125f, + 1.0f * 2.828427125f, 0.785694958f * 2.828427125f, 0.541196100f * 2.828427125f, 0.275899379f * 2.828427125f }; + + int row, col, i, k, subsample; + float fdtbl_Y[64], fdtbl_UV[64]; + unsigned char YTable[64], UVTable[64]; + + if(!data || !width || !height || comp > 4 || comp < 1) { + return 0; + } + + quality = quality ? quality : 90; + subsample = quality <= 90 ? 1 : 0; + quality = quality < 1 ? 1 : quality > 100 ? 100 : quality; + quality = quality < 50 ? 5000 / quality : 200 - quality * 2; + + for(i = 0; i < 64; ++i) { + int uvti, yti = (YQT[i]*quality+50)/100; + YTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (yti < 1 ? 1 : yti > 255 ? 255 : yti); + uvti = (UVQT[i]*quality+50)/100; + UVTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (uvti < 1 ? 1 : uvti > 255 ? 255 : uvti); + } + + for(row = 0, k = 0; row < 8; ++row) { + for(col = 0; col < 8; ++col, ++k) { + fdtbl_Y[k] = 1 / (YTable [stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]); + fdtbl_UV[k] = 1 / (UVTable[stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]); + } + } + + // Write Headers + { + static const unsigned char head0[] = { 0xFF,0xD8,0xFF,0xE0,0,0x10,'J','F','I','F',0,1,1,0,0,1,0,1,0,0,0xFF,0xDB,0,0x84,0 }; + static const unsigned char head2[] = { 0xFF,0xDA,0,0xC,3,1,0,2,0x11,3,0x11,0,0x3F,0 }; + const unsigned char head1[] = { 0xFF,0xC0,0,0x11,8,(unsigned char)(height>>8),STBIW_UCHAR(height),(unsigned char)(width>>8),STBIW_UCHAR(width), + 3,1,(unsigned char)(subsample?0x22:0x11),0,2,0x11,1,3,0x11,1,0xFF,0xC4,0x01,0xA2,0 }; + s->func(s->context, (void*)head0, sizeof(head0)); + s->func(s->context, (void*)YTable, sizeof(YTable)); + stbiw__putc(s, 1); + s->func(s->context, UVTable, sizeof(UVTable)); + s->func(s->context, (void*)head1, sizeof(head1)); + s->func(s->context, (void*)(std_dc_luminance_nrcodes+1), sizeof(std_dc_luminance_nrcodes)-1); + s->func(s->context, (void*)std_dc_luminance_values, sizeof(std_dc_luminance_values)); + stbiw__putc(s, 0x10); // HTYACinfo + s->func(s->context, (void*)(std_ac_luminance_nrcodes+1), sizeof(std_ac_luminance_nrcodes)-1); + s->func(s->context, (void*)std_ac_luminance_values, sizeof(std_ac_luminance_values)); + stbiw__putc(s, 1); // HTUDCinfo + s->func(s->context, (void*)(std_dc_chrominance_nrcodes+1), sizeof(std_dc_chrominance_nrcodes)-1); + s->func(s->context, (void*)std_dc_chrominance_values, sizeof(std_dc_chrominance_values)); + stbiw__putc(s, 0x11); // HTUACinfo + s->func(s->context, (void*)(std_ac_chrominance_nrcodes+1), sizeof(std_ac_chrominance_nrcodes)-1); + s->func(s->context, (void*)std_ac_chrominance_values, sizeof(std_ac_chrominance_values)); + s->func(s->context, (void*)head2, sizeof(head2)); + } + + // Encode 8x8 macroblocks + { + static const unsigned short fillBits[] = {0x7F, 7}; + int DCY=0, DCU=0, DCV=0; + int bitBuf=0, bitCnt=0; + // comp == 2 is grey+alpha (alpha is ignored) + int ofsG = comp > 2 ? 1 : 0, ofsB = comp > 2 ? 2 : 0; + const unsigned char *dataR = (const unsigned char *)data; + const unsigned char *dataG = dataR + ofsG; + const unsigned char *dataB = dataR + ofsB; + int x, y, pos; + if(subsample) { + for(y = 0; y < height; y += 16) { + for(x = 0; x < width; x += 16) { + float Y[256], U[256], V[256]; + for(row = y, pos = 0; row < y+16; ++row) { + // row >= height => use last input row + int clamped_row = (row < height) ? row : height - 1; + int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp; + for(col = x; col < x+16; ++col, ++pos) { + // if col >= width => use pixel from last input column + int p = base_p + ((col < width) ? col : (width-1))*comp; + float r = dataR[p], g = dataG[p], b = dataB[p]; + Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128; + U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b; + V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b; + } + } + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+0, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+8, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+128, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+136, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + + // subsample U,V + { + float subU[64], subV[64]; + int yy, xx; + for(yy = 0, pos = 0; yy < 8; ++yy) { + for(xx = 0; xx < 8; ++xx, ++pos) { + int j = yy*32+xx*2; + subU[pos] = (U[j+0] + U[j+1] + U[j+16] + U[j+17]) * 0.25f; + subV[pos] = (V[j+0] + V[j+1] + V[j+16] + V[j+17]) * 0.25f; + } + } + DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subU, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT); + DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subV, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT); + } + } + } + } else { + for(y = 0; y < height; y += 8) { + for(x = 0; x < width; x += 8) { + float Y[64], U[64], V[64]; + for(row = y, pos = 0; row < y+8; ++row) { + // row >= height => use last input row + int clamped_row = (row < height) ? row : height - 1; + int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp; + for(col = x; col < x+8; ++col, ++pos) { + // if col >= width => use pixel from last input column + int p = base_p + ((col < width) ? col : (width-1))*comp; + float r = dataR[p], g = dataG[p], b = dataB[p]; + Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128; + U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b; + V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b; + } + } + + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y, 8, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, U, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT); + DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, V, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT); + } + } + } + + // Do the bit alignment of the EOI marker + stbiw__jpg_writeBits(s, &bitBuf, &bitCnt, fillBits); + } + + // EOI + stbiw__putc(s, 0xFF); + stbiw__putc(s, 0xD9); + + return 1; +} + +STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_jpg_core(&s, x, y, comp, (void *) data, quality); +} + + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_jpg_core(&s, x, y, comp, data, quality); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif + +#endif // STB_IMAGE_WRITE_IMPLEMENTATION + +/* Revision history + 1.16 (2021-07-11) + make Deflate code emit uncompressed blocks when it would otherwise expand + support writing BMPs with alpha channel + 1.15 (2020-07-13) unknown + 1.14 (2020-02-02) updated JPEG writer to downsample chroma channels + 1.13 + 1.12 + 1.11 (2019-08-11) + + 1.10 (2019-02-07) + support utf8 filenames in Windows; fix warnings and platform ifdefs + 1.09 (2018-02-11) + fix typo in zlib quality API, improve STB_I_W_STATIC in C++ + 1.08 (2018-01-29) + add stbi__flip_vertically_on_write, external zlib, zlib quality, choose PNG filter + 1.07 (2017-07-24) + doc fix + 1.06 (2017-07-23) + writing JPEG (using Jon Olick's code) + 1.05 ??? + 1.04 (2017-03-03) + monochrome BMP expansion + 1.03 ??? + 1.02 (2016-04-02) + avoid allocating large structures on the stack + 1.01 (2016-01-16) + STBIW_REALLOC_SIZED: support allocators with no realloc support + avoid race-condition in crc initialization + minor compile issues + 1.00 (2015-09-14) + installable file IO function + 0.99 (2015-09-13) + warning fixes; TGA rle support + 0.98 (2015-04-08) + added STBIW_MALLOC, STBIW_ASSERT etc + 0.97 (2015-01-18) + fixed HDR asserts, rewrote HDR rle logic + 0.96 (2015-01-17) + add HDR output + fix monochrome BMP + 0.95 (2014-08-17) + add monochrome TGA output + 0.94 (2014-05-31) + rename private functions to avoid conflicts with stb_image.h + 0.93 (2014-05-27) + warning fixes + 0.92 (2010-08-01) + casts to unsigned char to fix warnings + 0.91 (2010-07-17) + first public release + 0.90 first internal release +*/ + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ \ No newline at end of file