diff --git a/.clang-format-ignore b/.clang-format-ignore index c052e26940..5f6c30dc53 100644 --- a/.clang-format-ignore +++ b/.clang-format-ignore @@ -1,3 +1,6 @@ # Do not format any .s or .inc file *.s *.inc + +# Do not format tools +tools/* diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 3c32bf0743..f764f62b1c 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -7,7 +7,7 @@ repos: hooks: - id: clang-format args: [--style=file] - exclude: ^(lib|subprojects|tools/(asmdiff|csv2bin|cw|fixrom|msgenc))/ + exclude: ^(lib|subprojects|tools)/ types_or: [c, c++] - repo: https://github.com/pre-commit/pre-commit-hooks rev: v5.0.0 diff --git a/subprojects/nitrogfx.wrap b/subprojects/nitrogfx.wrap deleted file mode 100644 index 1d6e43ad71..0000000000 --- a/subprojects/nitrogfx.wrap +++ /dev/null @@ -1,8 +0,0 @@ -[wrap-git] -url = https://github.com/red031000/nitrogfx.git -revision = 2af8fe24650ed7a296b3f101b08ec7d2317d4e40 -depth = 1 -patch_directory = nitrogfx_patch - -[provide] -program_names = nitrogfx diff --git a/tools/meson.build b/tools/meson.build index 250d0e3945..f446fe45ea 100644 --- a/tools/meson.build +++ b/tools/meson.build @@ -6,6 +6,7 @@ subdir('datagen') subdir('fixrom') subdir('json2bin') subdir('msgenc') +subdir('nitrogfx') subdir('ordergen') subdir('postconf') subdir('scripts') @@ -17,7 +18,6 @@ arm_none_eabi_objcopy_exe = find_program('arm-none-eabi-objcopy', native: true) # Subproject tools makelcf_exe = find_program('makelcf', native: true) -nitrogfx_exe = find_program('nitrogfx', native: true) nitrorom_exe = find_program('nitrorom', native: true) narc_exe = find_program('narc', native: true) SDATTool_py = find_program('SDATTool_py', native: true) diff --git a/tools/nitrogfx/LICENSE b/tools/nitrogfx/LICENSE new file mode 100644 index 0000000000..be4a59938b --- /dev/null +++ b/tools/nitrogfx/LICENSE @@ -0,0 +1,19 @@ +Copyright (c) 2015 YamaArashi, 2021-2024 red031000 + +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/tools/nitrogfx/Makefile b/tools/nitrogfx/Makefile new file mode 100644 index 0000000000..948416ea14 --- /dev/null +++ b/tools/nitrogfx/Makefile @@ -0,0 +1,28 @@ +CC = gcc + +HAVE_LIBPNG := $(shell pkg-config libpng; echo $?) + +ifeq ($(HAVE_LIBPNG),1) +$(error No package 'libpng' found) +endif + +CFLAGS = -Wall -Wextra -Werror -Wno-sign-compare -std=gnu17 -DPNG_SKIP_SETJMP_CHECK $(shell pkg-config --cflags libpng zlib) + +LIBS = $(shell pkg-config --libs libpng zlib) + +SRCS = main.c convert_png.c gfx.c jasc_pal.c lz.c rl.c util.c font.c huff.c json.c cJSON.c +OBJS = $(SRCS:%.c=%.o) + +.PHONY: all clean + +all: nitrogfx + @: + +nitrogfx-debug: $(SRCS) convert_png.h gfx.h global.h jasc_pal.h lz.h rl.h util.h font.h json.h cJSON.h + $(CC) $(CFLAGS) -g -DDEBUG $(SRCS) -o $@ $(LDFLAGS) $(LIBS) + +nitrogfx: $(SRCS) convert_png.h gfx.h global.h jasc_pal.h lz.h rl.h util.h font.h json.h cJSON.h + $(CC) $(CFLAGS) -O2 $(SRCS) -o $@ $(LDFLAGS) $(LIBS) + +clean: + $(RM) -r nitrogfx nitrogfx.exe $(OBJS) diff --git a/tools/nitrogfx/cJSON.c b/tools/nitrogfx/cJSON.c new file mode 100644 index 0000000000..d7c72363db --- /dev/null +++ b/tools/nitrogfx/cJSON.c @@ -0,0 +1,3164 @@ +/* + Copyright (c) 2009-2017 Dave Gamble and cJSON contributors + + 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. +*/ + +/* cJSON */ +/* JSON parser in C. */ + +/* disable warnings about old C89 functions in MSVC */ +#if !defined(_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) +#define _CRT_SECURE_NO_DEPRECATE +#endif + +#ifdef __GNUC__ +#pragma GCC visibility push(default) +#endif +#if defined(_MSC_VER) +#pragma warning (push) +/* disable warning about single line comments in system headers */ +#pragma warning (disable : 4001) +#endif + +#include +#include +#include +#include +#include +#include +#include + +#ifdef ENABLE_LOCALES +#include +#endif + +#if defined(_MSC_VER) +#pragma warning (pop) +#endif +#ifdef __GNUC__ +#pragma GCC visibility pop +#endif + +#include "cJSON.h" + +/* define our own boolean type */ +#ifdef true +#undef true +#endif +#define true ((cJSON_bool)1) + +#ifdef false +#undef false +#endif +#define false ((cJSON_bool)0) + +/* define isnan and isinf for ANSI C, if in C99 or above, isnan and isinf has been defined in math.h */ +#ifndef isinf +#define isinf(d) (isnan((d - d)) && !isnan(d)) +#endif +#ifndef isnan +#define isnan(d) (d != d) +#endif + +#ifndef NAN +#ifdef _WIN32 +#define NAN sqrt(-1.0) +#else +#define NAN 0.0/0.0 +#endif +#endif + +typedef struct { + const unsigned char *json; + size_t position; +} error; +static error global_error = { NULL, 0 }; + +CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void) +{ + return (const char*) (global_error.json + global_error.position); +} + +CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item) +{ + if (!cJSON_IsString(item)) + { + return NULL; + } + + return item->valuestring; +} + +CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item) +{ + if (!cJSON_IsNumber(item)) + { + return (double) NAN; + } + + return item->valuedouble; +} + +/* This is a safeguard to prevent copy-pasters from using incompatible C and header files */ +#if (CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 7) || (CJSON_VERSION_PATCH != 18) + #error cJSON.h and cJSON.c have different versions. Make sure that both have the same. +#endif + +CJSON_PUBLIC(const char*) cJSON_Version(void) +{ + static char version[15]; + sprintf(version, "%i.%i.%i", CJSON_VERSION_MAJOR, CJSON_VERSION_MINOR, CJSON_VERSION_PATCH); + + return version; +} + +/* Case insensitive string comparison, doesn't consider two NULL pointers equal though */ +static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2) +{ + if ((string1 == NULL) || (string2 == NULL)) + { + return 1; + } + + if (string1 == string2) + { + return 0; + } + + for(; tolower(*string1) == tolower(*string2); (void)string1++, string2++) + { + if (*string1 == '\0') + { + return 0; + } + } + + return tolower(*string1) - tolower(*string2); +} + +typedef struct internal_hooks +{ + void *(CJSON_CDECL *allocate)(size_t size); + void (CJSON_CDECL *deallocate)(void *pointer); + void *(CJSON_CDECL *reallocate)(void *pointer, size_t size); +} internal_hooks; + +#if defined(_MSC_VER) +/* work around MSVC error C2322: '...' address of dllimport '...' is not static */ +static void * CJSON_CDECL internal_malloc(size_t size) +{ + return malloc(size); +} +static void CJSON_CDECL internal_free(void *pointer) +{ + free(pointer); +} +static void * CJSON_CDECL internal_realloc(void *pointer, size_t size) +{ + return realloc(pointer, size); +} +#else +#define internal_malloc malloc +#define internal_free free +#define internal_realloc realloc +#endif + +/* strlen of character literals resolved at compile time */ +#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) + +static internal_hooks global_hooks = { internal_malloc, internal_free, internal_realloc }; + +static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks) +{ + size_t length = 0; + unsigned char *copy = NULL; + + if (string == NULL) + { + return NULL; + } + + length = strlen((const char*)string) + sizeof(""); + copy = (unsigned char*)hooks->allocate(length); + if (copy == NULL) + { + return NULL; + } + memcpy(copy, string, length); + + return copy; +} + +CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks) +{ + if (hooks == NULL) + { + /* Reset hooks */ + global_hooks.allocate = malloc; + global_hooks.deallocate = free; + global_hooks.reallocate = realloc; + return; + } + + global_hooks.allocate = malloc; + if (hooks->malloc_fn != NULL) + { + global_hooks.allocate = hooks->malloc_fn; + } + + global_hooks.deallocate = free; + if (hooks->free_fn != NULL) + { + global_hooks.deallocate = hooks->free_fn; + } + + /* use realloc only if both free and malloc are used */ + global_hooks.reallocate = NULL; + if ((global_hooks.allocate == malloc) && (global_hooks.deallocate == free)) + { + global_hooks.reallocate = realloc; + } +} + +/* Internal constructor. */ +static cJSON *cJSON_New_Item(const internal_hooks * const hooks) +{ + cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON)); + if (node) + { + memset(node, '\0', sizeof(cJSON)); + } + + return node; +} + +/* Delete a cJSON structure. */ +CJSON_PUBLIC(void) cJSON_Delete(cJSON *item) +{ + cJSON *next = NULL; + while (item != NULL) + { + next = item->next; + if (!(item->type & cJSON_IsReference) && (item->child != NULL)) + { + cJSON_Delete(item->child); + } + if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL)) + { + global_hooks.deallocate(item->valuestring); + item->valuestring = NULL; + } + if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) + { + global_hooks.deallocate(item->string); + item->string = NULL; + } + global_hooks.deallocate(item); + item = next; + } +} + +/* get the decimal point character of the current locale */ +static unsigned char get_decimal_point(void) +{ +#ifdef ENABLE_LOCALES + struct lconv *lconv = localeconv(); + return (unsigned char) lconv->decimal_point[0]; +#else + return '.'; +#endif +} + +typedef struct +{ + const unsigned char *content; + size_t length; + size_t offset; + size_t depth; /* How deeply nested (in arrays/objects) is the input at the current offset. */ + internal_hooks hooks; +} parse_buffer; + +/* check if the given size is left to read in a given parse buffer (starting with 1) */ +#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) +/* check if the buffer can be accessed at the given index (starting with 0) */ +#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) +#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) +/* get a pointer to the buffer at the position */ +#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) + +/* Parse the input text to generate a number, and populate the result into item. */ +static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_buffer) +{ + double number = 0; + unsigned char *after_end = NULL; + unsigned char number_c_string[64]; + unsigned char decimal_point = get_decimal_point(); + size_t i = 0; + + if ((input_buffer == NULL) || (input_buffer->content == NULL)) + { + return false; + } + + /* copy the number into a temporary buffer and replace '.' with the decimal point + * of the current locale (for strtod) + * This also takes care of '\0' not necessarily being available for marking the end of the input */ + for (i = 0; (i < (sizeof(number_c_string) - 1)) && can_access_at_index(input_buffer, i); i++) + { + switch (buffer_at_offset(input_buffer)[i]) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case '+': + case '-': + case 'e': + case 'E': + number_c_string[i] = buffer_at_offset(input_buffer)[i]; + break; + + case '.': + number_c_string[i] = decimal_point; + break; + + default: + goto loop_end; + } + } +loop_end: + number_c_string[i] = '\0'; + + number = strtod((const char*)number_c_string, (char**)&after_end); + if (number_c_string == after_end) + { + return false; /* parse_error */ + } + + item->valuedouble = number; + + /* use saturation in case of overflow */ + if (number >= INT_MAX) + { + item->valueint = INT_MAX; + } + else if (number <= (double)INT_MIN) + { + item->valueint = INT_MIN; + } + else + { + item->valueint = (int)number; + } + + item->type = cJSON_Number; + + input_buffer->offset += (size_t)(after_end - number_c_string); + return true; +} + +/* don't ask me, but the original cJSON_SetNumberValue returns an integer or double */ +CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number) +{ + if (number >= INT_MAX) + { + object->valueint = INT_MAX; + } + else if (number <= (double)INT_MIN) + { + object->valueint = INT_MIN; + } + else + { + object->valueint = (int)number; + } + + return object->valuedouble = number; +} + +/* Note: when passing a NULL valuestring, cJSON_SetValuestring treats this as an error and return NULL */ +CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring) +{ + char *copy = NULL; + size_t v1_len; + size_t v2_len; + /* if object's type is not cJSON_String or is cJSON_IsReference, it should not set valuestring */ + if ((object == NULL) || !(object->type & cJSON_String) || (object->type & cJSON_IsReference)) + { + return NULL; + } + /* return NULL if the object is corrupted or valuestring is NULL */ + if (object->valuestring == NULL || valuestring == NULL) + { + return NULL; + } + + v1_len = strlen(valuestring); + v2_len = strlen(object->valuestring); + + if (v1_len <= v2_len) + { + /* strcpy does not handle overlapping string: [X1, X2] [Y1, Y2] => X2 < Y1 or Y2 < X1 */ + if (!( valuestring + v1_len < object->valuestring || object->valuestring + v2_len < valuestring )) + { + return NULL; + } + strcpy(object->valuestring, valuestring); + return object->valuestring; + } + copy = (char*) cJSON_strdup((const unsigned char*)valuestring, &global_hooks); + if (copy == NULL) + { + return NULL; + } + if (object->valuestring != NULL) + { + cJSON_free(object->valuestring); + } + object->valuestring = copy; + + return copy; +} + +typedef struct +{ + unsigned char *buffer; + size_t length; + size_t offset; + size_t depth; /* current nesting depth (for formatted printing) */ + cJSON_bool noalloc; + cJSON_bool format; /* is this print a formatted print */ + internal_hooks hooks; +} printbuffer; + +/* realloc printbuffer if necessary to have at least "needed" bytes more */ +static unsigned char* ensure(printbuffer * const p, size_t needed) +{ + unsigned char *newbuffer = NULL; + size_t newsize = 0; + + if ((p == NULL) || (p->buffer == NULL)) + { + return NULL; + } + + if ((p->length > 0) && (p->offset >= p->length)) + { + /* make sure that offset is valid */ + return NULL; + } + + if (needed > INT_MAX) + { + /* sizes bigger than INT_MAX are currently not supported */ + return NULL; + } + + needed += p->offset + 1; + if (needed <= p->length) + { + return p->buffer + p->offset; + } + + if (p->noalloc) { + return NULL; + } + + /* calculate new buffer size */ + if (needed > (INT_MAX / 2)) + { + /* overflow of int, use INT_MAX if possible */ + if (needed <= INT_MAX) + { + newsize = INT_MAX; + } + else + { + return NULL; + } + } + else + { + newsize = needed * 2; + } + + if (p->hooks.reallocate != NULL) + { + /* reallocate with realloc if available */ + newbuffer = (unsigned char*)p->hooks.reallocate(p->buffer, newsize); + if (newbuffer == NULL) + { + p->hooks.deallocate(p->buffer); + p->length = 0; + p->buffer = NULL; + + return NULL; + } + } + else + { + /* otherwise reallocate manually */ + newbuffer = (unsigned char*)p->hooks.allocate(newsize); + if (!newbuffer) + { + p->hooks.deallocate(p->buffer); + p->length = 0; + p->buffer = NULL; + + return NULL; + } + + memcpy(newbuffer, p->buffer, p->offset + 1); + p->hooks.deallocate(p->buffer); + } + p->length = newsize; + p->buffer = newbuffer; + + return newbuffer + p->offset; +} + +/* calculate the new length of the string in a printbuffer and update the offset */ +static void update_offset(printbuffer * const buffer) +{ + const unsigned char *buffer_pointer = NULL; + if ((buffer == NULL) || (buffer->buffer == NULL)) + { + return; + } + buffer_pointer = buffer->buffer + buffer->offset; + + buffer->offset += strlen((const char*)buffer_pointer); +} + +/* securely comparison of floating-point variables */ +static cJSON_bool compare_double(double a, double b) +{ + double maxVal = fabs(a) > fabs(b) ? fabs(a) : fabs(b); + return (fabs(a - b) <= maxVal * DBL_EPSILON); +} + +/* Render the number nicely from the given item into a string. */ +static cJSON_bool print_number(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + double d = item->valuedouble; + int length = 0; + size_t i = 0; + unsigned char number_buffer[26] = {0}; /* temporary buffer to print the number into */ + unsigned char decimal_point = get_decimal_point(); + double test = 0.0; + + if (output_buffer == NULL) + { + return false; + } + + /* This checks for NaN and Infinity */ + if (isnan(d) || isinf(d)) + { + length = sprintf((char*)number_buffer, "null"); + } + else if(d == (double)item->valueint) + { + length = sprintf((char*)number_buffer, "%d", item->valueint); + } + else + { + /* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */ + length = sprintf((char*)number_buffer, "%1.15g", d); + + /* Check whether the original double can be recovered */ + if ((sscanf((char*)number_buffer, "%lg", &test) != 1) || !compare_double((double)test, d)) + { + /* If not, print with 17 decimal places of precision */ + length = sprintf((char*)number_buffer, "%1.17g", d); + } + } + + /* sprintf failed or buffer overrun occurred */ + if ((length < 0) || (length > (int)(sizeof(number_buffer) - 1))) + { + return false; + } + + /* reserve appropriate space in the output */ + output_pointer = ensure(output_buffer, (size_t)length + sizeof("")); + if (output_pointer == NULL) + { + return false; + } + + /* copy the printed number to the output and replace locale + * dependent decimal point with '.' */ + for (i = 0; i < ((size_t)length); i++) + { + if (number_buffer[i] == decimal_point) + { + output_pointer[i] = '.'; + continue; + } + + output_pointer[i] = number_buffer[i]; + } + output_pointer[i] = '\0'; + + output_buffer->offset += (size_t)length; + + return true; +} + +/* parse 4 digit hexadecimal number */ +static unsigned parse_hex4(const unsigned char * const input) +{ + unsigned int h = 0; + size_t i = 0; + + for (i = 0; i < 4; i++) + { + /* parse digit */ + if ((input[i] >= '0') && (input[i] <= '9')) + { + h += (unsigned int) input[i] - '0'; + } + else if ((input[i] >= 'A') && (input[i] <= 'F')) + { + h += (unsigned int) 10 + input[i] - 'A'; + } + else if ((input[i] >= 'a') && (input[i] <= 'f')) + { + h += (unsigned int) 10 + input[i] - 'a'; + } + else /* invalid */ + { + return 0; + } + + if (i < 3) + { + /* shift left to make place for the next nibble */ + h = h << 4; + } + } + + return h; +} + +/* converts a UTF-16 literal to UTF-8 + * A literal can be one or two sequences of the form \uXXXX */ +static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer) +{ + long unsigned int codepoint = 0; + unsigned int first_code = 0; + const unsigned char *first_sequence = input_pointer; + unsigned char utf8_length = 0; + unsigned char utf8_position = 0; + unsigned char sequence_length = 0; + unsigned char first_byte_mark = 0; + + if ((input_end - first_sequence) < 6) + { + /* input ends unexpectedly */ + goto fail; + } + + /* get the first utf16 sequence */ + first_code = parse_hex4(first_sequence + 2); + + /* check that the code is valid */ + if (((first_code >= 0xDC00) && (first_code <= 0xDFFF))) + { + goto fail; + } + + /* UTF16 surrogate pair */ + if ((first_code >= 0xD800) && (first_code <= 0xDBFF)) + { + const unsigned char *second_sequence = first_sequence + 6; + unsigned int second_code = 0; + sequence_length = 12; /* \uXXXX\uXXXX */ + + if ((input_end - second_sequence) < 6) + { + /* input ends unexpectedly */ + goto fail; + } + + if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u')) + { + /* missing second half of the surrogate pair */ + goto fail; + } + + /* get the second utf16 sequence */ + second_code = parse_hex4(second_sequence + 2); + /* check that the code is valid */ + if ((second_code < 0xDC00) || (second_code > 0xDFFF)) + { + /* invalid second half of the surrogate pair */ + goto fail; + } + + + /* calculate the unicode codepoint from the surrogate pair */ + codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF)); + } + else + { + sequence_length = 6; /* \uXXXX */ + codepoint = first_code; + } + + /* encode as UTF-8 + * takes at maximum 4 bytes to encode: + * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ + if (codepoint < 0x80) + { + /* normal ascii, encoding 0xxxxxxx */ + utf8_length = 1; + } + else if (codepoint < 0x800) + { + /* two bytes, encoding 110xxxxx 10xxxxxx */ + utf8_length = 2; + first_byte_mark = 0xC0; /* 11000000 */ + } + else if (codepoint < 0x10000) + { + /* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */ + utf8_length = 3; + first_byte_mark = 0xE0; /* 11100000 */ + } + else if (codepoint <= 0x10FFFF) + { + /* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */ + utf8_length = 4; + first_byte_mark = 0xF0; /* 11110000 */ + } + else + { + /* invalid unicode codepoint */ + goto fail; + } + + /* encode as utf8 */ + for (utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--) + { + /* 10xxxxxx */ + (*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF); + codepoint >>= 6; + } + /* encode first byte */ + if (utf8_length > 1) + { + (*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF); + } + else + { + (*output_pointer)[0] = (unsigned char)(codepoint & 0x7F); + } + + *output_pointer += utf8_length; + + return sequence_length; + +fail: + return 0; +} + +/* Parse the input text into an unescaped cinput, and populate item. */ +static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_buffer) +{ + const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1; + const unsigned char *input_end = buffer_at_offset(input_buffer) + 1; + unsigned char *output_pointer = NULL; + unsigned char *output = NULL; + + /* not a string */ + if (buffer_at_offset(input_buffer)[0] != '\"') + { + goto fail; + } + + { + /* calculate approximate size of the output (overestimate) */ + size_t allocation_length = 0; + size_t skipped_bytes = 0; + while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"')) + { + /* is escape sequence */ + if (input_end[0] == '\\') + { + if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length) + { + /* prevent buffer overflow when last input character is a backslash */ + goto fail; + } + skipped_bytes++; + input_end++; + } + input_end++; + } + if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"')) + { + goto fail; /* string ended unexpectedly */ + } + + /* This is at most how much we need for the output */ + allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes; + output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof("")); + if (output == NULL) + { + goto fail; /* allocation failure */ + } + } + + output_pointer = output; + /* loop through the string literal */ + while (input_pointer < input_end) + { + if (*input_pointer != '\\') + { + *output_pointer++ = *input_pointer++; + } + /* escape sequence */ + else + { + unsigned char sequence_length = 2; + if ((input_end - input_pointer) < 1) + { + goto fail; + } + + switch (input_pointer[1]) + { + case 'b': + *output_pointer++ = '\b'; + break; + case 'f': + *output_pointer++ = '\f'; + break; + case 'n': + *output_pointer++ = '\n'; + break; + case 'r': + *output_pointer++ = '\r'; + break; + case 't': + *output_pointer++ = '\t'; + break; + case '\"': + case '\\': + case '/': + *output_pointer++ = input_pointer[1]; + break; + + /* UTF-16 literal */ + case 'u': + sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer); + if (sequence_length == 0) + { + /* failed to convert UTF16-literal to UTF-8 */ + goto fail; + } + break; + + default: + goto fail; + } + input_pointer += sequence_length; + } + } + + /* zero terminate the output */ + *output_pointer = '\0'; + + item->type = cJSON_String; + item->valuestring = (char*)output; + + input_buffer->offset = (size_t) (input_end - input_buffer->content); + input_buffer->offset++; + + return true; + +fail: + if (output != NULL) + { + input_buffer->hooks.deallocate(output); + output = NULL; + } + + if (input_pointer != NULL) + { + input_buffer->offset = (size_t)(input_pointer - input_buffer->content); + } + + return false; +} + +/* Render the cstring provided to an escaped version that can be printed. */ +static cJSON_bool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer) +{ + const unsigned char *input_pointer = NULL; + unsigned char *output = NULL; + unsigned char *output_pointer = NULL; + size_t output_length = 0; + /* numbers of additional characters needed for escaping */ + size_t escape_characters = 0; + + if (output_buffer == NULL) + { + return false; + } + + /* empty string */ + if (input == NULL) + { + output = ensure(output_buffer, sizeof("\"\"")); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "\"\""); + + return true; + } + + /* set "flag" to 1 if something needs to be escaped */ + for (input_pointer = input; *input_pointer; input_pointer++) + { + switch (*input_pointer) + { + case '\"': + case '\\': + case '\b': + case '\f': + case '\n': + case '\r': + case '\t': + /* one character escape sequence */ + escape_characters++; + break; + default: + if (*input_pointer < 32) + { + /* UTF-16 escape sequence uXXXX */ + escape_characters += 5; + } + break; + } + } + output_length = (size_t)(input_pointer - input) + escape_characters; + + output = ensure(output_buffer, output_length + sizeof("\"\"")); + if (output == NULL) + { + return false; + } + + /* no characters have to be escaped */ + if (escape_characters == 0) + { + output[0] = '\"'; + memcpy(output + 1, input, output_length); + output[output_length + 1] = '\"'; + output[output_length + 2] = '\0'; + + return true; + } + + output[0] = '\"'; + output_pointer = output + 1; + /* copy the string */ + for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++) + { + if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\')) + { + /* normal character, copy */ + *output_pointer = *input_pointer; + } + else + { + /* character needs to be escaped */ + *output_pointer++ = '\\'; + switch (*input_pointer) + { + case '\\': + *output_pointer = '\\'; + break; + case '\"': + *output_pointer = '\"'; + break; + case '\b': + *output_pointer = 'b'; + break; + case '\f': + *output_pointer = 'f'; + break; + case '\n': + *output_pointer = 'n'; + break; + case '\r': + *output_pointer = 'r'; + break; + case '\t': + *output_pointer = 't'; + break; + default: + /* escape and print as unicode codepoint */ + sprintf((char*)output_pointer, "u%04x", *input_pointer); + output_pointer += 4; + break; + } + } + } + output[output_length + 1] = '\"'; + output[output_length + 2] = '\0'; + + return true; +} + +/* Invoke print_string_ptr (which is useful) on an item. */ +static cJSON_bool print_string(const cJSON * const item, printbuffer * const p) +{ + return print_string_ptr((unsigned char*)item->valuestring, p); +} + +/* Predeclare these prototypes. */ +static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer); +static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer); +static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer); + +/* Utility to jump whitespace and cr/lf */ +static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer) +{ + if ((buffer == NULL) || (buffer->content == NULL)) + { + return NULL; + } + + if (cannot_access_at_index(buffer, 0)) + { + return buffer; + } + + while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32)) + { + buffer->offset++; + } + + if (buffer->offset == buffer->length) + { + buffer->offset--; + } + + return buffer; +} + +/* skip the UTF-8 BOM (byte order mark) if it is at the beginning of a buffer */ +static parse_buffer *skip_utf8_bom(parse_buffer * const buffer) +{ + if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0)) + { + return NULL; + } + + if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0)) + { + buffer->offset += 3; + } + + return buffer; +} + +CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated) +{ + size_t buffer_length; + + if (NULL == value) + { + return NULL; + } + + /* Adding null character size due to require_null_terminated. */ + buffer_length = strlen(value) + sizeof(""); + + return cJSON_ParseWithLengthOpts(value, buffer_length, return_parse_end, require_null_terminated); +} + +/* Parse an object - create a new root, and populate. */ +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated) +{ + parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } }; + cJSON *item = NULL; + + /* reset error position */ + global_error.json = NULL; + global_error.position = 0; + + if (value == NULL || 0 == buffer_length) + { + goto fail; + } + + buffer.content = (const unsigned char*)value; + buffer.length = buffer_length; + buffer.offset = 0; + buffer.hooks = global_hooks; + + item = cJSON_New_Item(&global_hooks); + if (item == NULL) /* memory fail */ + { + goto fail; + } + + if (!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer)))) + { + /* parse failure. ep is set. */ + goto fail; + } + + /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */ + if (require_null_terminated) + { + buffer_skip_whitespace(&buffer); + if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0') + { + goto fail; + } + } + if (return_parse_end) + { + *return_parse_end = (const char*)buffer_at_offset(&buffer); + } + + return item; + +fail: + if (item != NULL) + { + cJSON_Delete(item); + } + + if (value != NULL) + { + error local_error; + local_error.json = (const unsigned char*)value; + local_error.position = 0; + + if (buffer.offset < buffer.length) + { + local_error.position = buffer.offset; + } + else if (buffer.length > 0) + { + local_error.position = buffer.length - 1; + } + + if (return_parse_end != NULL) + { + *return_parse_end = (const char*)local_error.json + local_error.position; + } + + global_error = local_error; + } + + return NULL; +} + +/* Default options for cJSON_Parse */ +CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value) +{ + return cJSON_ParseWithOpts(value, 0, 0); +} + +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length) +{ + return cJSON_ParseWithLengthOpts(value, buffer_length, 0, 0); +} + +#define cjson_min(a, b) (((a) < (b)) ? (a) : (b)) + +static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks) +{ + static const size_t default_buffer_size = 256; + printbuffer buffer[1]; + unsigned char *printed = NULL; + + memset(buffer, 0, sizeof(buffer)); + + /* create buffer */ + buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size); + buffer->length = default_buffer_size; + buffer->format = format; + buffer->hooks = *hooks; + if (buffer->buffer == NULL) + { + goto fail; + } + + /* print the value */ + if (!print_value(item, buffer)) + { + goto fail; + } + update_offset(buffer); + + /* check if reallocate is available */ + if (hooks->reallocate != NULL) + { + printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1); + if (printed == NULL) { + goto fail; + } + buffer->buffer = NULL; + } + else /* otherwise copy the JSON over to a new buffer */ + { + printed = (unsigned char*) hooks->allocate(buffer->offset + 1); + if (printed == NULL) + { + goto fail; + } + memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1)); + printed[buffer->offset] = '\0'; /* just to be sure */ + + /* free the buffer */ + hooks->deallocate(buffer->buffer); + buffer->buffer = NULL; + } + + return printed; + +fail: + if (buffer->buffer != NULL) + { + hooks->deallocate(buffer->buffer); + buffer->buffer = NULL; + } + + if (printed != NULL) + { + hooks->deallocate(printed); + printed = NULL; + } + + return NULL; +} + +/* Render a cJSON item/entity/structure to text. */ +CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item) +{ + return (char*)print(item, true, &global_hooks); +} + +CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item) +{ + return (char*)print(item, false, &global_hooks); +} + +CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt) +{ + printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; + + if (prebuffer < 0) + { + return NULL; + } + + p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer); + if (!p.buffer) + { + return NULL; + } + + p.length = (size_t)prebuffer; + p.offset = 0; + p.noalloc = false; + p.format = fmt; + p.hooks = global_hooks; + + if (!print_value(item, &p)) + { + global_hooks.deallocate(p.buffer); + p.buffer = NULL; + return NULL; + } + + return (char*)p.buffer; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format) +{ + printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; + + if ((length < 0) || (buffer == NULL)) + { + return false; + } + + p.buffer = (unsigned char*)buffer; + p.length = (size_t)length; + p.offset = 0; + p.noalloc = true; + p.format = format; + p.hooks = global_hooks; + + return print_value(item, &p); +} + +/* Parser core - when encountering text, process appropriately. */ +static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer) +{ + if ((input_buffer == NULL) || (input_buffer->content == NULL)) + { + return false; /* no input */ + } + + /* parse the different types of values */ + /* null */ + if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0)) + { + item->type = cJSON_NULL; + input_buffer->offset += 4; + return true; + } + /* false */ + if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0)) + { + item->type = cJSON_False; + input_buffer->offset += 5; + return true; + } + /* true */ + if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0)) + { + item->type = cJSON_True; + item->valueint = 1; + input_buffer->offset += 4; + return true; + } + /* string */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"')) + { + return parse_string(item, input_buffer); + } + /* number */ + if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9')))) + { + return parse_number(item, input_buffer); + } + /* array */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '[')) + { + return parse_array(item, input_buffer); + } + /* object */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{')) + { + return parse_object(item, input_buffer); + } + + return false; +} + +/* Render a value to text. */ +static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output = NULL; + + if ((item == NULL) || (output_buffer == NULL)) + { + return false; + } + + switch ((item->type) & 0xFF) + { + case cJSON_NULL: + output = ensure(output_buffer, 5); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "null"); + return true; + + case cJSON_False: + output = ensure(output_buffer, 6); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "false"); + return true; + + case cJSON_True: + output = ensure(output_buffer, 5); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "true"); + return true; + + case cJSON_Number: + return print_number(item, output_buffer); + + case cJSON_Raw: + { + size_t raw_length = 0; + if (item->valuestring == NULL) + { + return false; + } + + raw_length = strlen(item->valuestring) + sizeof(""); + output = ensure(output_buffer, raw_length); + if (output == NULL) + { + return false; + } + memcpy(output, item->valuestring, raw_length); + return true; + } + + case cJSON_String: + return print_string(item, output_buffer); + + case cJSON_Array: + return print_array(item, output_buffer); + + case cJSON_Object: + return print_object(item, output_buffer); + + default: + return false; + } +} + +/* Build an array from input text. */ +static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer) +{ + cJSON *head = NULL; /* head of the linked list */ + cJSON *current_item = NULL; + + if (input_buffer->depth >= CJSON_NESTING_LIMIT) + { + return false; /* to deeply nested */ + } + input_buffer->depth++; + + if (buffer_at_offset(input_buffer)[0] != '[') + { + /* not an array */ + goto fail; + } + + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']')) + { + /* empty array */ + goto success; + } + + /* check if we skipped to the end of the buffer */ + if (cannot_access_at_index(input_buffer, 0)) + { + input_buffer->offset--; + goto fail; + } + + /* step back to character in front of the first element */ + input_buffer->offset--; + /* loop through the comma separated array elements */ + do + { + /* allocate next item */ + cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); + if (new_item == NULL) + { + goto fail; /* allocation failure */ + } + + /* attach next item to list */ + if (head == NULL) + { + /* start the linked list */ + current_item = head = new_item; + } + else + { + /* add to the end and advance */ + current_item->next = new_item; + new_item->prev = current_item; + current_item = new_item; + } + + /* parse next value */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_value(current_item, input_buffer)) + { + goto fail; /* failed to parse value */ + } + buffer_skip_whitespace(input_buffer); + } + while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); + + if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']') + { + goto fail; /* expected end of array */ + } + +success: + input_buffer->depth--; + + if (head != NULL) { + head->prev = current_item; + } + + item->type = cJSON_Array; + item->child = head; + + input_buffer->offset++; + + return true; + +fail: + if (head != NULL) + { + cJSON_Delete(head); + } + + return false; +} + +/* Render an array to text */ +static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + size_t length = 0; + cJSON *current_element = item->child; + + if (output_buffer == NULL) + { + return false; + } + + /* Compose the output array. */ + /* opening square bracket */ + output_pointer = ensure(output_buffer, 1); + if (output_pointer == NULL) + { + return false; + } + + *output_pointer = '['; + output_buffer->offset++; + output_buffer->depth++; + + while (current_element != NULL) + { + if (!print_value(current_element, output_buffer)) + { + return false; + } + update_offset(output_buffer); + if (current_element->next) + { + length = (size_t) (output_buffer->format ? 2 : 1); + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ','; + if(output_buffer->format) + { + *output_pointer++ = ' '; + } + *output_pointer = '\0'; + output_buffer->offset += length; + } + current_element = current_element->next; + } + + output_pointer = ensure(output_buffer, 2); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ']'; + *output_pointer = '\0'; + output_buffer->depth--; + + return true; +} + +/* Build an object from the text. */ +static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer) +{ + cJSON *head = NULL; /* linked list head */ + cJSON *current_item = NULL; + + if (input_buffer->depth >= CJSON_NESTING_LIMIT) + { + return false; /* to deeply nested */ + } + input_buffer->depth++; + + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{')) + { + goto fail; /* not an object */ + } + + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}')) + { + goto success; /* empty object */ + } + + /* check if we skipped to the end of the buffer */ + if (cannot_access_at_index(input_buffer, 0)) + { + input_buffer->offset--; + goto fail; + } + + /* step back to character in front of the first element */ + input_buffer->offset--; + /* loop through the comma separated array elements */ + do + { + /* allocate next item */ + cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); + if (new_item == NULL) + { + goto fail; /* allocation failure */ + } + + /* attach next item to list */ + if (head == NULL) + { + /* start the linked list */ + current_item = head = new_item; + } + else + { + /* add to the end and advance */ + current_item->next = new_item; + new_item->prev = current_item; + current_item = new_item; + } + + if (cannot_access_at_index(input_buffer, 1)) + { + goto fail; /* nothing comes after the comma */ + } + + /* parse the name of the child */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_string(current_item, input_buffer)) + { + goto fail; /* failed to parse name */ + } + buffer_skip_whitespace(input_buffer); + + /* swap valuestring and string, because we parsed the name */ + current_item->string = current_item->valuestring; + current_item->valuestring = NULL; + + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':')) + { + goto fail; /* invalid object */ + } + + /* parse the value */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_value(current_item, input_buffer)) + { + goto fail; /* failed to parse value */ + } + buffer_skip_whitespace(input_buffer); + } + while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); + + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}')) + { + goto fail; /* expected end of object */ + } + +success: + input_buffer->depth--; + + if (head != NULL) { + head->prev = current_item; + } + + item->type = cJSON_Object; + item->child = head; + + input_buffer->offset++; + return true; + +fail: + if (head != NULL) + { + cJSON_Delete(head); + } + + return false; +} + +/* Render an object to text. */ +static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + size_t length = 0; + cJSON *current_item = item->child; + + if (output_buffer == NULL) + { + return false; + } + + /* Compose the output: */ + length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */ + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + + *output_pointer++ = '{'; + output_buffer->depth++; + if (output_buffer->format) + { + *output_pointer++ = '\n'; + } + output_buffer->offset += length; + + while (current_item) + { + if (output_buffer->format) + { + size_t i; + output_pointer = ensure(output_buffer, output_buffer->depth); + if (output_pointer == NULL) + { + return false; + } + for (i = 0; i < output_buffer->depth; i++) + { + *output_pointer++ = '\t'; + } + output_buffer->offset += output_buffer->depth; + } + + /* print key */ + if (!print_string_ptr((unsigned char*)current_item->string, output_buffer)) + { + return false; + } + update_offset(output_buffer); + + length = (size_t) (output_buffer->format ? 2 : 1); + output_pointer = ensure(output_buffer, length); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ':'; + if (output_buffer->format) + { + *output_pointer++ = '\t'; + } + output_buffer->offset += length; + + /* print value */ + if (!print_value(current_item, output_buffer)) + { + return false; + } + update_offset(output_buffer); + + /* print comma if not last */ + length = ((size_t)(output_buffer->format ? 1 : 0) + (size_t)(current_item->next ? 1 : 0)); + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + if (current_item->next) + { + *output_pointer++ = ','; + } + + if (output_buffer->format) + { + *output_pointer++ = '\n'; + } + *output_pointer = '\0'; + output_buffer->offset += length; + + current_item = current_item->next; + } + + output_pointer = ensure(output_buffer, output_buffer->format ? (output_buffer->depth + 1) : 2); + if (output_pointer == NULL) + { + return false; + } + if (output_buffer->format) + { + size_t i; + for (i = 0; i < (output_buffer->depth - 1); i++) + { + *output_pointer++ = '\t'; + } + } + *output_pointer++ = '}'; + *output_pointer = '\0'; + output_buffer->depth--; + + return true; +} + +/* Get Array size/item / object item. */ +CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array) +{ + cJSON *child = NULL; + size_t size = 0; + + if (array == NULL) + { + return 0; + } + + child = array->child; + + while(child != NULL) + { + size++; + child = child->next; + } + + /* FIXME: Can overflow here. Cannot be fixed without breaking the API */ + + return (int)size; +} + +static cJSON* get_array_item(const cJSON *array, size_t index) +{ + cJSON *current_child = NULL; + + if (array == NULL) + { + return NULL; + } + + current_child = array->child; + while ((current_child != NULL) && (index > 0)) + { + index--; + current_child = current_child->next; + } + + return current_child; +} + +CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index) +{ + if (index < 0) + { + return NULL; + } + + return get_array_item(array, (size_t)index); +} + +static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive) +{ + cJSON *current_element = NULL; + + if ((object == NULL) || (name == NULL)) + { + return NULL; + } + + current_element = object->child; + if (case_sensitive) + { + while ((current_element != NULL) && (current_element->string != NULL) && (strcmp(name, current_element->string) != 0)) + { + current_element = current_element->next; + } + } + else + { + while ((current_element != NULL) && (case_insensitive_strcmp((const unsigned char*)name, (const unsigned char*)(current_element->string)) != 0)) + { + current_element = current_element->next; + } + } + + if ((current_element == NULL) || (current_element->string == NULL)) { + return NULL; + } + + return current_element; +} + +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string) +{ + return get_object_item(object, string, false); +} + +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string) +{ + return get_object_item(object, string, true); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string) +{ + return cJSON_GetObjectItem(object, string) ? 1 : 0; +} + +/* Utility for array list handling. */ +static void suffix_object(cJSON *prev, cJSON *item) +{ + prev->next = item; + item->prev = prev; +} + +/* Utility for handling references. */ +static cJSON *create_reference(const cJSON *item, const internal_hooks * const hooks) +{ + cJSON *reference = NULL; + if (item == NULL) + { + return NULL; + } + + reference = cJSON_New_Item(hooks); + if (reference == NULL) + { + return NULL; + } + + memcpy(reference, item, sizeof(cJSON)); + reference->string = NULL; + reference->type |= cJSON_IsReference; + reference->next = reference->prev = NULL; + return reference; +} + +static cJSON_bool add_item_to_array(cJSON *array, cJSON *item) +{ + cJSON *child = NULL; + + if ((item == NULL) || (array == NULL) || (array == item)) + { + return false; + } + + child = array->child; + /* + * To find the last item in array quickly, we use prev in array + */ + if (child == NULL) + { + /* list is empty, start new one */ + array->child = item; + item->prev = item; + item->next = NULL; + } + else + { + /* append to the end */ + if (child->prev) + { + suffix_object(child->prev, item); + array->child->prev = item; + } + } + + return true; +} + +/* Add item to array/object. */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item) +{ + return add_item_to_array(array, item); +} + +#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))) + #pragma GCC diagnostic push +#endif +#ifdef __GNUC__ +#pragma GCC diagnostic ignored "-Wcast-qual" +#endif +/* helper function to cast away const */ +static void* cast_away_const(const void* string) +{ + return (void*)string; +} +#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))) + #pragma GCC diagnostic pop +#endif + + +static cJSON_bool add_item_to_object(cJSON * const object, const char * const string, cJSON * const item, const internal_hooks * const hooks, const cJSON_bool constant_key) +{ + char *new_key = NULL; + int new_type = cJSON_Invalid; + + if ((object == NULL) || (string == NULL) || (item == NULL) || (object == item)) + { + return false; + } + + if (constant_key) + { + new_key = (char*)cast_away_const(string); + new_type = item->type | cJSON_StringIsConst; + } + else + { + new_key = (char*)cJSON_strdup((const unsigned char*)string, hooks); + if (new_key == NULL) + { + return false; + } + + new_type = item->type & ~cJSON_StringIsConst; + } + + if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) + { + hooks->deallocate(item->string); + } + + item->string = new_key; + item->type = new_type; + + return add_item_to_array(object, item); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item) +{ + return add_item_to_object(object, string, item, &global_hooks, false); +} + +/* Add an item to an object with constant string as key */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item) +{ + return add_item_to_object(object, string, item, &global_hooks, true); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item) +{ + if (array == NULL) + { + return false; + } + + return add_item_to_array(array, create_reference(item, &global_hooks)); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item) +{ + if ((object == NULL) || (string == NULL)) + { + return false; + } + + return add_item_to_object(object, string, create_reference(item, &global_hooks), &global_hooks, false); +} + +CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name) +{ + cJSON *null = cJSON_CreateNull(); + if (add_item_to_object(object, name, null, &global_hooks, false)) + { + return null; + } + + cJSON_Delete(null); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name) +{ + cJSON *true_item = cJSON_CreateTrue(); + if (add_item_to_object(object, name, true_item, &global_hooks, false)) + { + return true_item; + } + + cJSON_Delete(true_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name) +{ + cJSON *false_item = cJSON_CreateFalse(); + if (add_item_to_object(object, name, false_item, &global_hooks, false)) + { + return false_item; + } + + cJSON_Delete(false_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean) +{ + cJSON *bool_item = cJSON_CreateBool(boolean); + if (add_item_to_object(object, name, bool_item, &global_hooks, false)) + { + return bool_item; + } + + cJSON_Delete(bool_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number) +{ + cJSON *number_item = cJSON_CreateNumber(number); + if (add_item_to_object(object, name, number_item, &global_hooks, false)) + { + return number_item; + } + + cJSON_Delete(number_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string) +{ + cJSON *string_item = cJSON_CreateString(string); + if (add_item_to_object(object, name, string_item, &global_hooks, false)) + { + return string_item; + } + + cJSON_Delete(string_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw) +{ + cJSON *raw_item = cJSON_CreateRaw(raw); + if (add_item_to_object(object, name, raw_item, &global_hooks, false)) + { + return raw_item; + } + + cJSON_Delete(raw_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name) +{ + cJSON *object_item = cJSON_CreateObject(); + if (add_item_to_object(object, name, object_item, &global_hooks, false)) + { + return object_item; + } + + cJSON_Delete(object_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name) +{ + cJSON *array = cJSON_CreateArray(); + if (add_item_to_object(object, name, array, &global_hooks, false)) + { + return array; + } + + cJSON_Delete(array); + return NULL; +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item) +{ + if ((parent == NULL) || (item == NULL) || (item != parent->child && item->prev == NULL)) + { + return NULL; + } + + if (item != parent->child) + { + /* not the first element */ + item->prev->next = item->next; + } + if (item->next != NULL) + { + /* not the last element */ + item->next->prev = item->prev; + } + + if (item == parent->child) + { + /* first element */ + parent->child = item->next; + } + else if (item->next == NULL) + { + /* last element */ + parent->child->prev = item->prev; + } + + /* make sure the detached item doesn't point anywhere anymore */ + item->prev = NULL; + item->next = NULL; + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which) +{ + if (which < 0) + { + return NULL; + } + + return cJSON_DetachItemViaPointer(array, get_array_item(array, (size_t)which)); +} + +CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which) +{ + cJSON_Delete(cJSON_DetachItemFromArray(array, which)); +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string) +{ + cJSON *to_detach = cJSON_GetObjectItem(object, string); + + return cJSON_DetachItemViaPointer(object, to_detach); +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string) +{ + cJSON *to_detach = cJSON_GetObjectItemCaseSensitive(object, string); + + return cJSON_DetachItemViaPointer(object, to_detach); +} + +CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string) +{ + cJSON_Delete(cJSON_DetachItemFromObject(object, string)); +} + +CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string) +{ + cJSON_Delete(cJSON_DetachItemFromObjectCaseSensitive(object, string)); +} + +/* Replace array/object items with new ones. */ +CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem) +{ + cJSON *after_inserted = NULL; + + if (which < 0 || newitem == NULL) + { + return false; + } + + after_inserted = get_array_item(array, (size_t)which); + if (after_inserted == NULL) + { + return add_item_to_array(array, newitem); + } + + if (after_inserted != array->child && after_inserted->prev == NULL) { + /* return false if after_inserted is a corrupted array item */ + return false; + } + + newitem->next = after_inserted; + newitem->prev = after_inserted->prev; + after_inserted->prev = newitem; + if (after_inserted == array->child) + { + array->child = newitem; + } + else + { + newitem->prev->next = newitem; + } + return true; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement) +{ + if ((parent == NULL) || (parent->child == NULL) || (replacement == NULL) || (item == NULL)) + { + return false; + } + + if (replacement == item) + { + return true; + } + + replacement->next = item->next; + replacement->prev = item->prev; + + if (replacement->next != NULL) + { + replacement->next->prev = replacement; + } + if (parent->child == item) + { + if (parent->child->prev == parent->child) + { + replacement->prev = replacement; + } + parent->child = replacement; + } + else + { /* + * To find the last item in array quickly, we use prev in array. + * We can't modify the last item's next pointer where this item was the parent's child + */ + if (replacement->prev != NULL) + { + replacement->prev->next = replacement; + } + if (replacement->next == NULL) + { + parent->child->prev = replacement; + } + } + + item->next = NULL; + item->prev = NULL; + cJSON_Delete(item); + + return true; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem) +{ + if (which < 0) + { + return false; + } + + return cJSON_ReplaceItemViaPointer(array, get_array_item(array, (size_t)which), newitem); +} + +static cJSON_bool replace_item_in_object(cJSON *object, const char *string, cJSON *replacement, cJSON_bool case_sensitive) +{ + if ((replacement == NULL) || (string == NULL)) + { + return false; + } + + /* replace the name in the replacement */ + if (!(replacement->type & cJSON_StringIsConst) && (replacement->string != NULL)) + { + cJSON_free(replacement->string); + } + replacement->string = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks); + if (replacement->string == NULL) + { + return false; + } + + replacement->type &= ~cJSON_StringIsConst; + + return cJSON_ReplaceItemViaPointer(object, get_object_item(object, string, case_sensitive), replacement); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem) +{ + return replace_item_in_object(object, string, newitem, false); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem) +{ + return replace_item_in_object(object, string, newitem, true); +} + +/* Create basic types: */ +CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_NULL; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_True; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_False; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = boolean ? cJSON_True : cJSON_False; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_Number; + item->valuedouble = num; + + /* use saturation in case of overflow */ + if (num >= INT_MAX) + { + item->valueint = INT_MAX; + } + else if (num <= (double)INT_MIN) + { + item->valueint = INT_MIN; + } + else + { + item->valueint = (int)num; + } + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_String; + item->valuestring = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks); + if(!item->valuestring) + { + cJSON_Delete(item); + return NULL; + } + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) + { + item->type = cJSON_String | cJSON_IsReference; + item->valuestring = (char*)cast_away_const(string); + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) { + item->type = cJSON_Object | cJSON_IsReference; + item->child = (cJSON*)cast_away_const(child); + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child) { + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) { + item->type = cJSON_Array | cJSON_IsReference; + item->child = (cJSON*)cast_away_const(child); + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_Raw; + item->valuestring = (char*)cJSON_strdup((const unsigned char*)raw, &global_hooks); + if(!item->valuestring) + { + cJSON_Delete(item); + return NULL; + } + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type=cJSON_Array; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if (item) + { + item->type = cJSON_Object; + } + + return item; +} + +/* Create Arrays: */ +CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for(i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber(numbers[i]); + if (!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for(i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber((double)numbers[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for(i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber(numbers[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (strings == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for (i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateString(strings[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p,n); + } + p = n; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +/* Duplication */ +cJSON * cJSON_Duplicate_rec(const cJSON *item, size_t depth, cJSON_bool recurse); + +CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse) +{ + return cJSON_Duplicate_rec(item, 0, recurse ); +} + +cJSON * cJSON_Duplicate_rec(const cJSON *item, size_t depth, cJSON_bool recurse) +{ + cJSON *newitem = NULL; + cJSON *child = NULL; + cJSON *next = NULL; + cJSON *newchild = NULL; + + /* Bail on bad ptr */ + if (!item) + { + goto fail; + } + /* Create new item */ + newitem = cJSON_New_Item(&global_hooks); + if (!newitem) + { + goto fail; + } + /* Copy over all vars */ + newitem->type = item->type & (~cJSON_IsReference); + newitem->valueint = item->valueint; + newitem->valuedouble = item->valuedouble; + if (item->valuestring) + { + newitem->valuestring = (char*)cJSON_strdup((unsigned char*)item->valuestring, &global_hooks); + if (!newitem->valuestring) + { + goto fail; + } + } + if (item->string) + { + newitem->string = (item->type&cJSON_StringIsConst) ? item->string : (char*)cJSON_strdup((unsigned char*)item->string, &global_hooks); + if (!newitem->string) + { + goto fail; + } + } + /* If non-recursive, then we're done! */ + if (!recurse) + { + return newitem; + } + /* Walk the ->next chain for the child. */ + child = item->child; + while (child != NULL) + { + if(depth >= CJSON_CIRCULAR_LIMIT) { + goto fail; + } + newchild = cJSON_Duplicate_rec(child, depth + 1, true); /* Duplicate (with recurse) each item in the ->next chain */ + if (!newchild) + { + goto fail; + } + if (next != NULL) + { + /* If newitem->child already set, then crosswire ->prev and ->next and move on */ + next->next = newchild; + newchild->prev = next; + next = newchild; + } + else + { + /* Set newitem->child and move to it */ + newitem->child = newchild; + next = newchild; + } + child = child->next; + } + if (newitem && newitem->child) + { + newitem->child->prev = newchild; + } + + return newitem; + +fail: + if (newitem != NULL) + { + cJSON_Delete(newitem); + } + + return NULL; +} + +static void skip_oneline_comment(char **input) +{ + *input += static_strlen("//"); + + for (; (*input)[0] != '\0'; ++(*input)) + { + if ((*input)[0] == '\n') { + *input += static_strlen("\n"); + return; + } + } +} + +static void skip_multiline_comment(char **input) +{ + *input += static_strlen("/*"); + + for (; (*input)[0] != '\0'; ++(*input)) + { + if (((*input)[0] == '*') && ((*input)[1] == '/')) + { + *input += static_strlen("*/"); + return; + } + } +} + +static void minify_string(char **input, char **output) { + (*output)[0] = (*input)[0]; + *input += static_strlen("\""); + *output += static_strlen("\""); + + + for (; (*input)[0] != '\0'; (void)++(*input), ++(*output)) { + (*output)[0] = (*input)[0]; + + if ((*input)[0] == '\"') { + (*output)[0] = '\"'; + *input += static_strlen("\""); + *output += static_strlen("\""); + return; + } else if (((*input)[0] == '\\') && ((*input)[1] == '\"')) { + (*output)[1] = (*input)[1]; + *input += static_strlen("\""); + *output += static_strlen("\""); + } + } +} + +CJSON_PUBLIC(void) cJSON_Minify(char *json) +{ + char *into = json; + + if (json == NULL) + { + return; + } + + while (json[0] != '\0') + { + switch (json[0]) + { + case ' ': + case '\t': + case '\r': + case '\n': + json++; + break; + + case '/': + if (json[1] == '/') + { + skip_oneline_comment(&json); + } + else if (json[1] == '*') + { + skip_multiline_comment(&json); + } else { + json++; + } + break; + + case '\"': + minify_string(&json, (char**)&into); + break; + + default: + into[0] = json[0]; + json++; + into++; + } + } + + /* and null-terminate. */ + *into = '\0'; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Invalid; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_False; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xff) == cJSON_True; +} + + +CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & (cJSON_True | cJSON_False)) != 0; +} +CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_NULL; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Number; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_String; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Array; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Object; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Raw; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive) +{ + if ((a == NULL) || (b == NULL) || ((a->type & 0xFF) != (b->type & 0xFF))) + { + return false; + } + + /* check if type is valid */ + switch (a->type & 0xFF) + { + case cJSON_False: + case cJSON_True: + case cJSON_NULL: + case cJSON_Number: + case cJSON_String: + case cJSON_Raw: + case cJSON_Array: + case cJSON_Object: + break; + + default: + return false; + } + + /* identical objects are equal */ + if (a == b) + { + return true; + } + + switch (a->type & 0xFF) + { + /* in these cases and equal type is enough */ + case cJSON_False: + case cJSON_True: + case cJSON_NULL: + return true; + + case cJSON_Number: + if (compare_double(a->valuedouble, b->valuedouble)) + { + return true; + } + return false; + + case cJSON_String: + case cJSON_Raw: + if ((a->valuestring == NULL) || (b->valuestring == NULL)) + { + return false; + } + if (strcmp(a->valuestring, b->valuestring) == 0) + { + return true; + } + + return false; + + case cJSON_Array: + { + cJSON *a_element = a->child; + cJSON *b_element = b->child; + + for (; (a_element != NULL) && (b_element != NULL);) + { + if (!cJSON_Compare(a_element, b_element, case_sensitive)) + { + return false; + } + + a_element = a_element->next; + b_element = b_element->next; + } + + /* one of the arrays is longer than the other */ + if (a_element != b_element) { + return false; + } + + return true; + } + + case cJSON_Object: + { + cJSON *a_element = NULL; + cJSON *b_element = NULL; + cJSON_ArrayForEach(a_element, a) + { + /* TODO This has O(n^2) runtime, which is horrible! */ + b_element = get_object_item(b, a_element->string, case_sensitive); + if (b_element == NULL) + { + return false; + } + + if (!cJSON_Compare(a_element, b_element, case_sensitive)) + { + return false; + } + } + + /* doing this twice, once on a and b to prevent true comparison if a subset of b + * TODO: Do this the proper way, this is just a fix for now */ + cJSON_ArrayForEach(b_element, b) + { + a_element = get_object_item(a, b_element->string, case_sensitive); + if (a_element == NULL) + { + return false; + } + + if (!cJSON_Compare(b_element, a_element, case_sensitive)) + { + return false; + } + } + + return true; + } + + default: + return false; + } +} + +CJSON_PUBLIC(void *) cJSON_malloc(size_t size) +{ + return global_hooks.allocate(size); +} + +CJSON_PUBLIC(void) cJSON_free(void *object) +{ + global_hooks.deallocate(object); + object = NULL; +} diff --git a/tools/nitrogfx/cJSON.h b/tools/nitrogfx/cJSON.h new file mode 100644 index 0000000000..37520bbcf8 --- /dev/null +++ b/tools/nitrogfx/cJSON.h @@ -0,0 +1,306 @@ +/* + Copyright (c) 2009-2017 Dave Gamble and cJSON contributors + + 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. +*/ + +#ifndef cJSON__h +#define cJSON__h + +#ifdef __cplusplus +extern "C" +{ +#endif + +#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32)) +#define __WINDOWS__ +#endif + +#ifdef __WINDOWS__ + +/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention. For windows you have 3 define options: + +CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols +CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default) +CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol + +For *nix builds that support visibility attribute, you can define similar behavior by + +setting default visibility to hidden by adding +-fvisibility=hidden (for gcc) +or +-xldscope=hidden (for sun cc) +to CFLAGS + +then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does + +*/ + +#define CJSON_CDECL __cdecl +#define CJSON_STDCALL __stdcall + +/* export symbols by default, this is necessary for copy pasting the C and header file */ +#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS) +#define CJSON_EXPORT_SYMBOLS +#endif + +#if defined(CJSON_HIDE_SYMBOLS) +#define CJSON_PUBLIC(type) type CJSON_STDCALL +#elif defined(CJSON_EXPORT_SYMBOLS) +#define CJSON_PUBLIC(type) __declspec(dllexport) type CJSON_STDCALL +#elif defined(CJSON_IMPORT_SYMBOLS) +#define CJSON_PUBLIC(type) __declspec(dllimport) type CJSON_STDCALL +#endif +#else /* !__WINDOWS__ */ +#define CJSON_CDECL +#define CJSON_STDCALL + +#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY) +#define CJSON_PUBLIC(type) __attribute__((visibility("default"))) type +#else +#define CJSON_PUBLIC(type) type +#endif +#endif + +/* project version */ +#define CJSON_VERSION_MAJOR 1 +#define CJSON_VERSION_MINOR 7 +#define CJSON_VERSION_PATCH 18 + +#include + +/* cJSON Types: */ +#define cJSON_Invalid (0) +#define cJSON_False (1 << 0) +#define cJSON_True (1 << 1) +#define cJSON_NULL (1 << 2) +#define cJSON_Number (1 << 3) +#define cJSON_String (1 << 4) +#define cJSON_Array (1 << 5) +#define cJSON_Object (1 << 6) +#define cJSON_Raw (1 << 7) /* raw json */ + +#define cJSON_IsReference 256 +#define cJSON_StringIsConst 512 + +/* The cJSON structure: */ +typedef struct cJSON +{ + /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */ + struct cJSON *next; + struct cJSON *prev; + /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */ + struct cJSON *child; + + /* The type of the item, as above. */ + int type; + + /* The item's string, if type==cJSON_String and type == cJSON_Raw */ + char *valuestring; + /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */ + int valueint; + /* The item's number, if type==cJSON_Number */ + double valuedouble; + + /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */ + char *string; +} cJSON; + +typedef struct cJSON_Hooks +{ + /* malloc/free are CDECL on Windows regardless of the default calling convention of the compiler, so ensure the hooks allow passing those functions directly. */ + void *(CJSON_CDECL *malloc_fn)(size_t sz); + void (CJSON_CDECL *free_fn)(void *ptr); +} cJSON_Hooks; + +typedef int cJSON_bool; + +/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them. + * This is to prevent stack overflows. */ +#ifndef CJSON_NESTING_LIMIT +#define CJSON_NESTING_LIMIT 1000 +#endif + +/* Limits the length of circular references can be before cJSON rejects to parse them. + * This is to prevent stack overflows. */ +#ifndef CJSON_CIRCULAR_LIMIT +#define CJSON_CIRCULAR_LIMIT 10000 +#endif + +/* returns the version of cJSON as a string */ +CJSON_PUBLIC(const char*) cJSON_Version(void); + +/* Supply malloc, realloc and free functions to cJSON */ +CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks); + +/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */ +/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */ +CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value); +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length); +/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */ +/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */ +CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated); +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated); + +/* Render a cJSON entity to text for transfer/storage. */ +CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item); +/* Render a cJSON entity to text for transfer/storage without any formatting. */ +CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item); +/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */ +CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt); +/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */ +/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */ +CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format); +/* Delete a cJSON entity and all subentities. */ +CJSON_PUBLIC(void) cJSON_Delete(cJSON *item); + +/* Returns the number of items in an array (or object). */ +CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array); +/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */ +CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index); +/* Get item "string" from object. Case insensitive. */ +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string); +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string); +CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string); +/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */ +CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void); + +/* Check item type and return its value */ +CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item); +CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item); + +/* These functions check the type of an item */ +CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item); + +/* These calls create a cJSON item of the appropriate type. */ +CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean); +CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num); +CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string); +/* raw json */ +CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw); +CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void); + +/* Create a string where valuestring references a string so + * it will not be freed by cJSON_Delete */ +CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string); +/* Create an object/array that only references it's elements so + * they will not be freed by cJSON_Delete */ +CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child); +CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child); + +/* These utilities create an Array of count items. + * The parameter count cannot be greater than the number of elements in the number array, otherwise array access will be out of bounds.*/ +CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count); +CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count); +CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count); +CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count); + +/* Append item to the specified array/object. */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item); +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item); +/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object. + * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before + * writing to `item->string` */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item); +/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item); +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item); + +/* Remove/Detach items from Arrays/Objects. */ +CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which); +CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string); +CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string); +CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string); + +/* Update array items. */ +CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */ +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement); +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem); +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem); +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem); + +/* Duplicate a cJSON item */ +CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse); +/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will + * need to be released. With recurse!=0, it will duplicate any children connected to the item. + * The item->next and ->prev pointers are always zero on return from Duplicate. */ +/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal. + * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */ +CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive); + +/* Minify a strings, remove blank characters(such as ' ', '\t', '\r', '\n') from strings. + * The input pointer json cannot point to a read-only address area, such as a string constant, + * but should point to a readable and writable address area. */ +CJSON_PUBLIC(void) cJSON_Minify(char *json); + +/* Helper functions for creating and adding items to an object at the same time. + * They return the added item or NULL on failure. */ +CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean); +CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number); +CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string); +CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw); +CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name); + +/* When assigning an integer value, it needs to be propagated to valuedouble too. */ +#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number)) +/* helper for the cJSON_SetNumberValue macro */ +CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number); +#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number)) +/* Change the valuestring of a cJSON_String object, only takes effect when type of object is cJSON_String */ +CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring); + +/* If the object is not a boolean type this does nothing and returns cJSON_Invalid else it returns the new type*/ +#define cJSON_SetBoolValue(object, boolValue) ( \ + (object != NULL && ((object)->type & (cJSON_False|cJSON_True))) ? \ + (object)->type=((object)->type &(~(cJSON_False|cJSON_True)))|((boolValue)?cJSON_True:cJSON_False) : \ + cJSON_Invalid\ +) + +/* Macro for iterating over an array or object */ +#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next) + +/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */ +CJSON_PUBLIC(void *) cJSON_malloc(size_t size); +CJSON_PUBLIC(void) cJSON_free(void *object); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/nitrogfx/convert_png.c b/tools/nitrogfx/convert_png.c new file mode 100644 index 0000000000..efd6989f05 --- /dev/null +++ b/tools/nitrogfx/convert_png.c @@ -0,0 +1,256 @@ +// Copyright (c) 2015 YamaArashi + +#include +#include +#include +#include "global.h" +#include "convert_png.h" +#include "gfx.h" + +static FILE *PngReadOpen(char *path, png_structp *pngStruct, png_infop *pngInfo) +{ + FILE *fp = fopen(path, "rb"); + + if (fp == NULL) + FATAL_ERROR("Failed to open \"%s\" for reading.\n", path); + + unsigned char sig[8]; + + if (fread(sig, 8, 1, fp) != 1) + FATAL_ERROR("Failed to read PNG signature from \"%s\".\n", path); + + if (png_sig_cmp(sig, 0, 8)) + FATAL_ERROR("\"%s\" does not have a valid PNG signature.\n", path); + + png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); + + if (!png_ptr) + FATAL_ERROR("Failed to create PNG read struct.\n"); + + png_infop info_ptr = png_create_info_struct(png_ptr); + + if (!info_ptr) + FATAL_ERROR("Failed to create PNG info struct.\n"); + + if (setjmp(png_jmpbuf(png_ptr))) + FATAL_ERROR("Failed to init I/O for reading \"%s\".\n", path); + + png_init_io(png_ptr, fp); + png_set_sig_bytes(png_ptr, 8); + png_read_info(png_ptr, info_ptr); + + *pngStruct = png_ptr; + *pngInfo = info_ptr; + + return fp; +} + +static unsigned char *ConvertBitDepth(unsigned char *src, int srcBitDepth, int destBitDepth, int numPixels) +{ + // Round the number of bits up to the next 8 and divide by 8 to get the number of bytes. + int srcSize = ((numPixels * srcBitDepth + 7) & ~7) / 8; + int destSize = ((numPixels * destBitDepth + 7) & ~7) / 8; + unsigned char *output = calloc(destSize, 1); + unsigned char *dest = output; + int i; + int j; + int destBit = 8 - destBitDepth; + + for (i = 0; i < srcSize; i++) + { + unsigned char srcByte = src[i]; + + for (j = 8 - srcBitDepth; j >= 0; j -= srcBitDepth) + { + unsigned char pixel = (srcByte >> j) % (1 << srcBitDepth); + + if (pixel >= (1 << destBitDepth)) + FATAL_ERROR("Image exceeds the maximum color value for a %ibpp image.\n", destBitDepth); + *dest |= pixel << destBit; + destBit -= destBitDepth; + if (destBit < 0) + { + dest++; + destBit = 8 - destBitDepth; + } + } + } + + return output; +} + +void ReadPng(char *path, struct Image *image) +{ + png_structp png_ptr; + png_infop info_ptr; + + FILE *fp = PngReadOpen(path, &png_ptr, &info_ptr); + + int bit_depth = png_get_bit_depth(png_ptr, info_ptr); + + int color_type = png_get_color_type(png_ptr, info_ptr); + + if (color_type != PNG_COLOR_TYPE_GRAY && color_type != PNG_COLOR_TYPE_PALETTE) + FATAL_ERROR("\"%s\" has an unsupported color type.\n", path); + + // Check if the image has a palette so that we can tell if the colors need to be inverted later. + // Don't read the palette because it's not needed for now. + image->hasPalette = (color_type == PNG_COLOR_TYPE_PALETTE); + + image->width = png_get_image_width(png_ptr, info_ptr); + image->height = png_get_image_height(png_ptr, info_ptr); + + int rowbytes = png_get_rowbytes(png_ptr, info_ptr); + + image->pixels = malloc(image->height * rowbytes); + + if (image->pixels == NULL) + FATAL_ERROR("Failed to allocate pixel buffer.\n"); + + png_bytepp row_pointers = malloc(image->height * sizeof(png_bytep)); + + if (row_pointers == NULL) + FATAL_ERROR("Failed to allocate row pointers.\n"); + + for (int i = 0; i < image->height; i++) + row_pointers[i] = (png_bytep)(image->pixels + (i * rowbytes)); + + if (setjmp(png_jmpbuf(png_ptr))) + FATAL_ERROR("Error reading from \"%s\".\n", path); + + png_read_image(png_ptr, row_pointers); + + png_destroy_read_struct(&png_ptr, &info_ptr, NULL); + + free(row_pointers); + fclose(fp); + + if (bit_depth != image->bitDepth) + { + unsigned char *src = image->pixels; + + if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 && bit_depth != 8) + FATAL_ERROR("Bit depth of image must be 1, 2, 4, or 8.\n"); + image->pixels = ConvertBitDepth(image->pixels, bit_depth, image->bitDepth, image->width * image->height); + free(src); + image->bitDepth = bit_depth; + } +} + +void ReadPngPalette(char *path, struct Palette *palette) +{ + png_structp png_ptr; + png_infop info_ptr; + png_colorp colors; + int numColors; + + FILE *fp = PngReadOpen(path, &png_ptr, &info_ptr); + + if (png_get_color_type(png_ptr, info_ptr) != PNG_COLOR_TYPE_PALETTE) + FATAL_ERROR("The image \"%s\" does not contain a palette.\n", path); + + if (png_get_PLTE(png_ptr, info_ptr, &colors, &numColors) != PNG_INFO_PLTE) + FATAL_ERROR("Failed to retrieve palette from \"%s\".\n", path); + + if (numColors > 256) + FATAL_ERROR("Images with more than 256 colors are not supported.\n"); + + palette->numColors = numColors; + for (int i = 0; i < numColors; i++) { + palette->colors[i].red = colors[i].red; + palette->colors[i].green = colors[i].green; + palette->colors[i].blue = colors[i].blue; + } + + palette->bitDepth = png_get_bit_depth(png_ptr, info_ptr); + + png_destroy_read_struct(&png_ptr, &info_ptr, NULL); + + fclose(fp); +} + +void SetPngPalette(png_structp png_ptr, png_infop info_ptr, struct Palette *palette) +{ + png_colorp colors = malloc(palette->numColors * sizeof(png_color)); + + if (colors == NULL) + FATAL_ERROR("Failed to allocate PNG palette.\n"); + + for (int i = 0; i < palette->numColors; i++) { + colors[i].red = palette->colors[i].red; + colors[i].green = palette->colors[i].green; + colors[i].blue = palette->colors[i].blue; + } + + png_set_PLTE(png_ptr, info_ptr, colors, palette->numColors); + + free(colors); +} + +void WritePng(char *path, struct Image *image) +{ + FILE *fp = fopen(path, "wb"); + + if (fp == NULL) + FATAL_ERROR("Failed to open \"%s\" for writing.\n", path); + + png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); + + if (!png_ptr) + FATAL_ERROR("Failed to create PNG write struct.\n"); + + png_infop info_ptr = png_create_info_struct(png_ptr); + + if (!info_ptr) + FATAL_ERROR("Failed to create PNG info struct.\n"); + + if (setjmp(png_jmpbuf(png_ptr))) + FATAL_ERROR("Failed to init I/O for writing \"%s\".\n", path); + + png_init_io(png_ptr, fp); + + if (setjmp(png_jmpbuf(png_ptr))) + FATAL_ERROR("Error writing header for \"%s\".\n", path); + + int color_type = image->hasPalette ? PNG_COLOR_TYPE_PALETTE : PNG_COLOR_TYPE_GRAY; + + png_set_IHDR(png_ptr, info_ptr, image->width, image->height, + image->bitDepth, color_type, PNG_INTERLACE_NONE, + PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); + + if (image->hasPalette) { + SetPngPalette(png_ptr, info_ptr, &image->palette); + + if (image->hasTransparency) { + png_byte trans = 0; + png_set_tRNS(png_ptr, info_ptr, &trans, 1, 0); + } + } + + png_write_info(png_ptr, info_ptr); + + png_bytepp row_pointers = malloc(image->height * sizeof(png_bytep)); + + if (row_pointers == NULL) + FATAL_ERROR("Failed to allocate row pointers.\n"); + + int rowbytes = png_get_rowbytes(png_ptr, info_ptr); + + for (int i = 0; i < image->height; i++) + row_pointers[i] = (png_bytep)(image->pixels + (i * rowbytes)); + + if (setjmp(png_jmpbuf(png_ptr))) + FATAL_ERROR("Error writing \"%s\".\n", path); + + png_write_image(png_ptr, row_pointers); + + if (setjmp(png_jmpbuf(png_ptr))) + FATAL_ERROR("Error ending write of \"%s\".\n", path); + + png_write_end(png_ptr, NULL); + + fclose(fp); + + png_destroy_write_struct(&png_ptr, &info_ptr); + free(row_pointers); +} diff --git a/tools/nitrogfx/convert_png.h b/tools/nitrogfx/convert_png.h new file mode 100644 index 0000000000..caf081b733 --- /dev/null +++ b/tools/nitrogfx/convert_png.h @@ -0,0 +1,12 @@ +// Copyright (c) 2015 YamaArashi + +#ifndef CONVERT_PNG_H +#define CONVERT_PNG_H + +#include "gfx.h" + +void ReadPng(char *path, struct Image *image); +void WritePng(char *path, struct Image *image); +void ReadPngPalette(char *path, struct Palette *palette); + +#endif // CONVERT_PNG_H diff --git a/tools/nitrogfx/font.c b/tools/nitrogfx/font.c new file mode 100644 index 0000000000..f929e30cea --- /dev/null +++ b/tools/nitrogfx/font.c @@ -0,0 +1,489 @@ +// Copyright (c) 2015 YamaArashi + +#include +#include +#include +#include +#include +#include "global.h" +#include "font.h" +#include "gfx.h" +#include "options.h" +#include "util.h" + +unsigned char gFontPalette[][3] = { + {0x90, 0xC8, 0xFF}, // bg (saturated blue that contrasts well with the shadow color) + {0x38, 0x38, 0x38}, // fg (dark grey) + {0xD8, 0xD8, 0xD8}, // shadow (light grey) + {0xFF, 0xFF, 0xFF} // box (white) +}; + +// special palette for DS subscreen font +unsigned char gFontPalette_Subscreen[][3] = { + {0x90, 0xC8, 0xFF}, // bg (saturated blue that contrasts well with the shadow color) + {0xFF, 0xFF, 0xFF}, // fg (white) + {0xD8, 0xD8, 0xD8}, // shadow (light grey) + {0x38, 0x38, 0x38}, // outline (dark grey) +}; + +static void ConvertFromLatinFont(unsigned char *src, unsigned char *dest, unsigned int numRows) +{ + unsigned int srcPixelsOffset = 0; + + for (unsigned int row = 0; row < numRows; row++) { + for (unsigned int column = 0; column < 16; column++) { + for (unsigned int glyphTile = 0; glyphTile < 4; glyphTile++) { + unsigned int pixelsX = (column * 16) + ((glyphTile & 1) * 8); + + for (unsigned int i = 0; i < 8; i++) { + unsigned int pixelsY = (row * 16) + ((glyphTile >> 1) * 8) + i; + unsigned int destPixelsOffset = (pixelsY * 64) + (pixelsX / 4); + + dest[destPixelsOffset] = src[srcPixelsOffset + 1]; + dest[destPixelsOffset + 1] = src[srcPixelsOffset]; + + srcPixelsOffset += 2; + } + } + } + } +} + +static void ConvertToLatinFont(unsigned char *src, unsigned char *dest, unsigned int numRows) +{ + unsigned int destPixelsOffset = 0; + + for (unsigned int row = 0; row < numRows; row++) { + for (unsigned int column = 0; column < 16; column++) { + for (unsigned int glyphTile = 0; glyphTile < 4; glyphTile++) { + unsigned int pixelsX = (column * 16) + ((glyphTile & 1) * 8); + + for (unsigned int i = 0; i < 8; i++) { + unsigned int pixelsY = (row * 16) + ((glyphTile >> 1) * 8) + i; + unsigned int srcPixelsOffset = (pixelsY * 64) + (pixelsX / 4); + + dest[destPixelsOffset] = src[srcPixelsOffset + 1]; + dest[destPixelsOffset + 1] = src[srcPixelsOffset]; + + destPixelsOffset += 2; + } + } + } + } +} + +static void ConvertFromHalfwidthJapaneseFont(unsigned char *src, unsigned char *dest, unsigned int numRows) +{ + for (unsigned int row = 0; row < numRows; row++) { + for (unsigned int column = 0; column < 16; column++) { + unsigned int glyphIndex = (row * 16) + column; + + for (unsigned int glyphTile = 0; glyphTile < 2; glyphTile++) { + unsigned int pixelsX = column * 8; + unsigned int srcPixelsOffset = 512 * (glyphIndex >> 4) + 16 * (glyphIndex & 0xF) + 256 * glyphTile; + + for (unsigned int i = 0; i < 8; i++) { + unsigned int pixelsY = (row * 16) + (glyphTile * 8) + i; + unsigned int destPixelsOffset = (pixelsY * 32) + (pixelsX / 4); + + dest[destPixelsOffset] = src[srcPixelsOffset + 1]; + dest[destPixelsOffset + 1] = src[srcPixelsOffset]; + + srcPixelsOffset += 2; + } + } + } + } +} + +static void ConvertToHalfwidthJapaneseFont(unsigned char *src, unsigned char *dest, unsigned int numRows) +{ + for (unsigned int row = 0; row < numRows; row++) { + for (unsigned int column = 0; column < 16; column++) { + unsigned int glyphIndex = (row * 16) + column; + + for (unsigned int glyphTile = 0; glyphTile < 2; glyphTile++) { + unsigned int pixelsX = column * 8; + unsigned int destPixelsOffset = 512 * (glyphIndex >> 4) + 16 * (glyphIndex & 0xF) + 256 * glyphTile; + + for (unsigned int i = 0; i < 8; i++) { + unsigned int pixelsY = (row * 16) + (glyphTile * 8) + i; + unsigned int srcPixelsOffset = (pixelsY * 32) + (pixelsX / 4); + + dest[destPixelsOffset] = src[srcPixelsOffset + 1]; + dest[destPixelsOffset + 1] = src[srcPixelsOffset]; + + destPixelsOffset += 2; + } + } + } + } +} + +static void ConvertFromFullwidthJapaneseFont(unsigned char *src, unsigned char *dest, unsigned int numRows) +{ + for (unsigned int row = 0; row < numRows; row++) { + for (unsigned int column = 0; column < 16; column++) { + unsigned int glyphIndex = (row * 16) + column; + + for (unsigned int glyphTile = 0; glyphTile < 4; glyphTile++) { + unsigned int pixelsX = (column * 16) + ((glyphTile & 1) * 8); + unsigned int srcPixelsOffset = 512 * (glyphIndex >> 3) + 32 * (glyphIndex & 7) + 256 * (glyphTile >> 1) + 16 * (glyphTile & 1); + + for (unsigned int i = 0; i < 8; i++) { + unsigned int pixelsY = (row * 16) + ((glyphTile >> 1) * 8) + i; + unsigned int destPixelsOffset = (pixelsY * 64) + (pixelsX / 4); + + dest[destPixelsOffset] = src[srcPixelsOffset + 1]; + dest[destPixelsOffset + 1] = src[srcPixelsOffset]; + + srcPixelsOffset += 2; + } + } + } + } +} + +static void ConvertToFullwidthJapaneseFont(unsigned char *src, unsigned char *dest, unsigned int numRows) +{ + for (unsigned int row = 0; row < numRows; row++) { + for (unsigned int column = 0; column < 16; column++) { + unsigned int glyphIndex = (row * 16) + column; + + for (unsigned int glyphTile = 0; glyphTile < 4; glyphTile++) { + unsigned int pixelsX = (column * 16) + ((glyphTile & 1) * 8); + unsigned int destPixelsOffset = 512 * (glyphIndex >> 3) + 32 * (glyphIndex & 7) + 256 * (glyphTile >> 1) + 16 * (glyphTile & 1); + + for (unsigned int i = 0; i < 8; i++) { + unsigned int pixelsY = (row * 16) + ((glyphTile >> 1) * 8) + i; + unsigned int srcPixelsOffset = (pixelsY * 64) + (pixelsX / 4); + + dest[destPixelsOffset] = src[srcPixelsOffset + 1]; + dest[destPixelsOffset + 1] = src[srcPixelsOffset]; + + destPixelsOffset += 2; + } + } + } + } +} + +static void ConvertFromNitroFont(unsigned char *src, unsigned char *dest, unsigned int numRows, struct NtrFontMetadata *metadata) +{ + unsigned int srcPixelsOffset = 0; + unsigned int curGlyph = 0; + + for (unsigned int row = 0; row < numRows; row++) { + for (unsigned int column = 0; column < 16 && curGlyph < metadata->numGlyphs; column++, curGlyph++) { + for (unsigned int glyphTile = 0; glyphTile < 4; glyphTile++) { + unsigned int pixelsX = (column * 16) + ((glyphTile & 1) * 8); + + for (unsigned int i = 0; i < 8; i++) { + unsigned int pixelsY = (row * 16) + ((glyphTile >> 1) * 8) + i; + unsigned int destPixelsOffset = (pixelsY * 64) + (pixelsX / 4); + + dest[destPixelsOffset] = src[srcPixelsOffset + 1]; + dest[destPixelsOffset + 1] = src[srcPixelsOffset]; + + srcPixelsOffset += 2; + } + } + } + } +} + +static void ConvertToNitroFont(unsigned char *src, unsigned char *dest, unsigned int numRows, struct NtrFontMetadata *metadata) +{ + unsigned int destPixelsOffset = 0; + unsigned int curGlyph = 0; + + for (unsigned int row = 0; row < numRows; row++) { + for (unsigned int column = 0; column < 16 && curGlyph < metadata->numGlyphs; column++, curGlyph++) { + for (unsigned int glyphTile = 0; glyphTile < 4; glyphTile++) { + unsigned int pixelsX = (column * 16) + ((glyphTile & 1) * 8); + + for (unsigned int i = 0; i < 8; i++) { + unsigned int pixelsY = (row * 16) + ((glyphTile >> 1) * 8) + i; + unsigned int srcPixelsOffset = (pixelsY * 64) + (pixelsX / 4); + + dest[destPixelsOffset] = src[srcPixelsOffset + 1]; + dest[destPixelsOffset + 1] = src[srcPixelsOffset]; + + destPixelsOffset += 2; + } + } + } + } +} + +static void SetFontPalette(struct Image *image) +{ + image->hasPalette = true; + + image->palette.numColors = 4; + + for (int i = 0; i < image->palette.numColors; i++) { + image->palette.colors[i].red = gFontPalette[i][0]; + image->palette.colors[i].green = gFontPalette[i][1]; + image->palette.colors[i].blue = gFontPalette[i][2]; + } + + image->hasTransparency = false; +} + +static void SetSubscreenFontPalette(struct Image *image) +{ + image->hasPalette = true; + + image->palette.numColors = 4; + + for (int i = 0; i < image->palette.numColors; i++) { + image->palette.colors[i].red = gFontPalette_Subscreen[i][0]; + image->palette.colors[i].green = gFontPalette_Subscreen[i][1]; + image->palette.colors[i].blue = gFontPalette_Subscreen[i][2]; + } + + image->hasTransparency = false; +} + +void ReadLatinFont(char *path, struct Image *image) +{ + int fileSize; + unsigned char *buffer = ReadWholeFile(path, &fileSize); + + int numGlyphs = fileSize / 64; + + if (numGlyphs % 16 != 0) + FATAL_ERROR("The number of glyphs (%d) is not a multiple of 16.\n", numGlyphs); + + int numRows = numGlyphs / 16; + + image->width = 256; + image->height = numRows * 16; + image->bitDepth = 2; + image->pixels = malloc(fileSize); + + if (image->pixels == NULL) + FATAL_ERROR("Failed to allocate memory for font.\n"); + + ConvertFromLatinFont(buffer, image->pixels, numRows); + + free(buffer); + + SetFontPalette(image); +} + +void WriteLatinFont(char *path, struct Image *image) +{ + if (image->width != 256) + FATAL_ERROR("The width of the font image (%d) is not 256.\n", image->width); + + if (image->height % 16 != 0) + FATAL_ERROR("The height of the font image (%d) is not a multiple of 16.\n", image->height); + + int numRows = image->height / 16; + int bufferSize = numRows * 16 * 64; + unsigned char *buffer = malloc(bufferSize); + + if (buffer == NULL) + FATAL_ERROR("Failed to allocate memory for font.\n"); + + ConvertToLatinFont(image->pixels, buffer, numRows); + + WriteWholeFile(path, buffer, bufferSize); + + free(buffer); +} + +void ReadHalfwidthJapaneseFont(char *path, struct Image *image) +{ + int fileSize; + unsigned char *buffer = ReadWholeFile(path, &fileSize); + + int glyphSize = 32; + + if (fileSize % glyphSize != 0) + FATAL_ERROR("The file size (%d) is not a multiple of %d.\n", fileSize, glyphSize); + + int numGlyphs = fileSize / glyphSize; + + if (numGlyphs % 16 != 0) + FATAL_ERROR("The number of glyphs (%d) is not a multiple of 16.\n", numGlyphs); + + int numRows = numGlyphs / 16; + + image->width = 128; + image->height = numRows * 16; + image->bitDepth = 2; + image->pixels = malloc(fileSize); + + if (image->pixels == NULL) + FATAL_ERROR("Failed to allocate memory for font.\n"); + + ConvertFromHalfwidthJapaneseFont(buffer, image->pixels, numRows); + + free(buffer); + + SetFontPalette(image); +} + +void WriteHalfwidthJapaneseFont(char *path, struct Image *image) +{ + if (image->width != 128) + FATAL_ERROR("The width of the font image (%d) is not 128.\n", image->width); + + if (image->height % 16 != 0) + FATAL_ERROR("The height of the font image (%d) is not a multiple of 16.\n", image->height); + + int numRows = image->height / 16; + int bufferSize = numRows * 16 * 32; + unsigned char *buffer = malloc(bufferSize); + + if (buffer == NULL) + FATAL_ERROR("Failed to allocate memory for font.\n"); + + ConvertToHalfwidthJapaneseFont(image->pixels, buffer, numRows); + + WriteWholeFile(path, buffer, bufferSize); + + free(buffer); +} + +void ReadFullwidthJapaneseFont(char *path, struct Image *image) +{ + int fileSize; + unsigned char *buffer = ReadWholeFile(path, &fileSize); + + int numGlyphs = fileSize / 64; + + if (numGlyphs % 16 != 0) + FATAL_ERROR("The number of glyphs (%d) is not a multiple of 16.\n", numGlyphs); + + int numRows = numGlyphs / 16; + + image->width = 256; + image->height = numRows * 16; + image->bitDepth = 2; + image->pixels = malloc(fileSize); + + if (image->pixels == NULL) + FATAL_ERROR("Failed to allocate memory for font.\n"); + + ConvertFromFullwidthJapaneseFont(buffer, image->pixels, numRows); + + free(buffer); + + SetFontPalette(image); +} + +void WriteFullwidthJapaneseFont(char *path, struct Image *image) +{ + if (image->width != 256) + FATAL_ERROR("The width of the font image (%d) is not 256.\n", image->width); + + if (image->height % 16 != 0) + FATAL_ERROR("The height of the font image (%d) is not a multiple of 16.\n", image->height); + + int numRows = image->height / 16; + int bufferSize = numRows * 16 * 64; + unsigned char *buffer = malloc(bufferSize); + + if (buffer == NULL) + FATAL_ERROR("Failed to allocate memory for font.\n"); + + ConvertToFullwidthJapaneseFont(image->pixels, buffer, numRows); + + WriteWholeFile(path, buffer, bufferSize); + + free(buffer); +} + +static inline uint32_t ReadLittleEndianWord(unsigned char *buffer, size_t start) +{ + return (buffer[start + 3] << 24) + | (buffer[start + 2] << 16) + | (buffer[start + 1] << 8) + | (buffer[start]); +} + +void ReadNtrFont(char *path, struct Image *image, struct NtrFontMetadata *metadata, bool useSubscreenPalette) +{ + int filesize; + unsigned char *buffer = ReadWholeFile(path, &filesize); + + metadata->size = ReadLittleEndianWord(buffer, 0x00); + metadata->widthTableOffset = ReadLittleEndianWord(buffer, 0x04); + metadata->numGlyphs = ReadLittleEndianWord(buffer, 0x08); + metadata->maxWidth = buffer[0x0C]; + metadata->maxHeight = buffer[0x0D]; + metadata->glyphWidth = buffer[0x0E]; + metadata->glyphHeight = buffer[0x0F]; + + int numRows = (metadata->numGlyphs + 15) / 16; // Round up to next multiple of 16. + + metadata->glyphWidthTable = malloc(metadata->numGlyphs); + memcpy(metadata->glyphWidthTable, buffer + metadata->widthTableOffset, metadata->numGlyphs); + + image->width = 256; + image->height = numRows * 16; + image->bitDepth = 2; + image->pixels = malloc(filesize); + + if (image->pixels == NULL) + FATAL_ERROR("Failed to allocate memory for font.\n"); + + ConvertFromNitroFont(buffer + metadata->size, image->pixels, numRows, metadata); + + free(buffer); + + if (useSubscreenPalette) + SetSubscreenFontPalette(image); + else + SetFontPalette(image); +} + +void WriteNtrFont(char *path, struct Image *image, struct NtrFontMetadata *metadata) +{ + if (image->width != 256) + FATAL_ERROR("The width of the font image (%d) is not 256.\n", image->width); + + if (image->height % 16 != 0) + FATAL_ERROR("The height of the font image (%d) is not a multiple of 16.\n", image->height); + + int numRows = image->height / 16; + int bufferSize = metadata->widthTableOffset + metadata->numGlyphs; + unsigned char *buffer = malloc(bufferSize); + + if (buffer == NULL) + FATAL_ERROR("Failed to allocate memory for font.\n"); + + buffer[0x00] = (metadata->size & 0x000000FF); + buffer[0x01] = (metadata->size & 0x0000FF00) >> 8; + buffer[0x02] = (metadata->size & 0x00FF0000) >> 16; + buffer[0x03] = (metadata->size & 0xFF000000) >> 24; + buffer[0x04] = (metadata->widthTableOffset & 0x000000FF); + buffer[0x05] = (metadata->widthTableOffset & 0x0000FF00) >> 8; + buffer[0x06] = (metadata->widthTableOffset & 0x00FF0000) >> 16; + buffer[0x07] = (metadata->widthTableOffset & 0xFF000000) >> 24; + buffer[0x08] = (metadata->numGlyphs & 0x000000FF); + buffer[0x09] = (metadata->numGlyphs & 0x0000FF00) >> 8; + buffer[0x0A] = (metadata->numGlyphs & 0x00FF0000) >> 16; + buffer[0x0B] = (metadata->numGlyphs & 0xFF000000) >> 24; + buffer[0x0C] = metadata->maxWidth; + buffer[0x0D] = metadata->maxHeight; + buffer[0x0E] = metadata->glyphWidth; + buffer[0x0F] = metadata->glyphHeight; + + ConvertToNitroFont(image->pixels, buffer + metadata->size, numRows, metadata); + memcpy(buffer + metadata->widthTableOffset, metadata->glyphWidthTable, metadata->numGlyphs); + + WriteWholeFile(path, buffer, bufferSize); + + free(buffer); +} + +void FreeNtrFontMetadata(struct NtrFontMetadata *metadata) +{ + free(metadata->glyphWidthTable); + free(metadata); +} diff --git a/tools/nitrogfx/font.h b/tools/nitrogfx/font.h new file mode 100644 index 0000000000..70dca08088 --- /dev/null +++ b/tools/nitrogfx/font.h @@ -0,0 +1,20 @@ +// Copyright (c) 2015 YamaArashi + +#ifndef FONT_H +#define FONT_H + +#include +#include "gfx.h" +#include "options.h" + +void ReadLatinFont(char *path, struct Image *image); +void WriteLatinFont(char *path, struct Image *image); +void ReadHalfwidthJapaneseFont(char *path, struct Image *image); +void WriteHalfwidthJapaneseFont(char *path, struct Image *image); +void ReadFullwidthJapaneseFont(char *path, struct Image *image); +void WriteFullwidthJapaneseFont(char *path, struct Image *image); +void ReadNtrFont(char *path, struct Image *image, struct NtrFontMetadata *metadata, bool useSubscreenPalette); +void WriteNtrFont(char *path, struct Image *image, struct NtrFontMetadata *metadata); +void FreeNtrFontMetadata(struct NtrFontMetadata *metadata); + +#endif // FONT_H diff --git a/tools/nitrogfx/gfx.c b/tools/nitrogfx/gfx.c new file mode 100644 index 0000000000..e5a2a4b017 --- /dev/null +++ b/tools/nitrogfx/gfx.c @@ -0,0 +1,2204 @@ +// Copyright (c) 2015 YamaArashi, 2021-2024 red031000 + +#include +#include +#include +#include +#include +#include "global.h" +#include "gfx.h" +#include "json.h" +#include "util.h" + +static unsigned int FindNitroDataBlock(const unsigned char *data, const char *ident, unsigned int fileSize, unsigned int *blockSize_out) +{ + unsigned int offset = 0x10; + while (offset < fileSize) + { + unsigned int blockSize = data[offset + 4] | (data[offset + 5] << 8) | (data[offset + 6] << 16) | (data[offset + 7] << 24); + if (offset + blockSize > fileSize) + { + FATAL_ERROR("corrupted NTR file"); + } + if (memcmp(data + offset, ident, 4) == 0) + { + *blockSize_out = blockSize; + return offset; + } + offset += blockSize; + } + return -1u; +} + +#define GET_GBA_PAL_RED(x) (((x) >> 0) & 0x1F) +#define GET_GBA_PAL_GREEN(x) (((x) >> 5) & 0x1F) +#define GET_GBA_PAL_BLUE(x) (((x) >> 10) & 0x1F) + +#define SET_GBA_PAL(r, g, b) (((b) << 10) | ((g) << 5) | (r)) + +#define UPCONVERT_BIT_DEPTH(x) (((x) * 255) / 31) + +#define DOWNCONVERT_BIT_DEPTH(x) ((x) / 8) + +static void AdvanceTilePosition(int *tilesSoFar, int *rowsSoFar, int *chunkStartX, int *chunkStartY, int chunksWide, int colsPerChunk, int rowsPerChunk) +{ + (*tilesSoFar)++; + if (*tilesSoFar == colsPerChunk) { + *tilesSoFar = 0; + (*rowsSoFar)++; + if (*rowsSoFar == rowsPerChunk) { + *rowsSoFar = 0; + (*chunkStartX)++; + if (*chunkStartX == chunksWide) { + *chunkStartX = 0; + (*chunkStartY)++; + } + } + } +} + +static void ConvertFromTiles1Bpp(unsigned char *src, unsigned char *dest, int numTiles, int chunksWide, int colsPerChunk, int rowsPerChunk, bool invertColors) +{ + int tilesSoFar = 0; + int rowsSoFar = 0; + int chunkStartX = 0; + int chunkStartY = 0; + int pitch = chunksWide * colsPerChunk; + + for (int i = 0; i < numTiles; i++) { + for (int j = 0; j < 8; j++) { + int idxComponentY = (chunkStartY * rowsPerChunk + rowsSoFar) * 8 + j; + int idxComponentX = chunkStartX * colsPerChunk + tilesSoFar; + unsigned char srcPixelOctet = *src++; + unsigned char *destPixelOctet = &dest[idxComponentY * pitch + idxComponentX]; + + for (int k = 0; k < 8; k++) { + *destPixelOctet <<= 1; + *destPixelOctet |= (srcPixelOctet & 1) ^ invertColors; + srcPixelOctet >>= 1; + } + } + + AdvanceTilePosition(&tilesSoFar, &rowsSoFar, &chunkStartX, &chunkStartY, chunksWide, colsPerChunk, rowsPerChunk); + } +} + +static void ConvertFromTiles4Bpp(unsigned char *src, unsigned char *dest, int numTiles, int chunksWide, int colsPerChunk, int rowsPerChunk, bool invertColors) +{ + int tilesSoFar = 0; + int rowsSoFar = 0; + int chunkStartX = 0; + int chunkStartY = 0; + int pitch = (chunksWide * colsPerChunk) * 4; + + for (int i = 0; i < numTiles; i++) { + for (int j = 0; j < 8; j++) { + int idxComponentY = (chunkStartY * rowsPerChunk + rowsSoFar) * 8 + j; + + for (int k = 0; k < 4; k++) { + int idxComponentX = (chunkStartX * colsPerChunk + tilesSoFar) * 4 + k; + unsigned char srcPixelPair = *src++; + unsigned char leftPixel = srcPixelPair & 0xF; + unsigned char rightPixel = srcPixelPair >> 4; + + if (invertColors) { + leftPixel = 15 - leftPixel; + rightPixel = 15 - rightPixel; + } + + dest[idxComponentY * pitch + idxComponentX] = (leftPixel << 4) | rightPixel; + } + } + + AdvanceTilePosition(&tilesSoFar, &rowsSoFar, &chunkStartX, &chunkStartY, chunksWide, colsPerChunk, rowsPerChunk); + } +} + +static void ConvertFromTiles4BppCell(unsigned char *src, unsigned char *dest, int oamWidth, int oamHeight, int imageWidth, int startX, int startY, bool hFlip, bool vFlip, bool hvFlip, bool toPNG) +{ + int tilesSoFar = 0; + int rowsSoFar = 0; + int chunkStartX = 0; + int chunkStartY = 0; + int pitch = imageWidth / 2; + + for (int i = 0; i < oamHeight * oamWidth; i++) { + for (int j = 0; j < 8; j++) { + int idxComponentY = (chunkStartY + rowsSoFar) * 8 + j + startY; + if (vFlip) + { + idxComponentY = (rowsSoFar + oamHeight - chunkStartY) * 8 + j + startY; + } + if (hvFlip) + { + idxComponentY += 8 - j * 2; + } + + for (int k = 0; k < 4; k++) { + int idxComponentX = (chunkStartX + tilesSoFar) * 4 + k + startX/2; + + if (hFlip) + { + idxComponentX = (tilesSoFar + oamWidth - chunkStartX) * 4 + - k + startX/2 - 1; + + unsigned char srcPixelPair = *src; + unsigned char leftPixel = srcPixelPair & 0xF; + unsigned char rightPixel = srcPixelPair >> 4; + + if (toPNG) + { + srcPixelPair = *src++; + leftPixel = srcPixelPair & 0xF; + rightPixel = srcPixelPair >> 4; + + dest[idxComponentY * pitch + idxComponentX] = (leftPixel << 4) | rightPixel; + } + else + { + srcPixelPair = src[idxComponentY * pitch + idxComponentX]; + leftPixel = srcPixelPair & 0xF; + rightPixel = srcPixelPair >> 4; + + *dest++ = (leftPixel << 4) | rightPixel; + } + } + else + { + if (toPNG) + { + dest[idxComponentY * pitch + idxComponentX] = *src++; + } + else + { + *dest++ = src[idxComponentY * pitch + idxComponentX]; + } + } + } + } + + AdvanceTilePosition(&tilesSoFar, &rowsSoFar, &chunkStartX, &chunkStartY, oamWidth, 1, 1); + } +} + +static uint32_t ConvertFromScanned4Bpp(unsigned char *src, unsigned char *dest, int fileSize, bool invertColours, bool scanFrontToBack) +{ + uint32_t encValue = 0; + if (scanFrontToBack) { + encValue = (src[1] << 8) | src[0]; + for (int i = 0; i < fileSize; i += 2) + { + uint16_t val = src[i] | (src[i + 1] << 8); + val ^= (encValue & 0xFFFF); + src[i] = val; + src[i + 1] = val >> 8; + encValue = encValue * 1103515245; + encValue = encValue + 24691; + } + } else { + encValue = (src[fileSize - 1] << 8) | src[fileSize - 2]; + for (int i = fileSize; i > 0; i -= 2) + { + uint16_t val = (src[i - 1] << 8) | src[i - 2]; + val ^= (encValue & 0xFFFF); + src[i - 1] = (val >> 8); + src[i - 2] = val; + encValue = encValue * 1103515245; + encValue = encValue + 24691; + } + } + for (int i = 0; i < fileSize; i++) + { + unsigned char srcPixelPair = src[i]; + unsigned char leftPixel = srcPixelPair & 0xF; + unsigned char rightPixel = srcPixelPair >> 4; + + if (invertColours) { + leftPixel = 15 - leftPixel; + rightPixel = 15 - rightPixel; + } + + dest[i] = (leftPixel << 4) | rightPixel; + } + return encValue; +} + +static void ConvertFromTiles8Bpp(unsigned char *src, unsigned char *dest, int numTiles, int chunksWide, int colsPerChunk, int rowsPerChunk, bool invertColors) +{ + int tilesSoFar = 0; + int rowsSoFar = 0; + int chunkStartX = 0; + int chunkStartY = 0; + int pitch = (chunksWide * colsPerChunk) * 8; + + for (int i = 0; i < numTiles; i++) { + for (int j = 0; j < 8; j++) { + int idxComponentY = (chunkStartY * rowsPerChunk + rowsSoFar) * 8 + j; + + for (int k = 0; k < 8; k++) { + int idxComponentX = (chunkStartX * colsPerChunk + tilesSoFar) * 8 + k; + unsigned char srcPixel = *src++; + + if (invertColors) + srcPixel = 255 - srcPixel; + + dest[idxComponentY * pitch + idxComponentX] = srcPixel; + } + } + + AdvanceTilePosition(&tilesSoFar, &rowsSoFar, &chunkStartX, &chunkStartY, chunksWide, colsPerChunk, rowsPerChunk); + } +} + +static void ConvertFromTiles8BppCell(unsigned char *src, unsigned char *dest, int oamWidth, int oamHeight, int imageWidth, int startX, int startY, bool hFlip, bool vFlip, bool hvFlip, bool toPNG) +{ + int tilesSoFar = 0; + int rowsSoFar = 0; + int chunkStartX = 0; + int chunkStartY = 0; + int pitch = imageWidth; + + for (int i = 0; i < oamHeight * oamWidth; i++) { + for (int j = 0; j < 8; j++) { + int idxComponentY = (chunkStartY + rowsSoFar) * 8 + j + startY; + if (vFlip) + { + idxComponentY = (rowsSoFar + oamHeight - chunkStartY) * 8 + j + startY; + } + if (hvFlip) + { + idxComponentY += 8 - j * 2; + } + + for (int k = 0; k < 8; k++) { + int idxComponentX = (chunkStartX + tilesSoFar) * 8 + k + startX; + if (hFlip) + { + idxComponentX = (tilesSoFar + oamWidth - chunkStartX) * 4 + - k + startX; + } + + if (toPNG) + { + dest[idxComponentY * pitch + idxComponentX] = *src++; + } + else + { + *dest++ = src[idxComponentY * pitch + idxComponentX]; + } + } + } + + AdvanceTilePosition(&tilesSoFar, &rowsSoFar, &chunkStartX, &chunkStartY, oamWidth, 1, 1); + } +} + +static uint32_t ConvertFromScanned8Bpp(unsigned char *src, unsigned char *dest, int fileSize, bool invertColours, bool scanFrontToBack) +{ + uint32_t encValue = 0; + if (scanFrontToBack) { + encValue = (src[1] << 8) | src[0]; + for (int i = 0; i < fileSize; i += 2) + { + uint16_t val = src[i] | (src[i + 1] << 8); + val ^= (encValue & 0xFFFF); + src[i] = val; + src[i + 1] = val >> 8; + encValue = encValue * 1103515245; + encValue = encValue + 24691; + } + } else { + encValue = (src[fileSize - 1] << 8) | src[fileSize - 2]; + for (int i = fileSize; i > 0; i -= 2) + { + uint16_t val = (src[i - 1] << 8) | src[i - 2]; + val ^= (encValue & 0xFFFF); + src[i - 1] = (val >> 8); + src[i - 2] = val; + encValue = encValue * 1103515245; + encValue = encValue + 24691; + } + } + for (int i = 0; i < fileSize; i++) + { + unsigned char srcPixel = src[i]; + + if (invertColours) { + srcPixel = 255 - srcPixel; + } + + dest[i] = srcPixel; + } + return encValue; +} + +static void ConvertToTiles1Bpp(unsigned char *src, unsigned char *dest, int numTiles, int chunksWide, int colsPerChunk, int rowsPerChunk, bool invertColors) +{ + int tilesSoFar = 0; + int rowsSoFar = 0; + int chunkStartX = 0; + int chunkStartY = 0; + int pitch = chunksWide * colsPerChunk; + + for (int i = 0; i < numTiles; i++) { + for (int j = 0; j < 8; j++) { + int idxComponentY = (chunkStartY * rowsPerChunk + rowsSoFar) * 8 + j; + int idxComponentX = chunkStartX * colsPerChunk + tilesSoFar; + unsigned char srcPixelOctet = src[idxComponentY * pitch + idxComponentX]; + unsigned char *destPixelOctet = dest++; + + for (int k = 0; k < 8; k++) { + *destPixelOctet <<= 1; + *destPixelOctet |= (srcPixelOctet & 1) ^ invertColors; + srcPixelOctet >>= 1; + } + } + + AdvanceTilePosition(&tilesSoFar, &rowsSoFar, &chunkStartX, &chunkStartY, chunksWide, colsPerChunk, rowsPerChunk); + } +} + +static void ConvertToTiles4Bpp(unsigned char *src, unsigned char *dest, int numTiles, int chunksWide, int colsPerChunk, int rowsPerChunk, bool invertColors) +{ + int tilesSoFar = 0; + int rowsSoFar = 0; + int chunkStartX = 0; + int chunkStartY = 0; + int pitch = (chunksWide * colsPerChunk) * 4; + + for (int i = 0; i < numTiles; i++) { + for (int j = 0; j < 8; j++) { + int idxComponentY = (chunkStartY * rowsPerChunk + rowsSoFar) * 8 + j; + + for (int k = 0; k < 4; k++) { + int idxComponentX = (chunkStartX * colsPerChunk + tilesSoFar) * 4 + k; + unsigned char srcPixelPair = src[idxComponentY * pitch + idxComponentX]; + unsigned char leftPixel = srcPixelPair >> 4; + unsigned char rightPixel = srcPixelPair & 0xF; + + if (invertColors) { + leftPixel = 15 - leftPixel; + rightPixel = 15 - rightPixel; + } + + *dest++ = (rightPixel << 4) | leftPixel; + } + } + + AdvanceTilePosition(&tilesSoFar, &rowsSoFar, &chunkStartX, &chunkStartY, chunksWide, colsPerChunk, rowsPerChunk); + } +} + +static void ConvertToScanned4Bpp(unsigned char *src, unsigned char *dest, int fileSize, bool invertColours, uint32_t encValue, uint32_t scanMode) +{ + for (int i = 0; i < fileSize; i++) + { + unsigned char srcPixelPair = src[i]; + unsigned char leftPixel = srcPixelPair & 0xF; + unsigned char rightPixel = srcPixelPair >> 4; + if (invertColours) { + leftPixel = 15 - leftPixel; + rightPixel = 15 - rightPixel; + } + dest[i] = (leftPixel << 4) | rightPixel; + } + + if (scanMode == 2) { // front to back + for (int i = fileSize - 1; i > 0; i -= 2) + { + uint16_t val = dest[i - 1] | (dest[i] << 8); + encValue = (encValue - 24691) * 4005161829; + val ^= (encValue & 0xFFFF); + dest[i] = (val >> 8); + dest[i - 1] = val; + } + } + else if (scanMode == 1) { + for (int i = 1; i < fileSize; i += 2) + { + uint16_t val = (dest[i] << 8) | dest[i - 1]; + encValue = (encValue - 24691) * 4005161829; + val ^= (encValue & 0xFFFF); + dest[i] = (val >> 8); + dest[i - 1] = val; + } + } +} + +static void ConvertToTiles8Bpp(unsigned char *src, unsigned char *dest, int numTiles, int chunksWide, int colsPerChunk, int rowsPerChunk, bool invertColors) +{ + int tilesSoFar = 0; + int rowsSoFar = 0; + int chunkStartX = 0; + int chunkStartY = 0; + int pitch = (chunksWide * colsPerChunk) * 8; + + for (int i = 0; i < numTiles; i++) { + for (int j = 0; j < 8; j++) { + int idxComponentY = (chunkStartY * rowsPerChunk + rowsSoFar) * 8 + j; + + for (int k = 0; k < 8; k++) { + int idxComponentX = (chunkStartX * colsPerChunk + tilesSoFar) * 8 + k; + unsigned char srcPixel = src[idxComponentY * pitch + idxComponentX]; + + if (invertColors) + srcPixel = 255 - srcPixel; + + *dest++ = srcPixel; + } + } + + AdvanceTilePosition(&tilesSoFar, &rowsSoFar, &chunkStartX, &chunkStartY, chunksWide, colsPerChunk, rowsPerChunk); + } +} + +void ReadImage(char *path, int tilesWide, int bitDepth, int colsPerChunk, int rowsPerChunk, struct Image *image, bool invertColors) +{ + int tileSize = bitDepth * 8; // number of bytes per tile + + int fileSize; + unsigned char *buffer = ReadWholeFile(path, &fileSize); + + int numTiles = fileSize / tileSize; + + int tilesTall = (numTiles + tilesWide - 1) / tilesWide; + + if (tilesWide % colsPerChunk != 0) + FATAL_ERROR("The width in tiles (%d) isn't a multiple of the specified tiles per row (%d)", tilesWide, colsPerChunk); + + if (tilesTall % rowsPerChunk != 0) + FATAL_ERROR("The height in tiles (%d) isn't a multiple of the specified rows per chunk (%d)", tilesTall, rowsPerChunk); + + image->width = tilesWide * 8; + image->height = tilesTall * 8; + image->bitDepth = bitDepth; + image->pixels = calloc(tilesWide * tilesTall, tileSize); + + if (image->pixels == NULL) + FATAL_ERROR("Failed to allocate memory for pixels.\n"); + + int chunksWide = tilesWide / colsPerChunk; // how many chunks side-by-side are needed for the full width of the image + + switch (bitDepth) { + case 1: + ConvertFromTiles1Bpp(buffer, image->pixels, numTiles, chunksWide, colsPerChunk, rowsPerChunk, invertColors); + break; + case 4: + ConvertFromTiles4Bpp(buffer, image->pixels, numTiles, chunksWide, colsPerChunk, rowsPerChunk, invertColors); + break; + case 8: + ConvertFromTiles8Bpp(buffer, image->pixels, numTiles, chunksWide, colsPerChunk, rowsPerChunk, invertColors); + break; + } + + free(buffer); +} + +uint32_t ReadNtrImage(char *path, int tilesWide, int bitDepth, int colsPerChunk, int rowsPerChunk, struct Image *image, bool invertColors, bool scanFrontToBack) +{ + int fileSize; + unsigned char *buffer = ReadWholeFile(path, &fileSize); + + if (memcmp(buffer, "RGCN", 4) != 0) + { + FATAL_ERROR("Not a valid NCGR character file.\n"); + } + + unsigned char *charHeader = buffer + 0x10; + + if (memcmp(charHeader, "RAHC", 4) != 0) + { + FATAL_ERROR("No valid CHAR file after NCLR header.\n"); + } + + bitDepth = bitDepth ? bitDepth : (charHeader[0xC] == 3 ? 4 : 8); + + if (bitDepth == 4) + { + image->palette.numColors = 16; + } + + unsigned char *imageData = charHeader + 0x20; + + bool scanned = charHeader[0x14]; + + int tileSize = bitDepth * 8; // number of bytes per tile + + if (tilesWide == 0) { + tilesWide = ReadS16(charHeader, 0xA); + if (tilesWide < 0) { + tilesWide = 1; + } + } + + int numTiles = ReadS32(charHeader, 0x18) / (64 / (8 / bitDepth)); + + int tilesTall = ReadS16(charHeader, 0x8); + if (tilesTall < 0) + tilesTall = (numTiles + tilesWide - 1) / tilesWide; + + if (tilesWide % colsPerChunk != 0) + FATAL_ERROR("The width in tiles (%d) isn't a multiple of the specified tiles per row (%d)", tilesWide, colsPerChunk); + + if (tilesTall % rowsPerChunk != 0) + FATAL_ERROR("The height in tiles (%d) isn't a multiple of the specified rows per chunk (%d)", tilesTall, rowsPerChunk); + + + image->width = tilesWide * 8; + image->height = tilesTall * 8; + image->bitDepth = bitDepth; + image->pixels = calloc(tilesWide * tilesTall, tileSize); + + if (image->pixels == NULL) + FATAL_ERROR("Failed to allocate memory for pixels.\n"); + + int chunksWide = tilesWide / colsPerChunk; // how many chunks side-by-side are needed for the full width of the image + + uint32_t key = 0; + if (scanned) + { + switch (bitDepth) + { + case 4: + key = ConvertFromScanned4Bpp(imageData, image->pixels, fileSize - 0x30, invertColors, scanFrontToBack); + break; + case 8: + key = ConvertFromScanned8Bpp(imageData, image->pixels, fileSize - 0x30, invertColors, scanFrontToBack); + break; + } + } + else + { + switch (bitDepth) + { + case 4: + ConvertFromTiles4Bpp(imageData, image->pixels, numTiles, chunksWide, colsPerChunk, rowsPerChunk, + invertColors); + break; + case 8: + ConvertFromTiles8Bpp(imageData, image->pixels, numTiles, chunksWide, colsPerChunk, rowsPerChunk, + invertColors); + break; + } + } + + free(buffer); + return key; +} + +void ApplyCellsToImage(char *cellFilePath, struct Image *image, bool toPNG) +{ + char *cellFileExtension = GetFileExtension(cellFilePath); + if (cellFileExtension == NULL) + { + FATAL_ERROR("NULL cell file path\n"); + } + struct JsonToCellOptions *options; + + if (strcmp(cellFileExtension, "NCER") == 0) + { + options = malloc(sizeof(struct JsonToCellOptions)); + ReadNtrCell(cellFilePath, options); + } + else + { + if (strcmp(cellFileExtension, "json") == 0) + { + options = ParseNCERJson(cellFilePath); + } + else + { + FATAL_ERROR("Incompatible cell file type\n"); + } + } + + int outputHeight = 0; + int outputWidth = 0; + int numTiles = 0; + + for (int i = 0; i < options->cellCount; i++) + { + if (options->cells[i]->oamCount == 0) + { + continue; + } + int cellHeight = 0; + int cellWidth = 0; + if (options->cells[i]->attributes.boundingRect) + { + cellHeight = options->cells[i]->maxY - options->cells[i]->minY + 1; + cellWidth = options->cells[i]->maxX - options->cells[i]->minX + 1; + } + else + { + FATAL_ERROR("No bounding rectangle. Incompatible NCER\n"); + } + + outputHeight += cellHeight; + if (outputWidth < cellWidth) + { + outputWidth = cellWidth; + } + if (i) + { + outputHeight++; + } + } + + if (outputHeight == 0 || outputWidth == 0) + { + FATAL_ERROR("No cells. Incompatible NCER\n"); + } + unsigned char *newPixels = malloc(outputHeight * outputWidth); + memset(newPixels, 255, outputHeight * outputWidth); + + int scanHeight = 0; + int maxTile = 0; + int tileMask[outputHeight * outputWidth]; // check for unused (starting) tiles + memset(tileMask, 0, outputHeight * outputWidth * sizeof(int)); + for (int i = 0; i < options->cellCount; i++) + { + if (options->cells[i]->oamCount == 0) + { + continue; + } + if (i) + { + scanHeight++; + } + int cellHeight = options->cells[i]->maxY - options->cells[i]->minY + 1; + int uniqueOAMs = options->cells[i]->oamCount; + + for (int j = 0; j < options->cells[i]->oamCount; j++) + { + int oamHeight = 0; + int oamWidth = 0; + int oamSize = options->cells[i]->oam[j].attr1.Size; + switch (options->cells[i]->oam[j].attr0.Shape) + { + case 0: + oamHeight = 1 << oamSize; + oamWidth = oamHeight; + break; + case 1: + switch (oamSize) + { + case 0: + oamHeight = 1; + oamWidth = 2; + break; + case 1: + oamHeight = 1; + oamWidth = 4; + break; + case 2: + oamHeight = 2; + oamWidth = 4; + break; + case 3: + oamHeight = 4; + oamWidth = 8; + break; + } + break; + case 2: + switch (oamSize) + { + case 0: + oamHeight = 2; + oamWidth = 1; + break; + case 1: + oamHeight = 4; + oamWidth = 1; + break; + case 2: + oamHeight = 4; + oamWidth = 2; + break; + case 3: + oamHeight = 8; + oamWidth = 4; + break; + } + break; + } + + int x = options->cells[i]->oam[j].attr1.XCoordinate; // 8 bits + if ((x & 0x80) != 0) + { + x = (x | ~0xFF); + } + int y = options->cells[i]->oam[j].attr0.YCoordinate; // 7 bits + if ((y & 0x40) != 0) + { + y = (y | ~0x7F); + } + x -= options->cells[i]->minX; + y -= options->cells[i]->minY; + + int pixelOffset = 0; + switch (options->mappingType) + { + case 0: + pixelOffset = options->cells[i]->oam[j].attr2.CharName * 32; + maxTile = options->cells[i]->oam[j].attr2.CharName + oamHeight * oamWidth; + if (maxTile > numTiles) + { + numTiles = maxTile; + } + if (tileMask[options->cells[i]->oam[j].attr2.CharName]) + { + uniqueOAMs--; + continue; + } + tileMask[options->cells[i]->oam[j].attr2.CharName]++; + break; + case 1: + pixelOffset = options->cells[i]->oam[j].attr2.CharName * 64 + (scanHeight - i) * outputWidth / 2; + numTiles += oamHeight * oamWidth; + break; + case 2: + pixelOffset = options->cells[i]->oam[j].attr2.CharName * 128; + maxTile = options->cells[i]->oam[j].attr2.CharName * 4 + oamHeight * oamWidth; + if (maxTile > numTiles) + { + numTiles = maxTile; + } + if (tileMask[options->cells[i]->oam[j].attr2.CharName]) + { + uniqueOAMs--; + continue; + } + tileMask[options->cells[i]->oam[j].attr2.CharName]++; + break; + } + bool rotationScaling = options->cells[i]->oam[j].attr1.RotationScaling; + bool hFlip = options->cells[i]->attributes.hFlip && rotationScaling; + bool vFlip = options->cells[i]->attributes.vFlip && rotationScaling; + bool hvFlip = options->cells[i]->attributes.hvFlip && rotationScaling; + + switch (image->bitDepth) + { + case 4: + if (toPNG) + { + ConvertFromTiles4BppCell(image->pixels + pixelOffset, newPixels, oamWidth, oamHeight, outputWidth, x, y + scanHeight, hFlip, vFlip, hvFlip, true); + } + else + { + ConvertFromTiles4BppCell(image->pixels, newPixels + pixelOffset, oamWidth, oamHeight, outputWidth, x, y + scanHeight, hFlip, vFlip, hvFlip, false); + } + break; + case 8: + pixelOffset *= 2; + if (toPNG) + { + ConvertFromTiles8BppCell(image->pixels + pixelOffset, newPixels, oamWidth, oamHeight, outputWidth, x, y + scanHeight, hFlip, vFlip, hvFlip, true); + } + else + { + ConvertFromTiles8BppCell(image->pixels, newPixels + pixelOffset, oamWidth, oamHeight, outputWidth, x, y + scanHeight, hFlip, vFlip, hvFlip, false); + } + break; + } + } + + if (uniqueOAMs == 0) + { + outputHeight -= cellHeight; + if (i) + { + scanHeight--; + outputHeight--; + } + } + else + { + scanHeight += cellHeight; + } + } + + free(image->pixels); + if (toPNG) + { + image->pixels = newPixels; + image->height = outputHeight; + image->width = outputWidth; + } + else + { + image->pixels = newPixels; + image->height = numTiles * 8; + image->width = 8; + } + FreeNCERCell(options); +} + +void WriteImage(char *path, int numTiles, int bitDepth, int colsPerChunk, int rowsPerChunk, struct Image *image, bool invertColors) +{ + int tileSize = bitDepth * 8; // number of bytes per tile + + if (image->width % 8 != 0) + FATAL_ERROR("The width in pixels (%d) isn't a multiple of 8.\n", image->width); + + if (image->height % 8 != 0) + FATAL_ERROR("The height in pixels (%d) isn't a multiple of 8.\n", image->height); + + int tilesWide = image->width / 8; // how many tiles wide the image is + int tilesTall = image->height / 8; // how many tiles tall the image is + + if (tilesWide % colsPerChunk != 0) + FATAL_ERROR("The width in tiles (%d) isn't a multiple of the specified tiles per row (%d)", tilesWide, colsPerChunk); + + if (tilesTall % rowsPerChunk != 0) + FATAL_ERROR("The height in tiles (%d) isn't a multiple of the specified rows per chunk (%d)", tilesTall, rowsPerChunk); + + int maxNumTiles = tilesWide * tilesTall; + + if (numTiles == 0) + numTiles = maxNumTiles; + else if (numTiles > maxNumTiles) + FATAL_ERROR("The specified number of tiles (%d) is greater than the maximum possible value (%d).\n", numTiles, maxNumTiles); + + int bufferSize = numTiles * tileSize; + unsigned char *buffer = malloc(bufferSize); + + if (buffer == NULL) + FATAL_ERROR("Failed to allocate memory for pixels.\n"); + + int chunksWide = tilesWide / colsPerChunk; // how many chunks side-by-side are needed for the full width of the image + + switch (bitDepth) { + case 1: + ConvertToTiles1Bpp(image->pixels, buffer, numTiles, chunksWide, colsPerChunk, rowsPerChunk, invertColors); + break; + case 4: + ConvertToTiles4Bpp(image->pixels, buffer, numTiles, chunksWide, colsPerChunk, rowsPerChunk, invertColors); + break; + case 8: + ConvertToTiles8Bpp(image->pixels, buffer, numTiles, chunksWide, colsPerChunk, rowsPerChunk, invertColors); + break; + } + + WriteWholeFile(path, buffer, bufferSize); + + free(buffer); +} + +void WriteNtrImage(char *path, int numTiles, int bitDepth, int colsPerChunk, int rowsPerChunk, struct Image *image, + bool invertColors, bool clobberSize, bool byteOrder, bool version101, bool sopc, bool vram, uint32_t scanMode, + uint32_t mappingType, uint32_t key, bool wrongSize) +{ + FILE *fp = fopen(path, "wb"); + + if (fp == NULL) + FATAL_ERROR("Failed to open \"%s\" for writing.\n", path); + + int tileSize = bitDepth * 8; // number of bytes per tile + + if (image->width % 8 != 0) + FATAL_ERROR("The width in pixels (%d) isn't a multiple of 8.\n", image->width); + + if (image->height % 8 != 0) + FATAL_ERROR("The height in pixels (%d) isn't a multiple of 8.\n", image->height); + + int tilesWide = image->width / 8; // how many tiles wide the image is + int tilesTall = image->height / 8; // how many tiles tall the image is + + if (tilesWide % colsPerChunk != 0) + FATAL_ERROR("The width in tiles (%d) isn't a multiple of the specified tiles per row (%d)", tilesWide, colsPerChunk); + + if (tilesTall % rowsPerChunk != 0) + FATAL_ERROR("The height in tiles (%d) isn't a multiple of the specified rows per chunk (%d)", tilesTall, rowsPerChunk); + + int maxNumTiles = tilesWide * tilesTall; + + if (numTiles == 0) + numTiles = maxNumTiles; + else if (numTiles > maxNumTiles) + FATAL_ERROR("The specified number of tiles (%d) is greater than the maximum possible value (%d).\n", numTiles, maxNumTiles); + + int bufferSize = numTiles * tileSize; + unsigned char *pixelBuffer = malloc(bufferSize); + + if (pixelBuffer == NULL) + FATAL_ERROR("Failed to allocate memory for pixels.\n"); + + int chunksWide = tilesWide / colsPerChunk; // how many chunks side-by-side are needed for the full width of the image + + if (scanMode) + { + switch (bitDepth) + { + case 4: + ConvertToScanned4Bpp(image->pixels, pixelBuffer, bufferSize, invertColors, key, scanMode); + break; + case 8: + FATAL_ERROR("8Bpp not supported yet.\n"); + break; + } + } + else + { + switch (bitDepth) + { + case 4: + ConvertToTiles4Bpp(image->pixels, pixelBuffer, numTiles, chunksWide, colsPerChunk, rowsPerChunk, + invertColors); + break; + case 8: + ConvertToTiles8Bpp(image->pixels, pixelBuffer, numTiles, chunksWide, colsPerChunk, rowsPerChunk, + invertColors); + break; + } + } + + WriteGenericNtrHeader(fp, "RGCN", bufferSize + (sopc ? 0x30 : 0x20) + (wrongSize ? -8 : 0), byteOrder, version101, sopc ? 2 : 1); + + unsigned char charHeader[0x20] = { 0x52, 0x41, 0x48, 0x43, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00 }; + + charHeader[4] = (bufferSize + 0x20 + (wrongSize ? -8 : 0)) & 0xFF; + charHeader[5] = ((bufferSize + 0x20 + (wrongSize ? -8 : 0)) >> 8) & 0xFF; + charHeader[6] = ((bufferSize + 0x20 + (wrongSize ? -8 : 0)) >> 16) & 0xFF; + charHeader[7] = ((bufferSize + 0x20 + (wrongSize ? -8 : 0)) >> 24) & 0xFF; + + if (!clobberSize) + { + charHeader[8] = tilesTall & 0xFF; + charHeader[9] = (tilesTall >> 8) & 0xFF; + + charHeader[10] = tilesWide & 0xFF; + charHeader[11] = (tilesWide >> 8) & 0xFF; + } + else + { + charHeader[8] = 0xFF; + charHeader[9] = 0xFF; + charHeader[10] = 0xFF; + charHeader[11] = 0xFF; + + charHeader[16] = 0x10; //size clobbering implies mapping type is some variant of 1d - *should* have a mapping type that's not 0 + + if (mappingType == 0) + { + mappingType = 32; // if not specified assume that it is 32k + } + } + + charHeader[12] = bitDepth == 4 ? 3 : 4; + + if (mappingType != 0) { + uint32_t val = 0; + switch (mappingType) { + case 32: + val = 0; + break; + case 64: + val = 0x10; + break; + case 128: + val = 0x20; + break; + case 256: + val = 0x30; + break; + default: + FATAL_ERROR("Invalid mapping type %d\n", mappingType); + break; + } + + charHeader[18] = val; + } + + if (scanMode) + { + charHeader[20] = 1; //implies BMP + } + + if (vram) + { + charHeader[21] = 1; //implies VRAM transfer + } + + charHeader[24] = bufferSize & 0xFF; + charHeader[25] = (bufferSize >> 8) & 0xFF; + charHeader[26] = (bufferSize >> 16) & 0xFF; + charHeader[27] = (bufferSize >> 24) & 0xFF; + + fwrite(charHeader, 1, 0x20, fp); + + fwrite(pixelBuffer, 1, bufferSize, fp); + + if (sopc) + { + unsigned char sopcBuffer[0x10] = { 0x53, 0x4F, 0x50, 0x43, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; + + sopcBuffer[12] = tilesWide & 0xFF; + sopcBuffer[13] = (tilesWide >> 8) & 0xFF; + + sopcBuffer[14] = tilesTall & 0xFF; + sopcBuffer[15] = (tilesTall >> 8) & 0xFF; + + fwrite(sopcBuffer, 1, 0x10, fp); + } + + free(pixelBuffer); + fclose(fp); +} + +void FreeImage(struct Image *image) +{ + free(image->pixels); + image->pixels = NULL; +} + +void ReadGbaPalette(char *path, struct Palette *palette) +{ + int fileSize; + unsigned char *data = ReadWholeFile(path, &fileSize); + + if (fileSize % 2 != 0) + FATAL_ERROR("The file size (%d) is not a multiple of 2.\n", fileSize); + + palette->numColors = fileSize / 2; + + for (int i = 0; i < palette->numColors; i++) { + uint16_t paletteEntry = (data[i * 2 + 1] << 8) | data[i * 2]; + palette->colors[i].red = UPCONVERT_BIT_DEPTH(GET_GBA_PAL_RED(paletteEntry)); + palette->colors[i].green = UPCONVERT_BIT_DEPTH(GET_GBA_PAL_GREEN(paletteEntry)); + palette->colors[i].blue = UPCONVERT_BIT_DEPTH(GET_GBA_PAL_BLUE(paletteEntry)); + } + + free(data); +} + +void ReadNtrPalette(char *path, struct Palette *palette, int bitdepth, int palIndex, bool inverted) +{ + int fileSize; + unsigned char *data = ReadWholeFile(path, &fileSize); + + if (memcmp(data, "RLCN", 4) != 0 && memcmp(data, "RPCN", 4) != 0) //NCLR / NCPR + { + FATAL_ERROR("Not a valid NCLR or NCPR palette file.\n"); + } + + unsigned char *paletteHeader = data + 0x10; + + if (memcmp(paletteHeader, "TTLP", 4) != 0) + { + FATAL_ERROR("No valid PLTT file after NCLR header.\n"); + } + + if ((fileSize - 0x28) % 2 != 0) + FATAL_ERROR("The file size (%d) is not a multiple of 2.\n", fileSize); + + palette->bitDepth = paletteHeader[0x8] == 3 ? 4 : 8; + + bitdepth = bitdepth ? bitdepth : palette->bitDepth; + + size_t paletteSize = (paletteHeader[0x10]) | (paletteHeader[0x11] << 8) | (paletteHeader[0x12] << 16) | (paletteHeader[0x13] << 24); + if (inverted) paletteSize = 0x200 - paletteSize; + if (palIndex == 0) { + palette->numColors = paletteSize / 2; + } else { + palette->numColors = bitdepth == 4 ? 16 : 256; //remove header and divide by 2 + --palIndex; + } + + unsigned char *paletteData = paletteHeader + 0x18; + + for (int i = 0; i < 256; i++) + { + if (i < palette->numColors) + { + uint16_t paletteEntry = (paletteData[(32 * palIndex) + i * 2 + 1] << 8) | paletteData[(32 * palIndex) + i * 2]; + palette->colors[i].red = UPCONVERT_BIT_DEPTH(GET_GBA_PAL_RED(paletteEntry)); + palette->colors[i].green = UPCONVERT_BIT_DEPTH(GET_GBA_PAL_GREEN(paletteEntry)); + palette->colors[i].blue = UPCONVERT_BIT_DEPTH(GET_GBA_PAL_BLUE(paletteEntry)); + } + else + { + palette->colors[i].red = 0; + palette->colors[i].green = 0; + palette->colors[i].blue = 0; + } + } + + free(data); +} + +void WriteGbaPalette(char *path, struct Palette *palette) +{ + FILE *fp = fopen(path, "wb"); + + if (fp == NULL) + FATAL_ERROR("Failed to open \"%s\" for writing.\n", path); + + for (int i = 0; i < palette->numColors; i++) { + unsigned char red = DOWNCONVERT_BIT_DEPTH(palette->colors[i].red); + unsigned char green = DOWNCONVERT_BIT_DEPTH(palette->colors[i].green); + unsigned char blue = DOWNCONVERT_BIT_DEPTH(palette->colors[i].blue); + + uint16_t paletteEntry = SET_GBA_PAL(red, green, blue); + + fputc(paletteEntry & 0xFF, fp); + fputc(paletteEntry >> 8, fp); + } + + fclose(fp); +} + +void WriteNtrPalette(char *path, struct Palette *palette, bool ncpr, bool ir, int bitdepth, bool pad, int compNum, bool pcmp, bool inverted) +{ + FILE *fp = fopen(path, "wb"); + + if (fp == NULL) + FATAL_ERROR("Failed to open \"%s\" for writing.\n", path); + + int colourNum = pad ? 256 : palette->numColors; + + uint32_t size = colourNum * 2; //todo check if there's a better way to detect :/ + uint32_t extSize = size + (ncpr ? 0x10 : 0x18); + + int numSections = 1; + int pcmpColorNum = 0; + uint32_t pcmpSize = 0; + if (pcmp) + { + pcmpColorNum = colourNum / (bitdepth == 4 ? 16 : 256); + if (pcmpColorNum == 0) { + FATAL_ERROR("colourNum=%d palette->bitDepth=%d\n", colourNum, bitdepth); + } + pcmpSize = 16 + pcmpColorNum * 2; + ++numSections; + } + + //NCLR header + WriteGenericNtrHeader(fp, (ncpr ? "RPCN" : "RLCN"), extSize + pcmpSize, !ncpr, false, numSections); + + unsigned char palHeader[0x18] = + { + 0x54, 0x54, 0x4C, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00 + }; + + //section size + palHeader[4] = extSize & 0xFF; + palHeader[5] = (extSize >> 8) & 0xFF; + palHeader[6] = (extSize >> 16) & 0xFF; + palHeader[7] = (extSize >> 24) & 0xFF; + + if (!palette->bitDepth) + palette->bitDepth = 4; + + bitdepth = bitdepth ? bitdepth : palette->bitDepth; + + //bit depth + palHeader[8] = bitdepth == 4 ? 0x03: 0x04; + + if (compNum) + { + palHeader[10] = compNum; //assuming this is an indicator of compression, literally no docs for it though + } + + //size + int colorSize = inverted ? 0x200 - size : size; + palHeader[16] = colorSize & 0xFF; + palHeader[17] = (colorSize >> 8) & 0xFF; + palHeader[18] = (colorSize >> 16) & 0xFF; + palHeader[19] = (colorSize >> 24) & 0xFF; + + fwrite(palHeader, 1, 0x18, fp); + + unsigned char * colours = malloc(colourNum * 2); + //palette data + for (int i = 0; i < colourNum; i++) + { + if (i < palette->numColors) + { + unsigned char red = DOWNCONVERT_BIT_DEPTH(palette->colors[i].red); + unsigned char green = DOWNCONVERT_BIT_DEPTH(palette->colors[i].green); + unsigned char blue = DOWNCONVERT_BIT_DEPTH(palette->colors[i].blue); + + uint16_t paletteEntry = SET_GBA_PAL(red, green, blue); + + colours[i * 2] = paletteEntry & 0xFF; + colours[i * 2 + 1] = paletteEntry >> 8; + } + else + { + colours[i * 2] = 0x00; + colours[i * 2 + 1] = 0x00; + } + } + + if (ir) + { + colours[colourNum * 2 - 2] = 'I'; + colours[colourNum * 2 - 1] = 'R'; + } + + fwrite(colours, 1, colourNum * 2, fp); + free(colours); + + if (pcmp) + { + uint8_t pcmp_header[16] = {0x50, 0x4D, 0x43, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xEF, 0xBE, 0x08, 0x00, 0x00, 0x00}; + pcmp_header[4] = pcmpSize & 0xFF; + pcmp_header[5] = (pcmpSize >> 8) & 0xFF; + pcmp_header[6] = (pcmpSize >> 16) & 0xFF; + pcmp_header[7] = (pcmpSize >> 24) & 0xFF; + pcmp_header[8] = pcmpColorNum & 0xFF; + pcmp_header[9] = (pcmpColorNum >> 8) & 0xFF; + fwrite(pcmp_header, 1, 16, fp); + + uint8_t *pcmp_data = malloc(2 * pcmpColorNum); + if (pcmp_data == NULL) + { + FATAL_ERROR("failed to alloc pcmp_data\n"); + } + for (int i = 0; i < pcmpColorNum; ++i) { + pcmp_data[i * 2] = i & 0xFF; + pcmp_data[i * 2 + 1] = (i >> 8) & 0xFF; + } + fwrite(pcmp_data, 1, pcmpColorNum * 2, fp); + free(pcmp_data); + } + + fclose(fp); +} + +void ReadNtrCell_CEBK(unsigned char * restrict data, unsigned int blockOffset, unsigned int blockSize, struct JsonToCellOptions *options) +{ + options->cellCount = data[blockOffset + 0x8] | (data[blockOffset + 0x9] << 8); + options->extended = data[blockOffset + 0xA] == 1; + + int vramTransferOffset = (data[blockOffset + 0x14] | data[blockOffset + 0x15] << 8); + options->vramTransferEnabled = vramTransferOffset > 0; + /*if (!options->extended) + { + //in theory not extended should be implemented, however not 100% sure + FATAL_ERROR("Don't know how to deal with not extended yet, bug red031000.\n"); + }*/ + + options->mappingType = data[blockOffset + 0x10]; + + options->cells = malloc(sizeof(struct Cell *) * options->cellCount); + int celSize = options->extended ? 0x10 : 0x8; + + for (int i = 0; i < options->cellCount; i++) + { + int offset = blockOffset + 0x20 + (i * celSize); + if (offset + celSize > blockOffset + blockSize) { + FATAL_ERROR("corrupted CEBK block\n"); + } + options->cells[i] = malloc(sizeof(struct Cell)); + options->cells[i]->oamCount = data[offset] | (data[offset + 1] << 8); + short cellAttrs = data[offset + 2] | (data[offset + 3] << 8); + options->cells[i]->attributes.hFlip = (cellAttrs >> 8) & 1; + options->cells[i]->attributes.vFlip = (cellAttrs >> 9) & 1; + options->cells[i]->attributes.hvFlip = (cellAttrs >> 10) & 1; + options->cells[i]->attributes.boundingRect = (cellAttrs >> 11) & 1; + options->cells[i]->attributes.boundingSphereRadius = cellAttrs & 0x3F; + + if (options->extended) + { + options->cells[i]->maxX = data[offset + 8] | (data[offset + 9] << 8); + options->cells[i]->maxY = data[offset + 10] | (data[offset + 11] << 8); + options->cells[i]->minX = data[offset + 12] | (data[offset + 13] << 8); + options->cells[i]->minY = data[offset + 14] | (data[offset + 15] << 8); + } + } + + int offset = blockOffset + 0x20 + (options->cellCount * celSize); + for (int i = 0; i < options->cellCount; i++) + { + options->cells[i]->oam = malloc(sizeof(struct OAM) * options->cells[i]->oamCount); + for (int j = 0; j < options->cells[i]->oamCount; j++) + { + //Attr0 + + //bits 0-7 Y coordinate + options->cells[i]->oam[j].attr0.YCoordinate = data[offset]; + + //bit 8 rotation + options->cells[i]->oam[j].attr0.Rotation = data[offset + 1] & 1; + + //bit 9 Obj Size (if rotation) or Obj Disable (if not rotation) + options->cells[i]->oam[j].attr0.SizeDisable = (data[offset + 1] >> 1) & 1; + + //bits 10-11 Obj Mode + options->cells[i]->oam[j].attr0.Mode = (data[offset + 1] >> 2) & 3; + + //bit 12 Obj Mosaic + options->cells[i]->oam[j].attr0.Mosaic = (data[offset + 1] >> 4) & 1; + + //bit 13 Colours + options->cells[i]->oam[j].attr0.Colours = ((data[offset + 1] >> 5) & 1) == 0 ? 16 : 256; + + //bits 14-15 Obj Shape + options->cells[i]->oam[j].attr0.Shape = (data[offset + 1] >> 6) & 3; + + //Attr1 + + //bits 0-8 X coordinate + options->cells[i]->oam[j].attr1.XCoordinate = data[offset + 2] | ((data[offset + 3] & 1) << 8); + + //bits 9-13 Rotation and scaling (if rotation) bit 12 Horizontal flip, bit 13 Vertical flip (if not rotation) + options->cells[i]->oam[j].attr1.RotationScaling = (data[offset + 3] >> 1) & 0x1F; + + //bits 14-15 Obj Size + options->cells[i]->oam[j].attr1.Size = (data[offset + 3] >> 6) & 3; + + //Attr2 + + //bits 0-9 Character Name? + options->cells[i]->oam[j].attr2.CharName = data[offset + 4] | ((data[offset + 5] & 3) << 8); + + //bits 10-11 Priority + options->cells[i]->oam[j].attr2.Priority = (data[offset + 5] >> 2) & 3; + + //bits 12-15 Palette Number + options->cells[i]->oam[j].attr2.Palette = (data[offset + 5] >> 4) & 0xF; + + offset += 6; + } + } + + if (options->vramTransferEnabled) + { + offset = blockOffset + 0x08 + vramTransferOffset; + + // first 2 dwords are max size and offset, offset *should* always be 0x08 since the transfer data list immediately follows this + options->vramTransferMaxSize = data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16) | (data[offset + 3] << 24); + offset += 0x08; + + // read 1 VRAM transfer data block for each cell (this is an assumption based on the NCERs I looked at) + options->transferData = malloc(sizeof(struct CellVramTransferData *) * options->cellCount); + for (int idx = 0; idx < options->cellCount; idx++) + { + options->transferData[idx] = malloc(sizeof(struct CellVramTransferData)); + options->transferData[idx]->sourceDataOffset = data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16) | (data[offset + 3] << 24); + options->transferData[idx]->size = data[offset + 4] | (data[offset + 5] << 8) | (data[offset + 6] << 16) | (data[offset + 7] << 24); + offset += 8; + } + } +} + +void ReadNtrCell_LABL(unsigned char * restrict data, unsigned int blockOffset, unsigned int blockSize, struct JsonToCellOptions *options) +{ + int count = 0; + unsigned int textStart = blockOffset + 8; + while (textStart < blockOffset + blockSize) + { + unsigned int labelOffset = data[textStart] | (data[textStart + 1] << 8) | (data[textStart + 2] << 16) | (data[textStart + 3] << 24); + if (labelOffset > blockSize) + { + break; + } + else { + ++count; + textStart += 4; + } + } + options->labelCount = count; + options->labels = malloc(sizeof(char *) * count); + for (int i = 0; i < count; ++i) + { + int offset = textStart + (data[blockOffset + 4 * i + 8] | (data[blockOffset + 4 * i + 9] << 8) | (data[blockOffset + 4 * i + 10] << 16) | (data[blockOffset + 4 * i + 11] << 24)); + if (offset > blockOffset + blockSize) + { + FATAL_ERROR("corrupted LABL block\n"); + } + unsigned long slen = strnlen((char *)data + offset, blockSize - offset); + options->labels[i] = malloc(slen + 1); + strncpy(options->labels[i], (char *)data + offset, slen + 1); + } +} + +void ReadNtrCell(char *path, struct JsonToCellOptions *options) +{ + int fileSize; + unsigned char *data = ReadWholeFile(path, &fileSize); + unsigned int offset = 0x10; + + if (memcmp(data, "RECN", 4) != 0) //NCER + { + FATAL_ERROR("Not a valid NCER cell file.\n"); + } + + options->labelEnabled = false; + + unsigned int blockSize; + offset = FindNitroDataBlock(data, "KBEC", fileSize, &blockSize); + if (offset != -1u) + { + ReadNtrCell_CEBK(data, offset, blockSize, options); + } + else { + FATAL_ERROR("missing CEBK block"); + } + offset = FindNitroDataBlock(data, "LBAL", fileSize, &blockSize); + if (offset != -1u) + { + options->labelEnabled = true; + ReadNtrCell_LABL(data, offset, blockSize, options); + } + + free(data); +} + +void WriteNtrCell(char *path, struct JsonToCellOptions *options) +{ + FILE *fp = fopen(path, "wb"); + + if (fp == NULL) + FATAL_ERROR("Failed to open \"%s\" for writing.\n", path); + + int iterNum = (options->extended ? 0x10 : 0x8); + + // KBEC base size: 0x08 per bank, or 0x10 per extended bank + unsigned int kbecSize = options->cellCount * (options->extended ? 0x10 : 0x08); + // if VRAM transfer is enabled, add 0x08 for the header and 0x08 for each cell + if (options->vramTransferEnabled) + { + kbecSize += 0x08 + (0x08 * options->cellCount); + } + // add 0x06 for number of OAMs - can be more than 1 + for (int idx = 0; idx < options->cellCount * iterNum; idx += iterNum) + { + kbecSize += options->cells[idx / iterNum]->oamCount * 0x06; + } + + // KBEC size is padded to be 4-byte aligned + kbecSize += kbecSize % 4; + + unsigned int totalSize = (options->labelEnabled > 0 ? 0x34 : 0x20) + kbecSize; + + if (options->labelEnabled) + { + for (int j = 0; j < options->labelCount; j++) + { + totalSize += (unsigned)strlen(options->labels[j]) + 5; //strlen + terminator + pointer + } + } + + WriteGenericNtrHeader(fp, "RECN", totalSize, true, false, options->labelEnabled ? 3 : 1); + + unsigned char KBECHeader[0x20] = + { + 0x4B, 0x42, 0x45, 0x43, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + KBECHeader[8] = options->cellCount; //cell count + + if (options->extended) + { + KBECHeader[10] = 1; //extended + } + + KBECHeader[4] = (kbecSize + 0x20) & 0xFF; //size + KBECHeader[5] = (kbecSize + 0x20) >> 8; //unlikely to be more than 16 bits, but there are 32 allocated, change if necessary + + KBECHeader[16] = (options->mappingType & 0xFF); //not possible to be more than 8 bits, though 32 are allocated + + // offset to VRAM transfer data within KBEC section (offset from KBEC start + 0x08) + if (options->vramTransferEnabled) + { + unsigned int vramTransferLength = 0x08 + (0x08 * options->cellCount); + unsigned int vramTransferOffset = (kbecSize + 0x20) - vramTransferLength - 0x08; + KBECHeader[20] = vramTransferOffset & 0xFF; + KBECHeader[21] = (vramTransferOffset >> 8) & 0xFF; + KBECHeader[22] = (vramTransferOffset >> 16) & 0xFF; + KBECHeader[23] = (vramTransferOffset >> 24) & 0xFF; + } + + fwrite(KBECHeader, 1, 0x20, fp); + + unsigned char *KBECContents = malloc(kbecSize); + + memset(KBECContents, 0, kbecSize); + + /*if (!options->extended) + { + //in theory not extended should be implemented, however not 100% sure + FATAL_ERROR("Don't know how to deal with not extended yet, bug red031000.\n"); + }*/ + + int i; + int totalOam = 0; + for (i = 0; i < options->cellCount * iterNum; i += iterNum) + { + KBECContents[i] = options->cells[i / iterNum]->oamCount; //number of OAM entries + short cellAttrs = (options->cells[i / iterNum]->attributes.hFlip << 8) | (options->cells[i / iterNum]->attributes.vFlip << 9) + | (options->cells[i / iterNum]->attributes.hvFlip << 10) | (options->cells[i / iterNum]->attributes.boundingRect << 11) + | (options->cells[i / iterNum]->attributes.boundingSphereRadius & 0x3F); + KBECContents[i + 2] = cellAttrs & 0xff; //cell attributes + KBECContents[i + 3] = cellAttrs >> 8; + KBECContents[i + 4] = (totalOam * 6) & 0xff; //pointer to OAM data + KBECContents[i + 5] = (totalOam * 6) >> 8; //unlikely to be more than 16 bits, but there are 32 allocated, change if necessary + if (options->extended) + { + KBECContents[i + 8] = options->cells[i / iterNum]->maxX & 0xff; //maxX + KBECContents[i + 9] = options->cells[i / iterNum]->maxX >> 8; + KBECContents[i + 10] = options->cells[i / iterNum]->maxY & 0xff; //maxY + KBECContents[i + 11] = options->cells[i / iterNum]->maxY >> 8; + KBECContents[i + 12] = options->cells[i / iterNum]->minX & 0xff; //minX + KBECContents[i + 13] = options->cells[i / iterNum]->minX >> 8; + KBECContents[i + 14] = options->cells[i / iterNum]->minY & 0xff; //minY + KBECContents[i + 15] = options->cells[i / iterNum]->minY >> 8; + } + totalOam += options->cells[i / iterNum]->oamCount; + } + + //OAM data + + int offset = i; + for (int j = 0; j < options->cellCount; j++) + { + for (int k = 0; k < options->cells[j]->oamCount; k++) + { + //Attr0 + + //bits 0-7 Y coordinate + KBECContents[offset] = options->cells[j]->oam[k].attr0.YCoordinate & 0xff; + + //bit 8 rotation + KBECContents[offset + 1] = options->cells[j]->oam[k].attr0.Rotation; + + //bit 9 Obj Size (if rotation) or Obj Disable (if not rotation) + KBECContents[offset + 1] |= options->cells[j]->oam[k].attr0.SizeDisable << 1; + + //bits 10-11 Obj Mode + KBECContents[offset + 1] |= options->cells[j]->oam[k].attr0.Mode << 2; + + //bit 12 Obj Mosaic + KBECContents[offset + 1] |= options->cells[j]->oam[k].attr0.Mosaic << 4; + + //bit 13 Colours + KBECContents[offset + 1] |= (options->cells[j]->oam[k].attr0.Colours == 16 ? 0 : 1) << 5; + + //bits 14-15 Obj Shape + KBECContents[offset + 1] |= options->cells[j]->oam[k].attr0.Shape << 6; + + //Attr1 + + //bits 0-8 X coordinate + KBECContents[offset + 2] = options->cells[j]->oam[k].attr1.XCoordinate & 0xff; + KBECContents[offset + 3] = options->cells[j]->oam[k].attr1.XCoordinate >> 8; + + //bits 9-13 Rotation and scaling (if rotation) bit 12 Horizontal flip, bit 13 Vertical flip (if not rotation) + KBECContents[offset + 3] |= options->cells[j]->oam[k].attr1.RotationScaling << 1; + + //bits 14-15 Obj Size + KBECContents[offset + 3] |= options->cells[j]->oam[k].attr1.Size << 6; + + //Attr2 + + //bits 0-9 Character Name? + KBECContents[offset + 4] = options->cells[j]->oam[k].attr2.CharName & 0xff; + KBECContents[offset + 5] = options->cells[j]->oam[k].attr2.CharName >> 8; + + //bits 10-11 Priority + KBECContents[offset + 5] |= options->cells[j]->oam[k].attr2.Priority << 2; + + //bits 12-15 Palette Number + KBECContents[offset + 5] |= options->cells[j]->oam[k].attr2.Palette << 4; + + offset += 6; + } + } + + // VRAM transfer data + if (options->vramTransferEnabled) + { + // max transfer size + fixed offset 0x08 + KBECContents[offset] = options->vramTransferMaxSize & 0xFF; + KBECContents[offset + 1] = (options->vramTransferMaxSize >> 8) & 0xFF; + KBECContents[offset + 2] = (options->vramTransferMaxSize >> 16) & 0xFF; + KBECContents[offset + 3] = (options->vramTransferMaxSize >> 24) & 0xFF; + + KBECContents[offset + 4] = 0x08; + + offset += 8; + + // write a VRAM transfer block for each cell + for (int idx = 0; idx < options->cellCount; idx++) + { + // offset + KBECContents[offset] = options->transferData[idx]->sourceDataOffset & 0xFF; + KBECContents[offset + 1] = (options->transferData[idx]->sourceDataOffset >> 8) & 0xFF; + KBECContents[offset + 2] = (options->transferData[idx]->sourceDataOffset >> 16) & 0xFF; + KBECContents[offset + 3] = (options->transferData[idx]->sourceDataOffset >> 24) & 0xFF; + + // size + KBECContents[offset + 4] = options->transferData[idx]->size & 0xFF; + KBECContents[offset + 5] = (options->transferData[idx]->size >> 8) & 0xFF; + KBECContents[offset + 6] = (options->transferData[idx]->size >> 16) & 0xFF; + KBECContents[offset + 7] = (options->transferData[idx]->size >> 24) & 0xFF; + offset += 8; + } + } + + fwrite(KBECContents, 1, kbecSize, fp); + + free(KBECContents); + + if (options->labelEnabled) + { + unsigned int lablSize = 8; + for (int j = 0; j < options->labelCount; j++) + { + lablSize += (unsigned)strlen(options->labels[j]) + 5; + } + + unsigned char *labl = malloc(lablSize); + + memset(labl, 0, lablSize); + + strcpy((char *) labl, "LBAL"); + labl[4] = lablSize & 0xff; + labl[5] = lablSize >> 8; + + unsigned int position = 0; + + i = 0; + for (int j = 0; j < options->labelCount; j++) + { + labl[i + 8] = position & 0xff; + labl[i + 9] = position >> 8; + + position += (unsigned)strlen(options->labels[j]) + 1; + i += 4; + } + + for (int j = 0; j < options->labelCount; j++) + { + strcpy((char *) (labl + (i + 8)), options->labels[j]); + i += (int)strlen(options->labels[j]) + 1; + } + + fwrite(labl, 1, lablSize, fp); + + free(labl); + + unsigned char txeu[0xc] = {0x54, 0x58, 0x45, 0x55, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + + fwrite(txeu, 1, 0xc, fp); + } + + fclose(fp); +} + +void WriteNtrScreen(char *path, struct JsonToScreenOptions *options) +{ + FILE *fp = fopen(path, "wb"); + + if (fp == NULL) + FATAL_ERROR("Failed to open \"%s\" for writing.\n", path); + + int totalSize = options->width * options->height * 2 + 0x14; + + WriteGenericNtrHeader(fp, "RCSN", totalSize, true, false, 1); + + unsigned char NSCRHeader[0x14] = { 0x4E, 0x52, 0x43, 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00 }; + + NSCRHeader[0x4] = totalSize & 0xff; + NSCRHeader[0x5] = (totalSize >> 8) & 0xff; + NSCRHeader[0x6] = (totalSize >> 16) & 0xff; + NSCRHeader[0x7] = totalSize >> 24; + + NSCRHeader[0x8] = (options->width * 8) & 0xff; + NSCRHeader[0x9] = (options->width * 8) >> 8; + + NSCRHeader[0xA] = (options->height * 8) & 0xff; + NSCRHeader[0xB] = (options->height * 8) >> 8; + + NSCRHeader[0xC] = options->bitdepth == 4 ? 0 : 1; + + NSCRHeader[0x10] = (totalSize - 0x14) & 0xff; + NSCRHeader[0x11] = ((totalSize - 0x14) >> 8) & 0xff; + NSCRHeader[0x12] = ((totalSize - 0x14) >> 16) & 0xff; + NSCRHeader[0x13] = (totalSize - 0x14) >> 24; + + fwrite(NSCRHeader, 1, 0x14, fp); + + fwrite(options->data, 1, totalSize - 0x14, fp); + + fclose(fp); +} + +void ReadNtrAnimation(char *path, struct JsonToAnimationOptions *options) +{ + int fileSize; + unsigned char *data = ReadWholeFile(path, &fileSize); + + if (memcmp(data, "RNAN", 4) != 0 && memcmp(data, "RAMN", 4) != 0) //NANR/NMAR + { + FATAL_ERROR("Not a valid NANR/NMAR animation file.\n"); + } + + options->labelEnabled = data[0xE] != 1; + + if (memcmp(data + 0x10, "KNBA", 4) != 0 ) //ABNK + { + FATAL_ERROR("Not a valid ABNK animation file.\n"); + } + + options->sequenceCount = data[0x18] | (data[0x19] << 8); + options->frameCount = data[0x1A] | (data[0x1B] << 8); + + options->sequenceData = malloc(sizeof(struct SequenceData *) * options->sequenceCount); + + for (int i = 0; i < options->sequenceCount; i++) + { + options->sequenceData[i] = malloc(sizeof(struct SequenceData)); + } + + int offset = 0x30; + + unsigned int *frameOffsets = malloc(sizeof(unsigned int) * options->sequenceCount); + + for (int i = 0; i < options->sequenceCount; i++, offset += 0x10) + { + options->sequenceData[i]->frameCount = data[offset] | (data[offset + 1] << 8); + options->sequenceData[i]->loopStartFrame = data[offset + 2] | (data[offset + 3] << 8); + options->sequenceData[i]->animationElement = data[offset + 4] | (data[offset + 5] << 8); + options->sequenceData[i]->animationType = data[offset + 6] | (data[offset + 7] << 8); + options->sequenceData[i]->playbackMode = data[offset + 8] | (data[offset + 9] << 8) | (data[offset + 10] << 16) | (data[offset + 11] << 24); + frameOffsets[i] = data[offset + 12] | (data[offset + 13] << 8) | (data[offset + 14] << 16) | (data[offset + 15] << 24); + + options->sequenceData[i]->frameData = malloc(sizeof(struct FrameData *) * options->sequenceData[i]->frameCount); + for (int j = 0; j < options->sequenceData[i]->frameCount; j++) + { + options->sequenceData[i]->frameData[j] = malloc(sizeof(struct FrameData)); + } + } + + int *resultOffsets = malloc(sizeof(int) * options->frameCount); + memset(resultOffsets, -1, sizeof(int) * options->frameCount); + + for (int i = 0; i < options->sequenceCount; i++) + { + for (int j = 0; j < options->sequenceData[i]->frameCount; j++) + { + int frameOffset = offset + frameOffsets[i] + j * 0x8; + options->sequenceData[i]->frameData[j]->resultOffset = data[frameOffset] | (data[frameOffset + 1] << 8) | (data[frameOffset + 2] << 16) | (data[frameOffset + 3] << 24); + options->sequenceData[i]->frameData[j]->frameDelay = data[frameOffset + 4] | (data[frameOffset + 5] << 8); + //0xBEEF + + //the following is messy + bool present = false; + //check for offset in array + for (int k = 0; k < options->frameCount; k++) + { + if (resultOffsets[k] == options->sequenceData[i]->frameData[j]->resultOffset) + { + options->sequenceData[i]->frameData[j]->resultId = k; + present = true; + break; + } + } + + //add data if not present + if (!present) + { + for (int k = 0; i < options->frameCount; k++) + { + if (resultOffsets[k] == -1) + { + options->sequenceData[i]->frameData[j]->resultId = k; + resultOffsets[k] = options->sequenceData[i]->frameData[j]->resultOffset; + break; + } + } + } + } + } + + free(frameOffsets); + + offset = 0x18 + (data[0x24] | (data[0x25] << 8) | (data[0x26] << 16) | (data[0x27] << 24)); //start of animation results + + int k; + + for (k = 0; k < options->frameCount; k++) + { + if (resultOffsets[k] == -1) + break; + } + options->resultCount = k; + + free(resultOffsets); + + options->animationResults = malloc(sizeof(struct AnimationResults *) * options->resultCount); + + for (int i = 0; i < options->resultCount; i++) + { + options->animationResults[i] = malloc(sizeof(struct AnimationResults)); + } + + // store the animationElement of the corresponding sequence as this result's resultType + for (int i = 0; i < options->sequenceCount; i++) + { + for (int j = 0; j < options->sequenceData[i]->frameCount; j++) + { + options->animationResults[options->sequenceData[i]->frameData[j]->resultId]->resultType = options->sequenceData[i]->animationElement; + } + } + + int resultOffset = 0; + int lastSequence = 0; + for (int i = 0; i < options->resultCount; i++) + { + // find the earliest sequence matching this animation result, + // and add padding if the sequence changes + the total offset is not 4-byte aligned. + bool found = false; + for (int j = 0; j < options->sequenceCount; j++) + { + for (int k = 0; k < options->sequenceData[j]->frameCount; k++) + { + if (options->sequenceData[j]->frameData[k]->resultId == i) + { + if (lastSequence != j) + { + lastSequence = j; + if (resultOffset % 4 != 0) + { + resultOffset += 0x2; + offset += 0x2; + } + } + found = true; + break; + } + } + if (found) break; + } + switch (options->animationResults[i]->resultType) + { + case 0: //index + options->animationResults[i]->index = data[offset] | (data[offset + 1] << 8); + resultOffset += 0x2; + offset += 0x2; + break; + + case 1: //SRT + options->animationResults[i]->dataSrt.index = data[offset] | (data[offset + 1] << 8); + options->animationResults[i]->dataSrt.rotation = data[offset + 2] | (data[offset + 3] << 8); + options->animationResults[i]->dataSrt.scaleX = data[offset + 4] | (data[offset + 5] << 8) | (data[offset + 6] << 16) | (data[offset + 7] << 24); + options->animationResults[i]->dataSrt.scaleY = data[offset + 8] | (data[offset + 9] << 8) | (data[offset + 10] << 16) | (data[offset + 11] << 24); + options->animationResults[i]->dataSrt.positionX = data[offset + 12] | (data[offset + 13] << 8); + options->animationResults[i]->dataSrt.positionY = data[offset + 14] | (data[offset + 15] << 8); + resultOffset += 0x10; + offset += 0x10; + break; + + case 2: //T + options->animationResults[i]->dataT.index = data[offset] | (data[offset + 1] << 8); + options->animationResults[i]->dataT.positionX = data[offset + 4] | (data[offset + 5] << 8); + options->animationResults[i]->dataT.positionY = data[offset + 6] | (data[offset + 7] << 8); + resultOffset += 0x8; + offset += 0x8; + break; + } + } + + // add any missed padding from the final frame before processing labels + if (offset % 4 != 0) offset += 2; + + if (options->labelEnabled) + { + options->labelCount = options->sequenceCount; //*should* be the same + options->labels = malloc(sizeof(char *) * options->labelCount); + offset += 0x8 + options->labelCount * 0x4; //skip to label data + for (int i = 0; i < options->labelCount; i++) + { + options->labels[i] = malloc(strlen((char *)data + offset) + 1); + strcpy(options->labels[i], (char *)data + offset); + offset += strlen((char *)data + offset) + 1; + } + } + + free(data); +} + +void WriteNtrAnimation(char *path, struct JsonToAnimationOptions *options) +{ + FILE *fp = fopen(path, "wb"); + + if (fp == NULL) + FATAL_ERROR("Failed to open \"%s\" for writing.\n", path); + + unsigned int totalSize = 0x20 + options->sequenceCount * 0x10 + options->frameCount * 0x8; + + for (int i = 0; i < options->resultCount; i++) + { + if (options->animationResults[i]->resultType == 0) + totalSize += 0x2; + else if (options->animationResults[i]->resultType == 1) + totalSize += 0x10; + else if (options->animationResults[i]->resultType == 2) + totalSize += 0x8; + } + + // foreach sequence, need to check whether padding is applied for its results + // then add 0x02 to totalSize if padding exists. + // padding exists if the animation results for that sequence are not 4-byte aligned. + // also flag the last result for the sequence with `padded` to save having to redo this same step later. + int *usedResults = malloc(sizeof(int) * options->frameCount); + memset(usedResults, -1, sizeof(int) * options->frameCount); + for (int i = 0; i < options->sequenceCount; i++) + { + int sequenceLen = 0; + int resultIndex = 0; + int lastNewResultIndex = -1; + for (int j = 0; j < options->sequenceData[i]->frameCount; j++) + { + // check if the result has already been used + bool isUsed = false; + for (resultIndex = 0; resultIndex < options->resultCount; resultIndex++) + { + if (usedResults[resultIndex] == options->sequenceData[i]->frameData[j]->resultId) + { + isUsed = true; + break; + } + + // if not already used, add it to the list + if (usedResults[resultIndex] == -1) + { + usedResults[resultIndex] = options->sequenceData[i]->frameData[j]->resultId; + lastNewResultIndex = options->sequenceData[i]->frameData[j]->resultId; + break; + } + } + + // if not already used, add it to the result size for the sequence + if (!isUsed) + { + if (options->animationResults[resultIndex]->resultType == 0) + sequenceLen += 0x2; + else if (options->animationResults[resultIndex]->resultType == 1) + sequenceLen += 0x10; + else if (options->animationResults[resultIndex]->resultType == 2) + sequenceLen += 0x8; + } + } + if (sequenceLen % 4 != 0 && lastNewResultIndex != -1) + { + totalSize += 0x02; + // mark the last new animationResult index for the sequence as padded, this saves needing to check this again later + options->animationResults[lastNewResultIndex]->padded = true; + } + } + + free(usedResults); + + unsigned int KNBASize = totalSize; + + if (options->labelEnabled) + { + totalSize += options->multiCell ? 0x8 : 0x14; + for (int j = 0; j < options->labelCount; j++) + { + totalSize += (unsigned)strlen(options->labels[j]) + 5; //strlen + terminator + pointer + } + } + + WriteGenericNtrHeader(fp, options->multiCell ? "RAMN" : "RNAN", totalSize, true, false, options->labelEnabled ? (options->multiCell ? 2 : 3) : 1); + + unsigned char KBNAHeader[0x20] = + { + 0x4B, 0x4E, 0x42, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + KBNAHeader[4] = KNBASize & 0xff; + KBNAHeader[5] = (KNBASize >> 8) & 0xff; + KBNAHeader[6] = (KNBASize >> 16) & 0xff; + KBNAHeader[7] = KNBASize >> 24; + + KBNAHeader[8] = options->sequenceCount & 0xff; + KBNAHeader[9] = options->sequenceCount >> 8; + + KBNAHeader[10] = options->frameCount & 0xff; + KBNAHeader[11] = options->frameCount >> 8; + + unsigned int frameOffset = 0x18 + options->sequenceCount * 0x10; + + KBNAHeader[16] = frameOffset & 0xff; + KBNAHeader[17] = (frameOffset >> 8) & 0xff; + KBNAHeader[18] = (frameOffset >> 16) & 0xff; + KBNAHeader[19] = frameOffset >> 24; + + unsigned int resultsOffset = frameOffset + options->frameCount * 0x8; + + KBNAHeader[20] = resultsOffset & 0xff; + KBNAHeader[21] = (resultsOffset >> 8) & 0xff; + KBNAHeader[22] = (resultsOffset >> 16) & 0xff; + KBNAHeader[23] = resultsOffset >> 24; + + fwrite(KBNAHeader, 1, 0x20, fp); + + int contentsSize = KNBASize - 0x20; + unsigned char *KBNAContents = malloc(contentsSize); + + int i; + int framePtrCounter = 0; + for (i = 0; i < options->sequenceCount * 0x10; i += 0x10) + { + KBNAContents[i] = options->sequenceData[i / 0x10]->frameCount & 0xff; + KBNAContents[i + 1] = options->sequenceData[i / 0x10]->frameCount >> 8; + KBNAContents[i + 2] = options->sequenceData[i / 0x10]->loopStartFrame & 0xff; + KBNAContents[i + 3] = options->sequenceData[i / 0x10]->loopStartFrame >> 8; + KBNAContents[i + 4] = options->sequenceData[i / 0x10]->animationElement & 0xff; + KBNAContents[i + 5] = (options->sequenceData[i / 0x10]->animationElement >> 8) & 0xff; + KBNAContents[i + 6] = options->sequenceData[i / 0x10]->animationType & 0xff; + KBNAContents[i + 7] = (options->sequenceData[i / 0x10]->animationType >> 8) & 0xff; + KBNAContents[i + 8] = options->sequenceData[i / 0x10]->playbackMode & 0xff; + KBNAContents[i + 9] = (options->sequenceData[i / 0x10]->playbackMode >> 8) & 0xff; + KBNAContents[i + 10] = (options->sequenceData[i / 0x10]->playbackMode >> 16) & 0xff; + KBNAContents[i + 11] = options->sequenceData[i / 0x10]->playbackMode >> 24; + KBNAContents[i + 12] = framePtrCounter & 0xff; + KBNAContents[i + 13] = (framePtrCounter >> 8) & 0xff; + KBNAContents[i + 14] = (framePtrCounter >> 16) & 0xff; + KBNAContents[i + 15] = framePtrCounter >> 24; + framePtrCounter += options->sequenceData[i / 0x10]->frameCount * 8; + } + + int j; + int m; + for (j = i, m = 0; m < options->sequenceCount; m++) + { + for (int k = 0; k < options->sequenceData[m]->frameCount; k++) { + int resPtr = 0; + for (int l = 0; l < options->sequenceData[m]->frameData[k]->resultId; l++) { + if (options->animationResults[l]->resultType == 0) + resPtr += 0x2; + else if (options->animationResults[l]->resultType == 1) + resPtr += 0x10; + else if (options->animationResults[l]->resultType == 2) + resPtr += 0x8; + + if (options->animationResults[l]->padded) resPtr += 0x02; + } + KBNAContents[j + (k * 8)] = resPtr & 0xff; + KBNAContents[j + (k * 8) + 1] = (resPtr >> 8) & 0xff; + KBNAContents[j + (k * 8) + 2] = (resPtr >> 16) & 0xff; + KBNAContents[j + (k * 8) + 3] = resPtr >> 24; + KBNAContents[j + (k * 8) + 4] = options->sequenceData[m]->frameData[k]->frameDelay & 0xff; + KBNAContents[j + (k * 8) + 5] = options->sequenceData[m]->frameData[k]->frameDelay >> 8; + KBNAContents[j + (k * 8) + 6] = 0xEF; + KBNAContents[j + (k * 8) + 7] = 0xBE; + } + j += options->sequenceData[m]->frameCount * 8; + } + + int resPtrCounter = j; + for (int k = 0; k < options->resultCount; k++) + { + switch (options->animationResults[k]->resultType) + { + case 0: + KBNAContents[resPtrCounter] = options->animationResults[k]->index & 0xff; + KBNAContents[resPtrCounter + 1] = options->animationResults[k]->index >> 8; + resPtrCounter += 0x2; + break; + + case 1: + KBNAContents[resPtrCounter] = options->animationResults[k]->dataSrt.index & 0xff; + KBNAContents[resPtrCounter + 1] = options->animationResults[k]->dataSrt.index >> 8; + KBNAContents[resPtrCounter + 2] = options->animationResults[k]->dataSrt.rotation & 0xff; + KBNAContents[resPtrCounter + 3] = options->animationResults[k]->dataSrt.rotation >> 8; + KBNAContents[resPtrCounter + 4] = options->animationResults[k]->dataSrt.scaleX & 0xff; + KBNAContents[resPtrCounter + 5] = (options->animationResults[k]->dataSrt.scaleX >> 8) & 0xff; + KBNAContents[resPtrCounter + 6] = (options->animationResults[k]->dataSrt.scaleX >> 16) & 0xff; + KBNAContents[resPtrCounter + 7] = options->animationResults[k]->dataSrt.scaleX >> 24; + KBNAContents[resPtrCounter + 8] = options->animationResults[k]->dataSrt.scaleY & 0xff; + KBNAContents[resPtrCounter + 9] = (options->animationResults[k]->dataSrt.scaleY >> 8) & 0xff; + KBNAContents[resPtrCounter + 10] = (options->animationResults[k]->dataSrt.scaleY >> 16) & 0xff; + KBNAContents[resPtrCounter + 11] = options->animationResults[k]->dataSrt.scaleY >> 24; + KBNAContents[resPtrCounter + 12] = options->animationResults[k]->dataSrt.positionX & 0xff; + KBNAContents[resPtrCounter + 13] = options->animationResults[k]->dataSrt.positionX >> 8; + KBNAContents[resPtrCounter + 14] = options->animationResults[k]->dataSrt.positionY & 0xff; + KBNAContents[resPtrCounter + 15] = options->animationResults[k]->dataSrt.positionY >> 8; + resPtrCounter += 0x10; + break; + + case 2: + KBNAContents[resPtrCounter] = options->animationResults[k]->dataT.index & 0xff; + KBNAContents[resPtrCounter + 1] = options->animationResults[k]->dataT.index >> 8; + KBNAContents[resPtrCounter + 2] = 0xEF; + KBNAContents[resPtrCounter + 3] = 0xBE; + KBNAContents[resPtrCounter + 4] = options->animationResults[k]->dataT.positionX & 0xff; + KBNAContents[resPtrCounter + 5] = options->animationResults[k]->dataT.positionX >> 8; + KBNAContents[resPtrCounter + 6] = options->animationResults[k]->dataT.positionY & 0xff; + KBNAContents[resPtrCounter + 7] = options->animationResults[k]->dataT.positionY >> 8; + resPtrCounter += 0x8; + break; + } + + // use the `padded` flag which was stored earlier to inject padding + if (options->animationResults[k]->padded) + { + KBNAContents[resPtrCounter] = 0xCC; + KBNAContents[resPtrCounter + 1] = 0xCC; + resPtrCounter += 0x2; + } + } + + fwrite(KBNAContents, 1, contentsSize, fp); + + free(KBNAContents); + + if (options->labelEnabled) + { + unsigned int lablSize = 8; + for (int j = 0; j < options->labelCount; j++) + { + lablSize += (unsigned)strlen(options->labels[j]) + 5; + } + + unsigned char *labl = malloc(lablSize); + + memset(labl, 0, lablSize); + + strcpy((char *) labl, "LBAL"); + labl[4] = lablSize & 0xff; + labl[5] = lablSize >> 8; + + unsigned int position = 0; + + i = 0; + for (int j = 0; j < options->labelCount; j++) + { + labl[i + 8] = position & 0xff; + labl[i + 9] = position >> 8; + + position += (unsigned)strlen(options->labels[j]) + 1; + i += 4; + } + + for (int j = 0; j < options->labelCount; j++) + { + strcpy((char *) (labl + (i + 8)), options->labels[j]); + i += (int)strlen(options->labels[j]) + 1; + } + + fwrite(labl, 1, lablSize, fp); + + free(labl); + + if(!options->multiCell) + { + unsigned char txeu[0xc] = {0x54, 0x58, 0x45, 0x55, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + + fwrite(txeu, 1, 0xc, fp); + } + } + + fclose(fp); +} diff --git a/tools/nitrogfx/gfx.h b/tools/nitrogfx/gfx.h new file mode 100644 index 0000000000..5efcf996c3 --- /dev/null +++ b/tools/nitrogfx/gfx.h @@ -0,0 +1,71 @@ +// Copyright (c) 2015 YamaArashi, 2021-2024 red031000 + +#ifndef GFX_H +#define GFX_H + +#include +#include +#include "options.h" + +struct Color { + unsigned char red; + unsigned char green; + unsigned char blue; +}; + +struct Palette { + struct Color colors[256]; + int numColors; + int bitDepth; +}; + +struct Image { + int width; + int height; + int bitDepth; + /** + * Pseudocode for converting index in pixels to coordinates in image is as follows + * (where (0, 0) is the top left corner with the format (x, y) ): + * if (bitDepth == 4) + * for (int i = 0; i < width * height / 2; i++) + * xCoord = i % + * yCoord = i / + * + * leftPixel = pixels[i] & 0xF + * rightPixel = pixels[i] >> 4) + * + * leftPixel coordinates: (xCoord, yCoord) + * rightPixel coordinates: (xCoord + 1, yCoord) + * else if (bitDepth == 8) + * for (int i = 0; i < width * height; i++) + * xCoord = i % + * yCoord = i / + * + * pixel = pixels[i] + * pixel coordinates: (xCoord, yCoord) + */ + unsigned char *pixels; + bool hasPalette; + struct Palette palette; + bool hasTransparency; +}; + +void ReadImage(char *path, int tilesWide, int bitDepth, int colsPerChunk, int rowsPerChunk, struct Image *image, bool invertColors); +uint32_t ReadNtrImage(char *path, int tilesWide, int bitDepth, int colsPerChunk, int rowsPerChunk, struct Image *image, bool invertColors, bool scanFrontToBack); +void ApplyCellsToImage(char *cellFilePath, struct Image *image, bool toPNG); +void WriteImage(char *path, int numTiles, int bitDepth, int colsPerChunk, int rowsPerChunk, struct Image *image, bool invertColors); +void WriteNtrImage(char *path, int numTiles, int bitDepth, int colsPerChunk, int rowsPerChunk, struct Image *image, + bool invertColors, bool clobberSize, bool byteOrder, bool version101, bool sopc, bool vram, uint32_t scanMode, + uint32_t mappingType, uint32_t key, bool wrongSize); +void FreeImage(struct Image *image); +void ReadGbaPalette(char *path, struct Palette *palette); +void ReadNtrPalette(char *path, struct Palette *palette, int bitdepth, int palIndex, bool inverted); +void WriteGbaPalette(char *path, struct Palette *palette); +void WriteNtrPalette(char *path, struct Palette *palette, bool ncpr, bool ir, int bitdepth, bool pad, int compNum, bool pcmp, bool inverted); +void ReadNtrCell(char *path, struct JsonToCellOptions *options); +void WriteNtrCell(char *path, struct JsonToCellOptions *options); +void WriteNtrScreen(char *path, struct JsonToScreenOptions *options); +void ReadNtrAnimation(char *path, struct JsonToAnimationOptions *options); +void WriteNtrAnimation(char *path, struct JsonToAnimationOptions *options); + +#endif // GFX_H diff --git a/tools/nitrogfx/global.h b/tools/nitrogfx/global.h new file mode 100644 index 0000000000..32378a9ff3 --- /dev/null +++ b/tools/nitrogfx/global.h @@ -0,0 +1,37 @@ +// Copyright (c) 2015 YamaArashi + +#ifndef GLOBAL_H +#define GLOBAL_H + +#include +#include + +#ifdef _MSC_VER + +#define FATAL_ERROR(format, ...) \ +do { \ + fprintf(stderr, format, __VA_ARGS__); \ + exit(1); \ +} while (0) + +#define UNUSED + +#else + +#define FATAL_ERROR(format, ...) \ +do { \ + fprintf(stderr, format, ##__VA_ARGS__); \ + exit(1); \ +} while (0) + +#define UNUSED __attribute__((__unused__)) + +#endif // _MSC_VER + +#define PTR_ADD(ptr, value) ((void*)((uintptr_t)(ptr) + (value))) +#define PTR_SUB(ptr, value) ((void*)((uintptr_t)(ptr) - (value))) +#define PTR_IADD(ptr, value) do { (ptr) = PTR_ADD(ptr, value); } while (0) +#define PTR_ISUB(ptr, value) do { (ptr) = PTR_SUB(ptr, value); } while (0) +#define PTR_DIFF(right, left) ((uintptr_t)(right) - (uintptr_t)(left)) + +#endif // GLOBAL_H diff --git a/tools/nitrogfx/huff.c b/tools/nitrogfx/huff.c new file mode 100644 index 0000000000..d718fb71be --- /dev/null +++ b/tools/nitrogfx/huff.c @@ -0,0 +1,398 @@ +#include +#include +#include +#include +#include +#include "global.h" +#include "huff.h" + +static int cmp_tree(const void * a0, const void * b0) { + return ((struct HuffData *)a0)->value - ((struct HuffData *)b0)->value; +} + +typedef int (*cmpfun)(const void *, const void *); + +int msort_r(void * data, size_t count, size_t size, cmpfun cmp, void * buffer) { + /* + * Out-of-place mergesort (stable sort) + * Returns 1 on success, 0 on failure + */ + void * leftPtr; + void * rightPtr; + void * leftEnd; + void * rightEnd; + int i; + + switch (count) { + case 0: + // Should never be here + return 0; + + case 1: + // Nothing to do here + break; + + case 2: + // Swap the two entries if the right one compares higher. + if (cmp(data, PTR_ADD(data, size)) > 0) { + memcpy(buffer, data, size); + memcpy(data, PTR_ADD(data, size), size); + memcpy(PTR_ADD(data, size), buffer, size); + } + break; + default: + // Merge sort out-of-place. + leftPtr = data; + leftEnd = rightPtr = PTR_ADD(data, count / 2 * size); + rightEnd = PTR_ADD(data, count * size); + + // Sort the left half + if (!msort_r(leftPtr, count / 2, size, cmp, buffer)) + return 0; + + // Sort the right half + if (!msort_r(rightPtr, count / 2 + (count & 1), size, cmp, buffer)) + return 0; + + // Merge the sorted halves out of place + i = 0; + do { + if (cmp(leftPtr, rightPtr) <= 0) { + memcpy(PTR_ADD(buffer, i * size), leftPtr, size); + PTR_IADD(leftPtr, size); + } else { + memcpy(PTR_ADD(buffer, i * size), rightPtr, size); + PTR_IADD(rightPtr, size); + } + + } while (++i < count && leftPtr < leftEnd && rightPtr < rightEnd); + + // Copy the remainder + if (i < count) { + if (leftPtr < leftEnd) { + memcpy(PTR_ADD(buffer, i * size), leftPtr, PTR_DIFF(leftEnd, leftPtr)); + } + else { + memcpy(PTR_ADD(buffer, i * size), rightPtr, PTR_DIFF(rightEnd, rightPtr)); + } + } + + // Copy the merged data back + memcpy(data, buffer, count * size); + break; + } + + return 1; +} + +int msort(void * data, size_t count, size_t size, cmpfun cmp) { + void * buffer = malloc(count * size); + if (buffer == NULL) return 0; + int result = msort_r(data, count, size, cmp, buffer); + free(buffer); + return result; +} + +static void write_tree(unsigned char * dest, HuffNode_t * tree, int nitems, struct BitEncoding * encoding) { + /* + * The example used to guide this function encodes the tree in a + * breadth-first manner. We attempt to emulate that here. + */ + + int i, j, k; + + // There are (2 * nitems - 1) nodes in the binary tree. Allocate that. + HuffNode_t * traversal = calloc(2 * nitems - 1, sizeof(HuffNode_t)); + if (traversal == NULL) + FATAL_ERROR("Fatal error while compressing Huff file.\n"); + + // The first node is the root of the tree. + traversal[0] = *tree; + i = 1; + + // Copy the tree into a breadth-first ordering using brute force. + for (int depth = 1; i < 2 * nitems - 1; depth++) { + // Consider every possible path up to the current depth. + for (j = 0; i < 2 * nitems - 1 && j < 1 << depth; j++) { + // The index of the path is used to encode the path itself. + // Start from the most significant relevant bit and work our way down. + // Keep track of the current and previous nodes. + HuffNode_t * currNode = traversal; + HuffNode_t * parent = NULL; + for (k = 0; k < depth; k++) { + if (currNode->header.isLeaf) + break; + parent = currNode; + if ((j >> (depth - k - 1)) & 1) + currNode = currNode->branch.right; + else + currNode = currNode->branch.left; + } + // Check that the length of the current path equals the current depth. + if (k == depth) { + // Make sure we can encode the current branch. + // Bail here if we cannot. + // This is only applicable for 8-bit encodings. + if (traversal + i - parent > 128) + FATAL_ERROR("Fatal error while compressing Huff file: unable to encode binary tree.\n"); + // Copy the current node, and update its parent. + traversal[i] = *currNode; + if (parent != NULL) { + if ((j & 1) == 1) + parent->branch.right = traversal + i; + else + parent->branch.left = traversal + i; + } + // Encode the path through the tree in the lookup table + if (traversal[i].header.isLeaf) { + encoding[traversal[i].leaf.key].nbits = depth; + encoding[traversal[i].leaf.key].bitstring = j; + } + i++; + } + } + } + + // Encode the size of the tree. + // This is used by the decompressor to skip the tree. + dest[4] = nitems - 1; + + // Encode each node in the tree. + for (i = 0; i < 2 * nitems - 1; i++) { + HuffNode_t * currNode = traversal + i; + if (currNode->header.isLeaf) { + dest[5 + i] = traversal[i].leaf.key; + } else { + dest[5 + i] = (unsigned char)(((currNode->branch.right - traversal - i) / 2) - 1); + if (currNode->branch.left->header.isLeaf) + dest[5 + i] |= 0x80; + if (currNode->branch.right->header.isLeaf) + dest[5 + i] |= 0x40; + } + } + + free(traversal); +} + +static inline void write_32_le(unsigned char * dest, int * destPos, uint32_t * buff, int * buffPos) { + dest[*destPos] = *buff; + dest[*destPos + 1] = *buff >> 8; + dest[*destPos + 2] = *buff >> 16; + dest[*destPos + 3] = *buff >> 24; + *destPos += 4; + *buff = 0; + *buffPos = 0; +} + +static inline void read_32_le(unsigned char * src, int * srcPos, uint32_t * buff) { + uint32_t tmp = src[*srcPos]; + tmp |= src[*srcPos + 1] << 8; + tmp |= src[*srcPos + 2] << 16; + tmp |= src[*srcPos + 3] << 24; + *srcPos += 4; + *buff = tmp; +} + +static void write_bits(unsigned char * dest, int * destPos, struct BitEncoding * encoding, int value, uint32_t * buff, int * buffBits) { + int nbits = (int)encoding[value].nbits; + uint32_t bitstring = (uint32_t)encoding[value].bitstring; + + if (*buffBits + nbits >= 32) { + int diff = *buffBits + nbits - 32; + *buff <<= nbits - diff; + *buff |= bitstring >> diff; + bitstring &= ~(1 << diff); + nbits = diff; + write_32_le(dest, destPos, buff, buffBits); + } + if (nbits != 0) { + *buff <<= nbits; + *buff |= bitstring; + *buffBits += nbits; + } +} + +/* +======================================= +MAIN COMPRESSION/DECOMPRESSION ROUTINES +======================================= + */ + +unsigned char * HuffCompress(unsigned char * src, int srcSize, int * compressedSize_p, int bitDepth) { + if (srcSize <= 0) + goto fail; + + int worstCaseDestSize = 4 + (2 << bitDepth) + srcSize * 3; + + unsigned char *dest = malloc(worstCaseDestSize); + if (dest == NULL) + goto fail; + + int nitems = 1 << bitDepth; + + HuffNode_t * freqs = calloc(nitems, sizeof(HuffNode_t)); + if (freqs == NULL) + goto fail; + + struct BitEncoding * encoding = calloc(nitems, sizeof(struct BitEncoding)); + if (encoding == NULL) + goto fail; + + // Set up the frequencies table. This will inform the tree. + for (int i = 0; i < nitems; i++) { + freqs[i].header.isLeaf = 1; + freqs[i].header.value = 0; + freqs[i].leaf.key = i; + } + + // Count each nybble or byte. + for (int i = 0; i < srcSize; i++) { + if (bitDepth == 8) { + freqs[src[i]].header.value++; + } else { + freqs[src[i] >> 4].header.value++; + freqs[src[i] & 0xF].header.value++; + } + } + +#ifdef DEBUG + for (int i = 0; i < nitems; i++) { + fprintf(stderr, "%d: %d\n", i, freqs[i].header.value); + } +#endif // DEBUG + + // Sort the frequency table. + if (!msort(freqs, nitems, sizeof(HuffNode_t), cmp_tree)) + goto fail; + + // Prune zero-frequency values. + for (int i = 0; i < nitems; i++) { + if (freqs[i].header.value != 0) { + if (i > 0) { + for (int j = i; j < nitems; j++) { + freqs[j - i] = freqs[j]; + } + nitems -= i; + } + break; + } + // This should never happen: + if (i == nitems - 1) + goto fail; + } + + HuffNode_t * tree = calloc(nitems * 2 - 1, sizeof(HuffNode_t)); + if (tree == NULL) + goto fail; + + // Iteratively collapse the two least frequent nodes. + HuffNode_t * endptr = freqs + nitems - 2; + + for (int i = 0; i < nitems - 1; i++) { + HuffNode_t * left = freqs; + HuffNode_t * right = freqs + 1; + tree[i * 2] = *right; + tree[i * 2 + 1] = *left; + for (int j = 0; j < nitems - i - 2; j++) + freqs[j] = freqs[j + 2]; + endptr->header.isLeaf = 0; + endptr->header.value = tree[i * 2].header.value + tree[i * 2 + 1].header.value; + endptr->branch.left = tree + i * 2; + endptr->branch.right = tree + i * 2 + 1; + endptr--; + if (i < nitems - 2 && !msort(freqs, nitems - i - 1, sizeof(HuffNode_t), cmp_tree)) + goto fail; + } + + // Write the tree breadth-first, and create the path lookup table. + write_tree(dest, freqs, nitems, encoding); + + free(tree); + free(freqs); + + // Encode the data itself. + int destPos = 4 + nitems * 2; + uint32_t destBuf = 0; + uint32_t srcBuf = 0; + int destBitPos = 0; + + for (int srcPos = 0; srcPos < srcSize;) { + read_32_le(src, &srcPos, &srcBuf); + for (int i = 0; i < 32 / bitDepth; i++) { + write_bits(dest, &destPos, encoding, srcBuf & (0xFF >> (8 - bitDepth)), &destBuf, &destBitPos); + srcBuf >>= bitDepth; + } + } + + if (destBitPos != 0) { + write_32_le(dest, &destPos, &destBuf, &destBitPos); + } + + free(encoding); + + // Write the header. + dest[0] = bitDepth | 0x20; + dest[1] = srcSize; + dest[2] = srcSize >> 8; + dest[3] = srcSize >> 16; + *compressedSize_p = (destPos + 3) & ~3; + return dest; + +fail: + FATAL_ERROR("Fatal error while compressing Huff file.\n"); +} + +unsigned char * HuffDecompress(unsigned char * src, int srcSize, int * uncompressedSize_p) { + if (srcSize < 4) + goto fail; + + int bitDepth = *src & 15; + if (bitDepth != 4 && bitDepth != 8) + goto fail; + + int destSize = (src[3] << 16) | (src[2] << 8) | src[1]; + + unsigned char *dest = malloc(destSize); + + if (dest == NULL) + goto fail; + + int treePos = 5; + int treeSize = (src[4] + 1) * 2; + int srcPos = 4 + treeSize; + int destPos = 0; + int curValPos = 0; + uint32_t destTmp = 0; + uint32_t window; + + for (;;) + { + if (srcPos >= srcSize) + goto fail; + read_32_le(src, &srcPos, &window); + for (int i = 0; i < 32; i++) { + int curBit = (window >> 31) & 1; + unsigned char treeView = src[treePos]; + bool isLeaf = ((treeView << curBit) & 0x80) != 0; + treePos &= ~1; // align + treePos += ((treeView & 0x3F) + 1) * 2 + curBit; + if (isLeaf) { + destTmp >>= bitDepth; + destTmp |= (src[treePos] << (32 - bitDepth)); + curValPos++; + if (curValPos == 32 / bitDepth) { + write_32_le(dest, &destPos, &destTmp, &curValPos); + if (destPos == destSize) { + *uncompressedSize_p = destSize; + return dest; + } + } + treePos = 5; + } + window <<= 1; + } + } + +fail: + FATAL_ERROR("Fatal error while decompressing Huff file.\n"); +} diff --git a/tools/nitrogfx/huff.h b/tools/nitrogfx/huff.h new file mode 100644 index 0000000000..6002fe954a --- /dev/null +++ b/tools/nitrogfx/huff.h @@ -0,0 +1,38 @@ +#ifndef HUFF_H +#define HUFF_H + +union HuffNode; + +struct HuffData { + unsigned value:31; + unsigned isLeaf:1; +}; + +struct HuffLeaf { + struct HuffData header; + unsigned char key; +}; + +struct HuffBranch { + struct HuffData header; + union HuffNode * left; + union HuffNode * right; +}; + +union HuffNode { + struct HuffData header; + struct HuffLeaf leaf; + struct HuffBranch branch; +}; + +typedef union HuffNode HuffNode_t; + +struct BitEncoding { + unsigned long long nbits:6; + unsigned long long bitstring:58; +}; + +unsigned char * HuffCompress(unsigned char * buffer, int srcSize, int * compressedSize_p, int bitDepth); +unsigned char * HuffDecompress(unsigned char * buffer, int srcSize, int * uncompressedSize_p); + +#endif //HUFF_H diff --git a/tools/nitrogfx/jasc_pal.c b/tools/nitrogfx/jasc_pal.c new file mode 100644 index 0000000000..4f80f5d900 --- /dev/null +++ b/tools/nitrogfx/jasc_pal.c @@ -0,0 +1,179 @@ +// Copyright (c) 2015 YamaArashi + +#include +#include +#include "global.h" +#include "gfx.h" +#include "util.h" + +// Read/write Paint Shop Pro palette files. + +// Format of a Paint Shop Pro palette file, line by line: +// "JASC-PAL\r\n" (signature) +// "0100\r\n" (version; seems to always be "0100") +// "\r\n" (number of colors in decimal) +// +// times: +// " \r\n" (color entry) +// +// Each color component is a decimal number from 0 to 255. +// Examples: +// Black - "0 0 0\r\n" +// Blue - "0 0 255\r\n" +// Brown - "150 75 0\r\n" + +#define MAX_LINE_LENGTH 11 + +void ReadJascPaletteLine(FILE *fp, char *line) +{ + int c; + int length = 0; + + for (;;) + { + c = fgetc(fp); + + if (c == '\r') + { + c = fgetc(fp); + + if (c != '\n') + FATAL_ERROR("CR line endings aren't supported.\n"); + + line[length] = 0; + + return; + } + + if (c == '\n') + FATAL_ERROR("LF line endings aren't supported.\n"); + + if (c == EOF) + FATAL_ERROR("Unexpected EOF. No CRLF at end of file.\n"); + + if (c == 0) + FATAL_ERROR("NUL character in file.\n"); + + if (length == MAX_LINE_LENGTH) + { + line[length] = 0; + FATAL_ERROR("The line \"%s\" is too long.\n", line); + } + + line[length++] = c; + } +} + +void ReadJascPalette(char *path, struct Palette *palette) +{ + char line[MAX_LINE_LENGTH + 1]; + + FILE *fp = fopen(path, "rb"); + + if (fp == NULL) + FATAL_ERROR("Failed to open JASC-PAL file \"%s\" for reading.\n", path); + + ReadJascPaletteLine(fp, line); + + if (strcmp(line, "JASC-PAL") != 0) + FATAL_ERROR("Invalid JASC-PAL signature.\n"); + + ReadJascPaletteLine(fp, line); + + if (strcmp(line, "0100") != 0) + FATAL_ERROR("Unsuported JASC-PAL version.\n"); + + ReadJascPaletteLine(fp, line); + + if (!ParseNumber(line, NULL, 10, &palette->numColors)) + FATAL_ERROR("Failed to parse number of colors.\n"); + + if (palette->numColors < 1 || palette->numColors > 256) + FATAL_ERROR("%d is an invalid number of colors. The number of colors must be in the range [1, 256].\n", palette->numColors); + + palette->bitDepth = 4; + + for (int i = 0; i < palette->numColors; i++) + { + ReadJascPaletteLine(fp, line); + + char *s = line; + char *end; + + int red; + int green; + int blue; + + if (!ParseNumber(s, &end, 10, &red)) + FATAL_ERROR("Failed to parse red color component.\n"); + + s = end; + + if (*s != ' ') + FATAL_ERROR("Expected a space after red color component.\n"); + + s++; + + if (*s < '0' || *s > '9') + FATAL_ERROR("Expected only a space between red and green color components.\n"); + + if (!ParseNumber(s, &end, 10, &green)) + FATAL_ERROR("Failed to parse green color component.\n"); + + s = end; + + if (*s != ' ') + FATAL_ERROR("Expected a space after green color component.\n"); + + s++; + + if (*s < '0' || *s > '9') + FATAL_ERROR("Expected only a space between green and blue color components.\n"); + + if (!ParseNumber(s, &end, 10, &blue)) + FATAL_ERROR("Failed to parse blue color component.\n"); + + if (*end != 0) + FATAL_ERROR("Garbage after blue color component.\n"); + + if (red < 0 || red > 255) + FATAL_ERROR("Red color component (%d) is outside the range [0, 255].\n", red); + + if (green < 0 || green > 255) + FATAL_ERROR("Green color component (%d) is outside the range [0, 255].\n", green); + + if (blue < 0 || blue > 255) + FATAL_ERROR("Blue color component (%d) is outside the range [0, 255].\n", blue); + + palette->colors[i].red = red; + palette->colors[i].green = green; + palette->colors[i].blue = blue; + if (i >= 16) + { + if (red || green || blue) + palette->bitDepth = 8; + } + } + + if (fgetc(fp) != EOF) + FATAL_ERROR("Garbage after color data.\n"); + + fclose(fp); +} + +void WriteJascPalette(char *path, struct Palette *palette) +{ + FILE *fp = fopen(path, "wb"); + + fputs("JASC-PAL\r\n", fp); + fputs("0100\r\n", fp); + fprintf(fp, "%d\r\n", palette->numColors); + + for (int i = 0; i < palette->numColors; i++) + { + struct Color *color = &palette->colors[i]; + fprintf(fp, "%d %d %d\r\n", color->red, color->green, color->blue); + } + + fclose(fp); +} diff --git a/tools/nitrogfx/jasc_pal.h b/tools/nitrogfx/jasc_pal.h new file mode 100644 index 0000000000..b60b31fc8d --- /dev/null +++ b/tools/nitrogfx/jasc_pal.h @@ -0,0 +1,9 @@ +// Copyright (c) 2015 YamaArashi + +#ifndef JASC_PAL_H +#define JASC_PAL_H + +void ReadJascPalette(char *path, struct Palette *palette); +void WriteJascPalette(char *path, struct Palette *palette); + +#endif // JASC_PAL_H diff --git a/tools/nitrogfx/json.c b/tools/nitrogfx/json.c new file mode 100644 index 0000000000..f0156700cf --- /dev/null +++ b/tools/nitrogfx/json.c @@ -0,0 +1,765 @@ +// Copyright (c) 2021-2024 red031000 + +#include "global.h" +#include "cJSON.h" +#include "json.h" +#include "util.h" +#include +#include + +static inline bool GetBool(cJSON * in) +{ + if (!cJSON_IsBool(in)) + return false; + + return cJSON_IsTrue(in); +} + +static inline int GetInt(cJSON * in) +{ + if (!cJSON_IsNumber(in)) + return 0; + + return in->valueint; +} + +static inline char *GetString(cJSON * in) +{ + if (!cJSON_IsString(in)) + return NULL; + + return in->valuestring; +} + +struct JsonToCellOptions *ParseNCERJson(char *path) +{ + int fileLength; + unsigned char *jsonString = ReadWholeFile(path, &fileLength); + + cJSON *json = cJSON_Parse((const char *)jsonString); + + struct JsonToCellOptions *options = malloc(sizeof(struct JsonToCellOptions)); + + if (json == NULL) + { + const char *errorPtr = cJSON_GetErrorPtr(); + FATAL_ERROR("Error in line \"%s\"\n", errorPtr); + } + + cJSON *labelBool = cJSON_GetObjectItemCaseSensitive(json, "labelEnabled"); + cJSON *vramTransferBool = cJSON_GetObjectItemCaseSensitive(json, "vramTransferEnabled"); + cJSON *extended = cJSON_GetObjectItemCaseSensitive(json, "extended"); + cJSON *cellCount = cJSON_GetObjectItemCaseSensitive(json, "cellCount"); + cJSON *mappingType = cJSON_GetObjectItemCaseSensitive(json, "mappingType"); + + options->labelEnabled = GetBool(labelBool); + options->vramTransferEnabled = GetBool(vramTransferBool); + options->extended = GetBool(extended); + options->cellCount = GetInt(cellCount); + options->mappingType = GetInt(mappingType); + + options->cells = malloc(sizeof(struct Cell *) * options->cellCount); + + if (options->labelEnabled) + { + cJSON *labelCount = cJSON_GetObjectItemCaseSensitive(json, "labelCount"); + options->labelCount = GetInt(labelCount); + options->labels = malloc(sizeof(char *) * options->labelCount); + + cJSON *labels = cJSON_GetObjectItemCaseSensitive(json, "labels"); + cJSON *label = NULL; + + int j = 0; + cJSON_ArrayForEach(label, labels) + { + char *labelString = GetString(label); + options->labels[j] = malloc(strlen(labelString) + 1); + strcpy(options->labels[j], labelString); + j++; + } + } + + if (options->vramTransferEnabled) + { + cJSON *vramTransferMaxSize = cJSON_GetObjectItemCaseSensitive(json, "vramTransferMaxSize"); + options->vramTransferMaxSize = GetInt(vramTransferMaxSize); + + options->transferData = malloc(sizeof(struct CellVramTransferData *) * options->cellCount); + + cJSON *transfers = cJSON_GetObjectItemCaseSensitive(json, "transferData"); + cJSON *transfer = NULL; + + int j = 0; + cJSON_ArrayForEach(transfer, transfers) + { + cJSON *vramTransferOffset = cJSON_GetObjectItemCaseSensitive(transfer, "offset"); + cJSON *vramTransferSize = cJSON_GetObjectItemCaseSensitive(transfer, "size"); + + options->transferData[j] = malloc(sizeof(struct CellVramTransferData)); + options->transferData[j]->sourceDataOffset = GetInt(vramTransferOffset); + options->transferData[j]->size = GetInt(vramTransferSize); + + j++; + } + } + + for (int i = 0; i < options->cellCount; i++) + { + options->cells[i] = malloc(sizeof(struct Cell)); + } + + int i = 0; + cJSON *cells = cJSON_GetObjectItemCaseSensitive(json, "cells"); + cJSON *cell = NULL; + + cJSON_ArrayForEach(cell, cells) + { + if (i > options->cellCount - 1) + FATAL_ERROR("Cell count is incorrect.\n"); + + cJSON *cellAttrs = cJSON_GetObjectItemCaseSensitive(cell, "cellAttrs"); + + cJSON *hFlip = cJSON_GetObjectItemCaseSensitive(cellAttrs, "hFlip"); + cJSON *vFlip = cJSON_GetObjectItemCaseSensitive(cellAttrs, "vFlip"); + cJSON *hvFlip = cJSON_GetObjectItemCaseSensitive(cellAttrs, "hvFlip"); + + options->cells[i]->attributes.hFlip = GetBool(hFlip); + options->cells[i]->attributes.vFlip = GetBool(vFlip); + options->cells[i]->attributes.hvFlip = GetBool(hvFlip); + + cJSON *boundingRect = cJSON_GetObjectItemCaseSensitive(cellAttrs, "boundingRect"); + + options->cells[i]->attributes.boundingRect = GetBool(boundingRect); + + cJSON *boundingSphereRadius = cJSON_GetObjectItemCaseSensitive(cellAttrs, "boundingSphereRadius"); + + options->cells[i]->attributes.boundingSphereRadius = GetInt(boundingSphereRadius); + + if (options->extended) + { + cJSON *maxX = cJSON_GetObjectItemCaseSensitive(cell, "maxX"); + cJSON *maxY = cJSON_GetObjectItemCaseSensitive(cell, "maxY"); + cJSON *minX = cJSON_GetObjectItemCaseSensitive(cell, "minX"); + cJSON *minY = cJSON_GetObjectItemCaseSensitive(cell, "minY"); + + options->cells[i]->maxX = (short)GetInt(maxX); + options->cells[i]->maxY = (short)GetInt(maxY); + options->cells[i]->minX = (short)GetInt(minX); + options->cells[i]->minY = (short)GetInt(minY); + } + //OAM data + cJSON *oamCount = cJSON_GetObjectItemCaseSensitive(cell, "oamCount"); + + options->cells[i]->oamCount = (short)GetInt(oamCount); + options->cells[i]->oam = malloc(sizeof(struct OAM) * options->cells[i]->oamCount); + + cJSON *OAMArray = cJSON_GetObjectItemCaseSensitive(cell, "OAM"); + cJSON *OAM = NULL; + + int j = 0; + + cJSON_ArrayForEach(OAM, OAMArray) + { + if (j > options->cells[i]->oamCount - 1) + FATAL_ERROR("OAM count is incorrect.\n"); + + //Attr0 + cJSON *Attr0 = cJSON_GetObjectItemCaseSensitive(OAM, "Attr0"); + + cJSON *YCoordinate = cJSON_GetObjectItemCaseSensitive(Attr0, "YCoordinate"); + cJSON *Rotation = cJSON_GetObjectItemCaseSensitive(Attr0, "Rotation"); + cJSON *SizeDisable = cJSON_GetObjectItemCaseSensitive(Attr0, "SizeDisable"); + cJSON *Mode = cJSON_GetObjectItemCaseSensitive(Attr0, "Mode"); + cJSON *Mosaic = cJSON_GetObjectItemCaseSensitive(Attr0, "Mosaic"); + cJSON *Colours = cJSON_GetObjectItemCaseSensitive(Attr0, "Colours"); + cJSON *Shape = cJSON_GetObjectItemCaseSensitive(Attr0, "Shape"); + + options->cells[i]->oam[j].attr0.YCoordinate = GetInt(YCoordinate); + options->cells[i]->oam[j].attr0.Rotation = GetBool(Rotation); + options->cells[i]->oam[j].attr0.SizeDisable = GetBool(SizeDisable); + options->cells[i]->oam[j].attr0.Mode = GetInt(Mode); + options->cells[i]->oam[j].attr0.Mosaic = GetBool(Mosaic); + options->cells[i]->oam[j].attr0.Colours = GetInt(Colours); + options->cells[i]->oam[j].attr0.Shape = GetInt(Shape); + + //Attr1 + cJSON *Attr1 = cJSON_GetObjectItemCaseSensitive(OAM, "Attr1"); + + cJSON *XCoordinate = cJSON_GetObjectItemCaseSensitive(Attr1, "XCoordinate"); + cJSON *RotationScaling = cJSON_GetObjectItemCaseSensitive(Attr1, "RotationScaling"); + cJSON *Size = cJSON_GetObjectItemCaseSensitive(Attr1, "Size"); + + options->cells[i]->oam[j].attr1.XCoordinate = GetInt(XCoordinate); + options->cells[i]->oam[j].attr1.RotationScaling = GetInt(RotationScaling); + options->cells[i]->oam[j].attr1.Size = GetInt(Size); + + //Attr2 + cJSON *Attr2 = cJSON_GetObjectItemCaseSensitive(OAM, "Attr2"); + + cJSON *CharName = cJSON_GetObjectItemCaseSensitive(Attr2, "CharName"); + cJSON *Priority = cJSON_GetObjectItemCaseSensitive(Attr2, "Priority"); + cJSON *Palette = cJSON_GetObjectItemCaseSensitive(Attr2, "Palette"); + + options->cells[i]->oam[j].attr2.CharName = GetInt(CharName); + options->cells[i]->oam[j].attr2.Priority = GetInt(Priority); + options->cells[i]->oam[j].attr2.Palette = GetInt(Palette); + + j++; + } + + i++; + } + + cJSON_Delete(json); + free(jsonString); + return options; +} + +char *GetNCERJson(struct JsonToCellOptions *options) +{ + cJSON *ncer = cJSON_CreateObject(); + + cJSON_AddBoolToObject(ncer, "labelEnabled", options->labelEnabled); + cJSON_AddBoolToObject(ncer, "extended", options->extended); + cJSON_AddBoolToObject(ncer, "vramTransferEnabled", options->vramTransferEnabled); + cJSON_AddNumberToObject(ncer, "cellCount", options->cellCount); + cJSON_AddNumberToObject(ncer, "mappingType", options->mappingType); + + cJSON *cells = cJSON_AddArrayToObject(ncer, "cells"); + + for (int i = 0; i < options->cellCount; i++) + { + cJSON *cell = cJSON_CreateObject(); + + cJSON *cellAttrs = cJSON_AddObjectToObject(cell, "cellAttrs"); + + cJSON_AddBoolToObject(cellAttrs, "hFlip", options->cells[i]->attributes.hFlip); + cJSON_AddBoolToObject(cellAttrs, "vFlip", options->cells[i]->attributes.vFlip); + cJSON_AddBoolToObject(cellAttrs, "hvFlip", options->cells[i]->attributes.hvFlip); + cJSON_AddBoolToObject(cellAttrs, "boundingRect", options->cells[i]->attributes.boundingRect); + cJSON_AddNumberToObject(cellAttrs, "boundingSphereRadius", options->cells[i]->attributes.boundingSphereRadius); + + if (options->extended) + { + cJSON_AddNumberToObject(cell, "maxX", options->cells[i]->maxX); + cJSON_AddNumberToObject(cell, "maxY", options->cells[i]->maxY); + cJSON_AddNumberToObject(cell, "minX", options->cells[i]->minX); + cJSON_AddNumberToObject(cell, "minY", options->cells[i]->minY); + } + + cJSON_AddNumberToObject(cell, "oamCount", options->cells[i]->oamCount); + + cJSON *OAMArray = cJSON_AddArrayToObject(cell, "OAM"); + + for (int j = 0; j < options->cells[i]->oamCount; j++) + { + cJSON *OAM = cJSON_CreateObject(); + + cJSON *Attr0 = cJSON_AddObjectToObject(OAM, "Attr0"); + + cJSON_AddNumberToObject(Attr0, "YCoordinate", options->cells[i]->oam[j].attr0.YCoordinate); + cJSON_AddBoolToObject(Attr0, "Rotation", options->cells[i]->oam[j].attr0.Rotation); + cJSON_AddBoolToObject(Attr0, "SizeDisable", options->cells[i]->oam[j].attr0.SizeDisable); + cJSON_AddNumberToObject(Attr0, "Mode", options->cells[i]->oam[j].attr0.Mode); + cJSON_AddBoolToObject(Attr0, "Mosaic", options->cells[i]->oam[j].attr0.Mosaic); + cJSON_AddNumberToObject(Attr0, "Colours", options->cells[i]->oam[j].attr0.Colours); + cJSON_AddNumberToObject(Attr0, "Shape", options->cells[i]->oam[j].attr0.Shape); + + cJSON *Attr1 = cJSON_AddObjectToObject(OAM, "Attr1"); + + cJSON_AddNumberToObject(Attr1, "XCoordinate", options->cells[i]->oam[j].attr1.XCoordinate); + cJSON_AddNumberToObject(Attr1, "RotationScaling", options->cells[i]->oam[j].attr1.RotationScaling); + cJSON_AddNumberToObject(Attr1, "Size", options->cells[i]->oam[j].attr1.Size); + + cJSON *Attr2 = cJSON_AddObjectToObject(OAM, "Attr2"); + + cJSON_AddNumberToObject(Attr2, "CharName", options->cells[i]->oam[j].attr2.CharName); + cJSON_AddNumberToObject(Attr2, "Priority", options->cells[i]->oam[j].attr2.Priority); + cJSON_AddNumberToObject(Attr2, "Palette", options->cells[i]->oam[j].attr2.Palette); + + cJSON_AddItemToArray(OAMArray, OAM); + } + + cJSON_AddItemToArray(cells, cell); + } + + if (options->labelEnabled) + { + cJSON *labels = cJSON_CreateStringArray((const char * const*)options->labels, options->labelCount); + cJSON_AddItemToObject(ncer, "labels", labels); + cJSON_AddNumberToObject(ncer, "labelCount", options->labelCount); + } + + if (options->vramTransferEnabled) + { + cJSON_AddNumberToObject(ncer, "vramTransferMaxSize", options->vramTransferMaxSize); + cJSON *transfers = cJSON_AddArrayToObject(ncer, "transferData"); + + for (int idx = 0; idx < options->cellCount; idx++) + { + cJSON *transfer = cJSON_CreateObject(); + cJSON_AddNumberToObject(transfer, "offset", options->transferData[idx]->sourceDataOffset); + cJSON_AddNumberToObject(transfer, "size", options->transferData[idx]->size); + cJSON_AddItemToArray(transfers, transfer); + } + } + + char *jsonString = cJSON_Print(ncer); + cJSON_Delete(ncer); + return jsonString; +} + +struct JsonToScreenOptions *ParseNSCRJson(char *path) +{ + int fileLength; + unsigned char *jsonString = ReadWholeFile(path, &fileLength); + + cJSON *json = cJSON_Parse((const char *)jsonString); + + struct JsonToScreenOptions *options = malloc(sizeof(struct JsonToScreenOptions)); + + if (json == NULL) + { + const char *errorPtr = cJSON_GetErrorPtr(); + FATAL_ERROR("Error in line \"%s\"\n", errorPtr); + } + + cJSON *Height = cJSON_GetObjectItemCaseSensitive(json, "height"); + cJSON *Width = cJSON_GetObjectItemCaseSensitive(json, "width"); + + options->height = GetInt(Height); + options->width = GetInt(Width); + + options->data = malloc(sizeof(unsigned short) * options->height * options->width); + + cJSON *layer = NULL; + cJSON *layers = cJSON_GetObjectItemCaseSensitive(json, "layers"); + int palette = 0; + cJSON *tilesets = cJSON_GetObjectItemCaseSensitive(json, "tilesets"); + int tilesetSize = 0; + if (cJSON_GetArraySize(tilesets) != 1) + { + cJSON *tileset = cJSON_GetArrayItem(tilesets, 1); + cJSON *firstGid = cJSON_GetObjectItemCaseSensitive(tileset, "firstgid"); + tilesetSize = GetInt(firstGid) - 1; + if (tilesetSize <= 1) + FATAL_ERROR("Wrong tileset index (tileset 0 should be added first)\n"); + } + + cJSON_ArrayForEach(layer, layers) + { + cJSON *tile = NULL; + cJSON *data = cJSON_GetObjectItemCaseSensitive(layer, "data"); + int i = 0; + cJSON_ArrayForEach(tile, data) + { + int tileInt = GetInt(tile) - 1; + if (tileInt != -1) + { + if (tilesetSize != 0) + { + palette = tileInt / tilesetSize; + tileInt %= tilesetSize; + } + bool vFlip = tileInt >> 30; + bool hFlip = tileInt >> 31; + tileInt |= vFlip << 11; + tileInt |= hFlip << 10; + tileInt |= palette << 12; + options->data[i] = (short) (tileInt & 0xFFFF); + } + i++; + } + } + + cJSON_Delete(json); + free(jsonString); + return options; +} + +struct JsonToAnimationOptions *ParseNANRJson(char *path) +{ + int filelength; + unsigned char *jsonString = ReadWholeFile(path, &filelength); + + cJSON *json = cJSON_Parse((const char *)jsonString); + + struct JsonToAnimationOptions *options = malloc(sizeof(struct JsonToAnimationOptions)); + + if (json == NULL) + { + const char *errorPtr = cJSON_GetErrorPtr(); + FATAL_ERROR("Error in line \"%s\"\n", errorPtr); + } + + cJSON *sequenceCount = cJSON_GetObjectItemCaseSensitive(json, "sequenceCount"); + cJSON *frameCount = cJSON_GetObjectItemCaseSensitive(json, "frameCount"); + + options->sequenceCount = GetInt(sequenceCount); + options->frameCount = GetInt(frameCount); + + options->sequenceData = malloc(sizeof(struct SequenceData *) * options->sequenceCount); + + int i; + for (i = 0; i < options->sequenceCount; i++) + { + options->sequenceData[i] = malloc(sizeof(struct SequenceData)); + } + + cJSON *sequence = NULL; + cJSON *sequences = cJSON_GetObjectItemCaseSensitive(json, "sequences"); + + i = 0; + cJSON_ArrayForEach(sequence, sequences) + { + if (i > options->sequenceCount - 1) + FATAL_ERROR("Sequence count is incorrect.\n"); + + cJSON *frameCount = cJSON_GetObjectItemCaseSensitive(sequence, "frameCount"); + cJSON *loopStartFrame = cJSON_GetObjectItemCaseSensitive(sequence, "loopStartFrame"); + cJSON *animationElement = cJSON_GetObjectItemCaseSensitive(sequence, "animationElement"); + cJSON *animationType = cJSON_GetObjectItemCaseSensitive(sequence, "animationType"); + cJSON *playbackMode = cJSON_GetObjectItemCaseSensitive(sequence, "playbackMode"); + + options->sequenceData[i]->frameCount = GetInt(frameCount); + options->sequenceData[i]->loopStartFrame = GetInt(loopStartFrame); + options->sequenceData[i]->animationElement = GetInt(animationElement); + options->sequenceData[i]->animationType = GetInt(animationType); + options->sequenceData[i]->playbackMode = GetInt(playbackMode); + + options->sequenceData[i]->frameData = malloc(sizeof(struct FrameData *) * options->sequenceData[i]->frameCount); + int j; + for (j = 0; j < options->sequenceData[i]->frameCount; j++) + { + options->sequenceData[i]->frameData[j] = malloc(sizeof(struct FrameData)); + } + + j = 0; + cJSON *frame = NULL; + cJSON *frameData = cJSON_GetObjectItemCaseSensitive(sequence, "frameData"); + + cJSON_ArrayForEach(frame, frameData) + { + if (j > options->sequenceData[i]->frameCount - 1) + FATAL_ERROR("Sequence frame count is incorrect.\n"); + + cJSON *frameDelay = cJSON_GetObjectItemCaseSensitive(frame, "frameDelay"); + cJSON *resultId = cJSON_GetObjectItemCaseSensitive(frame, "resultId"); + + options->sequenceData[i]->frameData[j]->frameDelay = GetInt(frameDelay); + options->sequenceData[i]->frameData[j]->resultId = GetInt(resultId); + + j++; + } + + i++; + } + + //todo implement extended attributes + + cJSON *resultCount = cJSON_GetObjectItemCaseSensitive(json, "resultCount"); + + options->resultCount = GetInt(resultCount); + + options->animationResults = malloc(sizeof(struct AnimationResults *) * options->resultCount); + + for (i = 0; i < options->resultCount; i++) + { + options->animationResults[i] = malloc(sizeof(struct AnimationResults)); + } + + i = 0; + + cJSON *animationResult = NULL; + cJSON *animationResults = cJSON_GetObjectItemCaseSensitive(json, "animationResults"); + cJSON_ArrayForEach(animationResult, animationResults) + { + if (i > options->resultCount - 1) + FATAL_ERROR("Frame count is incorrect.\n"); + + cJSON *resultType = cJSON_GetObjectItemCaseSensitive(animationResult, "resultType"); + options->animationResults[i]->resultType = GetInt(resultType); + switch (options->animationResults[i]->resultType) { + case 0: { //index + cJSON *index = cJSON_GetObjectItemCaseSensitive(animationResult, "index"); + options->animationResults[i]->index = GetInt(index); + break; + } + + case 1: { //SRT + cJSON *index = cJSON_GetObjectItemCaseSensitive(animationResult, "index"); + cJSON *rotation = cJSON_GetObjectItemCaseSensitive(animationResult, "rotation"); + cJSON *scaleX = cJSON_GetObjectItemCaseSensitive(animationResult, "scaleX"); + cJSON *scaleY = cJSON_GetObjectItemCaseSensitive(animationResult, "scaleY"); + cJSON *positionX = cJSON_GetObjectItemCaseSensitive(animationResult, "positionX"); + cJSON *positionY = cJSON_GetObjectItemCaseSensitive(animationResult, "positionY"); + + options->animationResults[i]->dataSrt.index = GetInt(index); + options->animationResults[i]->dataSrt.rotation = GetInt(rotation); + options->animationResults[i]->dataSrt.scaleX = GetInt(scaleX); + options->animationResults[i]->dataSrt.scaleY = GetInt(scaleY); + options->animationResults[i]->dataSrt.positionX = GetInt(positionX); + options->animationResults[i]->dataSrt.positionY = GetInt(positionY); + break; + } + + case 2: { //T + cJSON *index = cJSON_GetObjectItemCaseSensitive(animationResult, "index"); + //cJSON *rotation = cJSON_GetObjectItemCaseSensitive(animationResult, "rotation"); + cJSON *positionX = cJSON_GetObjectItemCaseSensitive(animationResult, "positionX"); + cJSON *positionY = cJSON_GetObjectItemCaseSensitive(animationResult, "positionY"); + + options->animationResults[i]->dataT.index = GetInt(index); + //options->animationResults[i]->dataSrt.rotation = GetInt(rotation); + options->animationResults[i]->dataT.positionX = GetInt(positionX); + options->animationResults[i]->dataT.positionY = GetInt(positionY); + break; + } + } + + i++; + } + + cJSON *labelBool = cJSON_GetObjectItemCaseSensitive(json, "labelEnabled"); + options->labelEnabled = GetBool(labelBool); + + if (options->labelEnabled) + { + cJSON *labelCount = cJSON_GetObjectItemCaseSensitive(json, "labelCount"); + options->labelCount = GetInt(labelCount); + options->labels = malloc(sizeof(char *) * options->labelCount); + + cJSON *labels = cJSON_GetObjectItemCaseSensitive(json, "labels"); + cJSON *label = NULL; + + int j = 0; + cJSON_ArrayForEach(label, labels) + { + char *labelString = GetString(label); + options->labels[j] = malloc(strlen(labelString) + 1); + strcpy(options->labels[j], labelString); + j++; + } + } + + cJSON_Delete(json); + free(jsonString); + return options; +} + +char *GetNANRJson(struct JsonToAnimationOptions *options) +{ + cJSON *nanr = cJSON_CreateObject(); + + cJSON_AddBoolToObject(nanr, "labelEnabled", options->labelEnabled); + cJSON_AddNumberToObject(nanr, "sequenceCount", options->sequenceCount); + cJSON_AddNumberToObject(nanr, "frameCount", options->frameCount); + + cJSON *sequences = cJSON_AddArrayToObject(nanr, "sequences"); + + for (int i = 0; i < options->sequenceCount; i++) + { + cJSON *sequence = cJSON_CreateObject(); + cJSON_AddNumberToObject(sequence, "frameCount", options->sequenceData[i]->frameCount); + cJSON_AddNumberToObject(sequence, "loopStartFrame", options->sequenceData[i]->loopStartFrame); + cJSON_AddNumberToObject(sequence, "animationElement", options->sequenceData[i]->animationElement); + cJSON_AddNumberToObject(sequence, "animationType", options->sequenceData[i]->animationType); + cJSON_AddNumberToObject(sequence, "playbackMode", options->sequenceData[i]->playbackMode); + + cJSON *frameData = cJSON_AddArrayToObject(sequence, "frameData"); + + for (int j = 0; j < options->sequenceData[i]->frameCount; j++) + { + cJSON *frame = cJSON_CreateObject(); + cJSON_AddNumberToObject(frame, "frameDelay", options->sequenceData[i]->frameData[j]->frameDelay); + cJSON_AddNumberToObject(frame, "resultId", options->sequenceData[i]->frameData[j]->resultId); + cJSON_AddItemToArray(frameData, frame); + } + + cJSON_AddItemToArray(sequences, sequence); + } + + cJSON *animationResults = cJSON_AddArrayToObject(nanr, "animationResults"); + + for (int i = 0; i < options->resultCount; i++) + { + cJSON *animationResult = cJSON_CreateObject(); + cJSON_AddNumberToObject(animationResult, "resultType", options->animationResults[i]->resultType); + + switch (options->animationResults[i]->resultType) + { + case 0: //index + cJSON_AddNumberToObject(animationResult, "index", options->animationResults[i]->index); + break; + + case 1: //SRT + cJSON_AddNumberToObject(animationResult, "index", options->animationResults[i]->dataSrt.index); + cJSON_AddNumberToObject(animationResult, "rotation", options->animationResults[i]->dataSrt.rotation); + cJSON_AddNumberToObject(animationResult, "scaleX", options->animationResults[i]->dataSrt.scaleX); + cJSON_AddNumberToObject(animationResult, "scaleY", options->animationResults[i]->dataSrt.scaleY); + cJSON_AddNumberToObject(animationResult, "positionX", options->animationResults[i]->dataSrt.positionX); + cJSON_AddNumberToObject(animationResult, "positionY", options->animationResults[i]->dataSrt.positionY); + break; + + case 2: //T + cJSON_AddNumberToObject(animationResult, "index", options->animationResults[i]->dataT.index); + cJSON_AddNumberToObject(animationResult, "positionX", options->animationResults[i]->dataT.positionX); + cJSON_AddNumberToObject(animationResult, "positionY", options->animationResults[i]->dataT.positionY); + break; + } + + cJSON_AddItemToArray(animationResults, animationResult); + } + + cJSON_AddNumberToObject(nanr, "resultCount", options->resultCount); + + if (options->labelEnabled) + { + cJSON *labels = cJSON_CreateStringArray((const char * const*)options->labels, options->labelCount); + cJSON_AddItemToObject(nanr, "labels", labels); + + cJSON_AddNumberToObject(nanr, "labelCount", options->labelCount); + } + + char *jsonString = cJSON_Print(nanr); + cJSON_Delete(nanr); + return jsonString; +} + +void FreeNCERCell(struct JsonToCellOptions *options) +{ + for (int i = 0; i < options->cellCount; i++) + { + free(options->cells[i]->oam); + free(options->cells[i]); + } + if (options->labelEnabled) + { + for (int j = 0; j < options->labelCount; j++) + { + free(options->labels[j]); + } + free(options->labels); + } + if (options->vramTransferEnabled) + { + for (int j = 0; j < options->cellCount; j++) + { + free(options->transferData[j]); + } + free(options->transferData); + } + free(options->cells); + free(options); +} + +void FreeNSCRScreen(struct JsonToScreenOptions *options) +{ + free(options->data); + free(options); +} + + +void FreeNANRAnimation(struct JsonToAnimationOptions *options) +{ + for (int i = 0; i < options->sequenceCount; i++) + { + for (int j = 0; j < options->sequenceData[i]->frameCount; j++) + { + free(options->sequenceData[i]->frameData[j]); + } + free(options->sequenceData[i]->frameData); + free(options->sequenceData[i]); + } + for (int i = 0; i < options->resultCount; i++) + { + free(options->animationResults[i]); + } + if (options->labelEnabled) + { + for (int j = 0; j < options->labelCount; j++) + { + free(options->labels[j]); + } + free(options->labels); + } + free(options->sequenceData); + free(options->animationResults); + free(options); +} + +char *GetNtrFontMetadataJson(struct NtrFontMetadata *metadata) +{ + cJSON *json = cJSON_CreateObject(); + + cJSON_AddNumberToObject(json, "maxGlyphWidth", metadata->maxWidth); + cJSON_AddNumberToObject(json, "maxGlyphHeight", metadata->maxHeight); + + cJSON *glyphWidths = cJSON_AddArrayToObject(json, "glyphWidths"); + for (int i = 0; i < metadata->numGlyphs; i++) + { + cJSON *width = cJSON_CreateNumber(metadata->glyphWidthTable[i]); + cJSON_AddItemToArray(glyphWidths, width); + } + + char *jsonString = cJSON_Print(json); + cJSON_Delete(json); + return jsonString; +} + +#define TILE_DIMENSION_PIXELS 8 +#define PIXELS_FOR_DIMENSION(dim) ((dim) * TILE_DIMENSION_PIXELS) +#define TILES_FOR_PIXELS(num) (((num) + TILE_DIMENSION_PIXELS - 1) / TILE_DIMENSION_PIXELS) +#define PIXELS_PER_BYTE_2BPP 4 +#define NTR_FONT_HEADER_SIZE 16 + +struct NtrFontMetadata *ParseNtrFontMetadataJson(char *path) +{ + int fileLength; + unsigned char *jsonString = ReadWholeFile(path, &fileLength); + + cJSON *json = cJSON_Parse((const char *)jsonString); + if (json == NULL) + { + const char *errorPtr = cJSON_GetErrorPtr(); + FATAL_ERROR("Error in line \"%s\"\n", errorPtr); + } + + cJSON *labelMaxGlyphWidth = cJSON_GetObjectItemCaseSensitive(json, "maxGlyphWidth"); + cJSON *labelMaxGlyphHeight = cJSON_GetObjectItemCaseSensitive(json, "maxGlyphHeight"); + cJSON *labelGlyphWidths = cJSON_GetObjectItemCaseSensitive(json, "glyphWidths"); + int numGlyphs = cJSON_GetArraySize(labelGlyphWidths); + + struct NtrFontMetadata *metadata = malloc(sizeof(struct NtrFontMetadata)); + + metadata->size = NTR_FONT_HEADER_SIZE; + metadata->numGlyphs = numGlyphs; + metadata->maxWidth = GetInt(labelMaxGlyphWidth); + metadata->maxHeight = GetInt(labelMaxGlyphHeight); + + metadata->glyphWidth = TILES_FOR_PIXELS(metadata->maxWidth); + metadata->glyphHeight = TILES_FOR_PIXELS(metadata->maxHeight); + + int glyphBitmapSize = (PIXELS_FOR_DIMENSION(metadata->glyphWidth) * PIXELS_FOR_DIMENSION(metadata->glyphHeight)) / PIXELS_PER_BYTE_2BPP; + metadata->widthTableOffset = metadata->size + (metadata->numGlyphs * glyphBitmapSize); + + metadata->glyphWidthTable = malloc(metadata->numGlyphs); + + uint8_t *glyphWidthCursor = metadata->glyphWidthTable; + cJSON *glyphWidthIter = NULL; + cJSON_ArrayForEach(glyphWidthIter, labelGlyphWidths) + { + if (!cJSON_IsNumber(glyphWidthIter)) + { + const char *errorPtr = cJSON_GetErrorPtr(); + FATAL_ERROR("Error in line \"%s\"\n", errorPtr); + } + + *glyphWidthCursor = glyphWidthIter->valueint; + glyphWidthCursor++; + } + + cJSON_Delete(json); + free(jsonString); + return metadata; +} diff --git a/tools/nitrogfx/json.h b/tools/nitrogfx/json.h new file mode 100644 index 0000000000..8bdf307ff7 --- /dev/null +++ b/tools/nitrogfx/json.h @@ -0,0 +1,19 @@ +// Copyright (c) 2021-2024 red031000 + +#ifndef JSON_H +#define JSON_H + +#include "options.h" + +struct JsonToCellOptions *ParseNCERJson(char *path); +char *GetNCERJson(struct JsonToCellOptions *options); +struct JsonToScreenOptions *ParseNSCRJson(char *path); +struct JsonToAnimationOptions *ParseNANRJson(char *path); +char *GetNANRJson(struct JsonToAnimationOptions *options); +void FreeNCERCell(struct JsonToCellOptions *options); +void FreeNSCRScreen(struct JsonToScreenOptions *options); +void FreeNANRAnimation(struct JsonToAnimationOptions *options); +char *GetNtrFontMetadataJson(struct NtrFontMetadata *metadata); +struct NtrFontMetadata *ParseNtrFontMetadataJson(char *path); + +#endif //JSON_H diff --git a/tools/nitrogfx/lz.c b/tools/nitrogfx/lz.c new file mode 100644 index 0000000000..e9bea861d5 --- /dev/null +++ b/tools/nitrogfx/lz.c @@ -0,0 +1,190 @@ +// Copyright (c) 2015 YamaArashi + +#include +#include +#include +#include +#include "global.h" +#include "lz.h" + +unsigned char *LZDecompress(unsigned char *src, int srcSize, int *uncompressedSize) +{ + if (srcSize < 4) + goto fail; + + int destSize = (src[3] << 16) | (src[2] << 8) | src[1]; + + unsigned char *dest = malloc(destSize); + + if (dest == NULL) + goto fail; + + int srcPos = 4; + int destPos = 0; + + for (;;) { + if (srcPos >= srcSize) + goto fail; + + unsigned char flags = src[srcPos++]; + + for (int i = 0; i < 8; i++) { + if (flags & 0x80) { + if (srcPos + 1 >= srcSize) + goto fail; + + int blockSize = (src[srcPos] >> 4) + 3; + int blockDistance = (((src[srcPos] & 0xF) << 8) | src[srcPos + 1]) + 1; + + srcPos += 2; + + int blockPos = destPos - blockDistance; + + // Some Ruby/Sapphire tilesets overflow. + if (destPos + blockSize > destSize) { + blockSize = destSize - destPos; + fprintf(stderr, "Destination buffer overflow.\n"); + } + + if (blockPos < 0) + goto fail; + + for (int j = 0; j < blockSize; j++) + dest[destPos++] = dest[blockPos + j]; + } else { + if (srcPos >= srcSize || destPos >= destSize) + goto fail; + + dest[destPos++] = src[srcPos++]; + } + + if (destPos == destSize) { + *uncompressedSize = destSize; + return dest; + } + + flags <<= 1; + } + } + +fail: + FATAL_ERROR("Fatal error while decompressing LZ file.\n"); +} + +static void FindBestBlockForwards(unsigned char *src, int srcPos, int srcSize, const int minDistance, int *outBestBlockDistance, int *outBestBlockSize) +{ + int blockStart = srcPos < 0x1000 ? 0 : srcPos - 0x1000; + while (blockStart != srcPos) { + int blockSize = 0; + + while (blockSize < 18 + && srcPos + blockSize < srcSize + && src[blockStart + blockSize] == src[srcPos + blockSize]) + blockSize++; + + if (blockSize > *outBestBlockSize + && srcPos - blockStart >= minDistance) { + *outBestBlockDistance = srcPos - blockStart; + *outBestBlockSize = blockSize; + + if (blockSize == 18) + break; + } + + blockStart++; + } +} + +static void FindBestBlockBackwards(unsigned char *src, int srcPos, int srcSize, const int minDistance, int *outBestBlockDistance, int *outBestBlockSize) +{ + int blockDistance = minDistance; + + while (blockDistance <= srcPos && blockDistance <= 0x1000) { + int blockStart = srcPos - blockDistance; + int blockSize = 0; + + while (blockSize < 18 + && srcPos + blockSize < srcSize + && src[blockStart + blockSize] == src[srcPos + blockSize]) + blockSize++; + + if (blockSize > *outBestBlockSize) { + *outBestBlockDistance = blockDistance; + *outBestBlockSize = blockSize; + + if (blockSize == 18) + break; + } + + blockDistance++; + } +} + +typedef void (*FindBestBlockFunc)(unsigned char *src, int srcPos, int srcSize, const int minDistance, int *outBestBlockDistance, int *outBestBlockSize); + +unsigned char *LZCompress(unsigned char *src, int srcSize, int *compressedSize, const int minDistance, bool forwardIteration, bool pad) +{ + if (srcSize <= 0) + goto fail; + + int worstCaseDestSize = 4 + srcSize + ((srcSize + 7) / 8); + + // Round up to the next multiple of four. + worstCaseDestSize = (worstCaseDestSize + 3) & ~3; + + unsigned char *dest = malloc(worstCaseDestSize); + + if (dest == NULL) + goto fail; + + // header + dest[0] = 0x10; // LZ compression type + dest[1] = (unsigned char)srcSize; + dest[2] = (unsigned char)(srcSize >> 8); + dest[3] = (unsigned char)(srcSize >> 16); + + int srcPos = 0; + int destPos = 4; + FindBestBlockFunc FindBestBlock = forwardIteration ? FindBestBlockForwards : FindBestBlockBackwards; + + for (;;) { + unsigned char *flags = &dest[destPos++]; + *flags = 0; + + for (int i = 0; i < 8; i++) { + int bestBlockDistance = 0; + int bestBlockSize = 0; + + FindBestBlock(src, srcPos, srcSize, minDistance, &bestBlockDistance, &bestBlockSize); + + if (bestBlockSize >= 3) { + *flags |= (0x80 >> i); + srcPos += bestBlockSize; + bestBlockSize -= 3; + bestBlockDistance--; + dest[destPos++] = (bestBlockSize << 4) | ((unsigned int)bestBlockDistance >> 8); + dest[destPos++] = (unsigned char)bestBlockDistance; + } else { + dest[destPos++] = src[srcPos++]; + } + + if (srcPos == srcSize) { + if (pad) { + // Pad to multiple of 4 bytes. + int remainder = destPos % 4; + + if (remainder != 0) { + for (int i = 0; i < 4 - remainder; i++) + dest[destPos++] = 0; + } + } + + *compressedSize = destPos; + return dest; + } + } + } + +fail: + FATAL_ERROR("Fatal error while compressing LZ file.\n"); +} diff --git a/tools/nitrogfx/lz.h b/tools/nitrogfx/lz.h new file mode 100644 index 0000000000..21f18a829e --- /dev/null +++ b/tools/nitrogfx/lz.h @@ -0,0 +1,11 @@ +// Copyright (c) 2015 YamaArashi + +#ifndef LZ_H +#define LZ_H + +#include "stdbool.h" + +unsigned char *LZDecompress(unsigned char *src, int srcSize, int *uncompressedSize); +unsigned char *LZCompress(unsigned char *src, int srcSize, int *compressedSize, const int minDistance, bool forwardIteration, bool pad); + +#endif // LZ_H diff --git a/tools/nitrogfx/main.c b/tools/nitrogfx/main.c new file mode 100644 index 0000000000..304cb93fb4 --- /dev/null +++ b/tools/nitrogfx/main.c @@ -0,0 +1,1413 @@ +// Copyright (c) 2015 YamaArashi, 2021-2024 red031000 + +#include +#include +#include +#include +#include "global.h" +#include "util.h" +#include "options.h" +#include "gfx.h" +#include "convert_png.h" +#include "jasc_pal.h" +#include "lz.h" +#include "rl.h" +#include "font.h" +#include "huff.h" +#include "json.h" + +struct CommandHandler +{ + const char *inputFileExtension; + const char *outputFileExtension; + void(*function)(char *inputPath, char *outputPath, int argc, char **argv); +}; + +static int CountLzCompressArgs(int argc, char **argv); +static void HandleLZCompressCommand(char *inputPath, char *outputPath, int argc, char **argv); +static void HandleLZDecompressCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED); + +void ConvertGbaToPng(char *inputPath, char *outputPath, struct GbaToPngOptions *options) +{ + struct Image image; + + if (options->paletteFilePath != NULL) + { + ReadGbaPalette(options->paletteFilePath, &image.palette); + image.hasPalette = true; + } + else + { + image.hasPalette = false; + } + + ReadImage(inputPath, options->width, options->bitDepth, options->colsPerChunk, options->rowsPerChunk, &image, !image.hasPalette); + + image.hasTransparency = options->hasTransparency; + + WritePng(outputPath, &image); + + FreeImage(&image); +} + +void ConvertNtrToPng(char *inputPath, char *outputPath, struct NtrToPngOptions *options) +{ + // handle empty files if possible + if (options->handleEmpty) + { + FILE *fp = fopen(inputPath, "rb"); + if (fp != NULL) + { + fseek(fp, 0, SEEK_END); + uint32_t size = ftell(fp); + rewind(fp); + if (size == 0) + { + FILE *out = fopen(outputPath, "wb+"); + if (out != NULL) + { + fclose(out); + } + fclose(fp); + return; + } + fclose(fp); + } + } + + struct Image image; + + if (options->paletteFilePath != NULL) + { + ReadNtrPalette(options->paletteFilePath, &image.palette, options->bitDepth, options->palIndex, false); + image.hasPalette = true; + } + else + { + image.hasPalette = false; + } + + uint32_t key = ReadNtrImage(inputPath, options->width, 0, options->colsPerChunk, options->rowsPerChunk, &image, !image.hasPalette, options->scanFrontToBack); + + if (key) + { + char* string = malloc(strlen(outputPath) + 5); + sprintf(string, "%s.key", outputPath); + FILE *fp = fopen(string, "wb"); + if (fp == NULL) + FATAL_ERROR("Failed to open key file for writing.\n"); + fwrite(&key, 4, 1, fp); + fclose(fp); + free(string); + } + + image.hasTransparency = options->hasTransparency; + + if (options->cellFilePath != NULL) + { + ApplyCellsToImage(options->cellFilePath, &image, true); + } + + WritePng(outputPath, &image); + + FreeImage(&image); +} + +void ConvertPngToGba(char *inputPath, char *outputPath, struct PngToGbaOptions *options) +{ + struct Image image; + + image.bitDepth = options->bitDepth; + + ReadPng(inputPath, &image); + + WriteImage(outputPath, options->numTiles, options->bitDepth, options->colsPerChunk, options->rowsPerChunk, &image, !image.hasPalette); + + FreeImage(&image); +} + +void ConvertPngToNtr(char *inputPath, char *outputPath, struct PngToNtrOptions *options) +{ + // handle empty files if possible + if (options->handleEmpty) + { + FILE *fp = fopen(inputPath, "rb"); + if (fp != NULL) + { + fseek(fp, 0, SEEK_END); + uint32_t size = ftell(fp); + rewind(fp); + if (size == 0) + { + FILE *out = fopen(outputPath, "wb+"); + if (out != NULL) + { + fclose(out); + } + fclose(fp); + return; + } + fclose(fp); + } + } + + struct Image image; + + image.bitDepth = options->bitDepth == 0 ? 4 : options->bitDepth; + + ReadPng(inputPath, &image); + + uint32_t key = 0; + if (options->scanMode) + { + char* string = malloc(strlen(inputPath) + 5); + sprintf(string, "%s.key", inputPath); + FILE *fp = fopen(string, "rb"); + if (fp == NULL) + FATAL_ERROR("Failed to open key file for reading.\n"); + size_t count = fread(&key, 4, 1, fp); + if (count != 1) + FATAL_ERROR("Not a valid key file.\n"); + fclose(fp); + free(string); + } + + options->bitDepth = options->bitDepth == 0 ? image.bitDepth : options->bitDepth; + + if (options->cellFilePath != NULL) + { + ApplyCellsToImage(options->cellFilePath, &image, false); + } + + WriteNtrImage(outputPath, options->numTiles, options->bitDepth, options->colsPerChunk, options->rowsPerChunk, + &image, !image.hasPalette, options->clobberSize, options->byteOrder, options->version101, + options->sopc, options->vramTransfer, options->scanMode, options->mappingType, key, options->wrongSize); + + FreeImage(&image); +} + +void HandleGbaToPngCommand(char *inputPath, char *outputPath, int argc, char **argv) +{ + char *inputFileExtension = GetFileExtension(inputPath); + struct GbaToPngOptions options; + options.paletteFilePath = NULL; + if (isdigit((unsigned char)inputFileExtension[0])) + options.bitDepth = inputFileExtension[0] - '0'; + else + options.bitDepth = 4; + options.hasTransparency = false; + options.width = 1; + options.colsPerChunk = 1; + options.rowsPerChunk = 1; + + for (int i = 3; i < argc; i++) + { + char *option = argv[i]; + + if (strcmp(option, "-palette") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No palette file path following \"-palette\".\n"); + + i++; + + options.paletteFilePath = argv[i]; + } + else if (strcmp(option, "-object") == 0) + { + options.hasTransparency = true; + } + else if (strcmp(option, "-width") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No width following \"-width\".\n"); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &options.width)) + FATAL_ERROR("Failed to parse width.\n"); + + if (options.width < 1) + FATAL_ERROR("Width must be positive.\n"); + } + else if (strcmp(option, "-mwidth") == 0 || strcmp(option, "-cpc") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No columns per chunk value following \"%s\".\n", option); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &options.colsPerChunk)) + FATAL_ERROR("Failed to parse columns per chunk.\n"); + + if (options.colsPerChunk < 1) + FATAL_ERROR("columns per chunk must be positive.\n"); + } + else if (strcmp(option, "-mheight") == 0 || strcmp(option, "-rpc") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No rows per chunk value following \"%s\".\n", option); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &options.rowsPerChunk)) + FATAL_ERROR("Failed to parse rows per chunk.\n"); + + if (options.rowsPerChunk < 1) + FATAL_ERROR("rows per chunk must be positive.\n"); + } + else + { + FATAL_ERROR("Unrecognized option \"%s\".\n", option); + } + } + + if (options.colsPerChunk > options.width) + options.width = options.colsPerChunk; + + ConvertGbaToPng(inputPath, outputPath, &options); +} + +void HandleNtrToPngCommand(char *inputPath, char *outputPath, int argc, char **argv) +{ + struct NtrToPngOptions options; + options.paletteFilePath = NULL; + options.cellFilePath = NULL; + options.hasTransparency = false; + options.width = 0; + options.colsPerChunk = 1; + options.rowsPerChunk = 1; + options.palIndex = 1; + options.scanFrontToBack = false; + options.handleEmpty = false; + + for (int i = 3; i < argc; i++) + { + char *option = argv[i]; + + if (strcmp(option, "-palette") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No palette file path following \"-palette\".\n"); + + i++; + + options.paletteFilePath = argv[i]; + } + else if (strcmp(option, "-cell") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No cell file path following \"-cell\".\n"); + + i++; + + options.cellFilePath = argv[i]; + } + else if (strcmp(option, "-object") == 0) + { + options.hasTransparency = true; + } + else if (strcmp(option, "-palindex") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No palette index following \"-palindex\".\n"); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &options.palIndex)) + FATAL_ERROR("Failed to parse palette index.\n"); + + if (options.palIndex < 1) + FATAL_ERROR("Palette index must be positive.\n"); + } + else if (strcmp(option, "-width") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No width following \"-width\".\n"); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &options.width)) + FATAL_ERROR("Failed to parse width.\n"); + + if (options.width < 1) + FATAL_ERROR("Width must be positive.\n"); + } + else if (strcmp(option, "-mwidth") == 0 || strcmp(option, "-cpc") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No columns per chunk value following \"%s\".\n", option); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &options.colsPerChunk)) + FATAL_ERROR("Failed to parse columns per chunk.\n"); + + if (options.colsPerChunk < 1) + FATAL_ERROR("columns per chunk must be positive.\n"); + } + else if (strcmp(option, "-mheight") == 0 || strcmp(option, "-rpc") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No rows per chunk value following \"%s\".\n", option); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &options.rowsPerChunk)) + FATAL_ERROR("Failed to parse rows per chunk.\n"); + + if (options.rowsPerChunk < 1) + FATAL_ERROR("rows per chunk must be positive.\n"); + } + else if (strcmp(option, "-scanfronttoback") == 0) + { + options.scanFrontToBack = true; + } + else if (strcmp(option, "-handleempty") == 0) + { + options.handleEmpty = true; + } + else + { + FATAL_ERROR("Unrecognized option \"%s\".\n", option); + } + } + + if (options.width != 0 && options.colsPerChunk > options.width) + options.width = options.colsPerChunk; + + ConvertNtrToPng(inputPath, outputPath, &options); +} + +void HandleNtrLzToPngCommand(char *inputPath, char *outputPath, int argc, char **argv) +{ + HandleLZDecompressCommand(inputPath, outputPath, argc, argv); + + HandleNtrToPngCommand(outputPath, outputPath, argc, argv); +} + +void HandlePngToGbaCommand(char *inputPath, char *outputPath, int argc, char **argv) +{ + char *outputFileExtension = GetFileExtension(outputPath); + int bitDepth; + if (strcmp(outputFileExtension, "nbfc") == 0) + bitDepth = 4; + else + bitDepth = outputFileExtension[0] - '0'; + struct PngToGbaOptions options; + options.numTiles = 0; + options.bitDepth = bitDepth; + options.colsPerChunk = 1; + options.rowsPerChunk = 1; + + for (int i = 3; i < argc; i++) + { + char *option = argv[i]; + + if (strcmp(option, "-num_tiles") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No number of tiles following \"-num_tiles\".\n"); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &options.numTiles)) + FATAL_ERROR("Failed to parse number of tiles.\n"); + + if (options.numTiles < 1) + FATAL_ERROR("Number of tiles must be positive.\n"); + } + else if (strcmp(option, "-mwidth") == 0 || strcmp(option, "-cpc") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No columns per chunk value following \"%s\".\n", option); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &options.colsPerChunk)) + FATAL_ERROR("Failed to parse columns per chunk.\n"); + + if (options.colsPerChunk < 1) + FATAL_ERROR("columns per chunk must be positive.\n"); + } + else if (strcmp(option, "-mheight") == 0 || strcmp(option, "-rpc") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No rows per chunk value following \"%s\".\n", option); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &options.rowsPerChunk)) + FATAL_ERROR("Failed to parse rows per chunk.\n"); + + if (options.rowsPerChunk < 1) + FATAL_ERROR("rows per chunk must be positive.\n"); + } + else + { + FATAL_ERROR("Unrecognized option \"%s\".\n", option); + } + } + + ConvertPngToGba(inputPath, outputPath, &options); +} + +void HandlePngToNtrCommand(char *inputPath, char *outputPath, int argc, char **argv) +{ + struct PngToNtrOptions options; + options.cellFilePath = NULL; + options.numTiles = 0; + options.bitDepth = 0; + options.colsPerChunk = 1; + options.rowsPerChunk = 1; + options.wrongSize = false; + options.clobberSize = false; + options.byteOrder = true; + options.version101 = false; + options.sopc = false; + options.scanMode = 0; + options.handleEmpty = false; + options.vramTransfer = false; + options.mappingType = 0; + + for (int i = 3; i < argc; i++) + { + char *option = argv[i]; + + if (strcmp(option, "-num_tiles") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No number of tiles following \"-num_tiles\".\n"); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &options.numTiles)) + FATAL_ERROR("Failed to parse number of tiles.\n"); + + if (options.numTiles < 1) + FATAL_ERROR("Number of tiles must be positive.\n"); + } + else if (strcmp(option, "-cell") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No cell file path following \"-cell\".\n"); + + i++; + + options.cellFilePath = argv[i]; + } + else if (strcmp(option, "-mwidth") == 0 || strcmp(option, "-cpc") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No columns per chunk value following \"%s\".\n", option); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &options.colsPerChunk)) + FATAL_ERROR("Failed to parse columns per chunk.\n"); + + if (options.colsPerChunk < 1) + FATAL_ERROR("columns per chunk must be positive.\n"); + } + else if (strcmp(option, "-mheight") == 0 || strcmp(option, "-rpc") == 0) { + if (i + 1 >= argc) + FATAL_ERROR("No rows per chunk value following \"%s\".\n", option); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &options.rowsPerChunk)) + FATAL_ERROR("Failed to parse rows per chunk.\n"); + + if (options.rowsPerChunk < 1) + FATAL_ERROR("rows per chunk must be positive.\n"); + } + else if (strcmp(option, "-bitdepth") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No bitdepth value following \"-bitdepth\".\n"); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &options.bitDepth)) + FATAL_ERROR("Failed to parse bitdepth.\n"); + + if (options.bitDepth != 4 && options.bitDepth != 8) + FATAL_ERROR("bitdepth must be either 4 or 8.\n"); + } + else if (strcmp(option, "-clobbersize") == 0) + { + options.clobberSize = true; + } + else if (strcmp(option, "-nobyteorder") == 0) + { + options.byteOrder = false; + } + else if (strcmp(option, "-version101") == 0) + { + options.version101 = true; + } + else if (strcmp(option, "-sopc") == 0) + { + options.sopc = true; + } + else if (strcmp(option, "-scanned") == 0) + { + if (options.scanMode != 0) + FATAL_ERROR("Scan mode specified more than once.\n-scanned goes back to front as in DP, -scanfronttoback goes front to back as in PtHGSS\n"); + options.scanMode = 1; + } + else if (strcmp(option, "-scanfronttoback") == 0) + { + if (options.scanMode != 0) + FATAL_ERROR("Scan mode specified more than once.\n-scanned goes back to front as in DP, -scanfronttoback goes front to back as in PtHGSS\n"); + options.scanMode = 2; + } + else if (strcmp(option, "-wrongsize") == 0) { + options.wrongSize = true; + } + else if (strcmp(option, "-handleempty") == 0) + { + options.handleEmpty = true; + } + else if (strcmp(option, "-vram") == 0) + { + options.vramTransfer = true; + } + else if (strcmp(option, "-mappingtype") == 0) { + if (i + 1 >= argc) + FATAL_ERROR("No mapping type value following \"-mappingtype\".\n"); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &options.mappingType)) + FATAL_ERROR("Failed to parse mapping type.\n"); + + if (options.mappingType != 0 && options.mappingType != 32 && options.mappingType != 64 && options.mappingType != 128 && options.mappingType != 256) + FATAL_ERROR("bitdepth must be one of the following: 0, 32, 64, 128, or 256\n"); + } + else + { + FATAL_ERROR("Unrecognized option \"%s\".\n", option); + } + } + + ConvertPngToNtr(inputPath, outputPath, &options); +} + +void HandlePngToNtrLzCommand(char *inputPath, char *outputPath, int argc, char **argv) +{ + int numLzArgs = CountLzCompressArgs(argc, argv); + + HandlePngToNtrCommand(inputPath, outputPath, argc - numLzArgs, argv); + + HandleLZCompressCommand(outputPath, outputPath, 3 + numLzArgs, &(argv[argc - 3 - numLzArgs])); +} + +void HandlePngToGbaPaletteCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED) +{ + struct Palette palette; + + ReadPngPalette(inputPath, &palette); + WriteGbaPalette(outputPath, &palette); +} + +void HandlePngToNtrPaletteCommand(char *inputPath, char *outputPath, int argc, char **argv) +{ + struct Palette palette; + bool ncpr = false; + bool ir = false; + bool nopad = false; + int bitdepth = 0; + int compNum = 0; + bool pcmp = false; + bool inverted = false; + + for (int i = 3; i < argc; i++) + { + char *option = argv[i]; + + if (strcmp(option, "-ncpr") == 0) + { + ncpr = true; + } + else if (strcmp(option, "-ir") == 0) + { + ir = true; + } + else if (strcmp(option, "-nopad") == 0) + { + nopad = true; + } + else if (strcmp(option, "-bitdepth") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No bitdepth following \"-bitdepth\".\n"); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &bitdepth)) + FATAL_ERROR("Failed to parse bitdepth.\n"); + + if (bitdepth != 4 && bitdepth != 8) + FATAL_ERROR("Bitdepth must be 4 or 8.\n"); + } + else if (strcmp(option, "-comp") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No compression value following \"-comp\".\n"); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &compNum)) + FATAL_ERROR("Failed to parse compression value.\n"); + + if (compNum > 255) + FATAL_ERROR("Compression value must be 255 or below.\n"); + } + else if (strcmp(option, "-pcmp") == 0) + { + pcmp = true; + } + else if (strcmp(option, "-invertsize") == 0) + { + inverted = true; + } + else + { + FATAL_ERROR("Unrecognized option \"%s\".\n", option); + } + } + + ReadPngPalette(inputPath, &palette); + WriteNtrPalette(outputPath, &palette, ncpr, ir, bitdepth, !nopad, compNum, pcmp, inverted); +} + +void HandleGbaToJascPaletteCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED) +{ + struct Palette palette; + + ReadGbaPalette(inputPath, &palette); + WriteJascPalette(outputPath, &palette); +} + +void HandleNtrToJascPaletteCommand(char *inputPath, char *outputPath, int argc, char **argv) +{ + struct Palette palette; + int bitdepth = 0; + bool inverted = false; + + for (int i = 3; i < argc; i++) + { + char *option = argv[i]; + + if (strcmp(option, "-bitdepth") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No bitdepth following \"-bitdepth\".\n"); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &bitdepth)) + FATAL_ERROR("Failed to parse bitdepth.\n"); + + if (bitdepth != 4 && bitdepth != 8) + FATAL_ERROR("Bitdepth must be 4 or 8.\n"); + } + else if (strcmp(option, "-invertsize") == 0) + { + inverted = true; + } + else + { + FATAL_ERROR("Unrecognized option \"%s\".\n", option); + } + } + + ReadNtrPalette(inputPath, &palette, bitdepth, 0, inverted); + WriteJascPalette(outputPath, &palette); +} + +void HandleJascToGbaPaletteCommand(char *inputPath, char *outputPath, int argc, char **argv) +{ + int numColors = 0; + + for (int i = 3; i < argc; i++) + { + char *option = argv[i]; + + if (strcmp(option, "-num_colors") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No number of colors following \"-num_colors\".\n"); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &numColors)) + FATAL_ERROR("Failed to parse number of colors.\n"); + + if (numColors < 1) + FATAL_ERROR("Number of colors must be positive.\n"); + } + else + { + FATAL_ERROR("Unrecognized option \"%s\".\n", option); + } + } + + struct Palette palette; + + ReadJascPalette(inputPath, &palette); + + if (numColors != 0) + palette.numColors = numColors; + + WriteGbaPalette(outputPath, &palette); +} + +void HandleJascToNtrPaletteCommand(char *inputPath, char *outputPath, int argc, char **argv) +{ + int numColors = 0; + bool ncpr = false; + bool ir = false; + bool nopad = false; + int bitdepth = 0; + int compNum = 0; + bool pcmp = false; + bool inverted = false; + + for (int i = 3; i < argc; i++) + { + char *option = argv[i]; + + if (strcmp(option, "-num_colors") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No number of colors following \"-num_colors\".\n"); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &numColors)) + FATAL_ERROR("Failed to parse number of colors.\n"); + + if (numColors < 1) + FATAL_ERROR("Number of colors must be positive.\n"); + } + else if (strcmp(option, "-bitdepth") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No bitdepth following \"-bitdepth\".\n"); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &bitdepth)) + FATAL_ERROR("Failed to parse bitdepth.\n"); + + if (bitdepth != 4 && bitdepth != 8) + FATAL_ERROR("Bitdepth must be 4 or 8.\n"); + } + else if (strcmp(option, "-comp") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No compression value following \"-comp\".\n"); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &compNum)) + FATAL_ERROR("Failed to parse compression value.\n"); + + if (compNum > 255) + FATAL_ERROR("Compression value must be 255 or below.\n"); + } + else if (strcmp(option, "-ncpr") == 0) + { + ncpr = true; + } + else if (strcmp(option, "-ir") == 0) + { + ir = true; + } + else if (strcmp(option, "-nopad") == 0) + { + nopad = true; + } + else if (strcmp(option, "-pcmp") == 0) + { + pcmp = true; + } + else if (strcmp(option, "-invertsize") == 0) + { + inverted = true; + } + else + { + FATAL_ERROR("Unrecognized option \"%s\".\n", option); + } + } + + struct Palette palette; + + ReadJascPalette(inputPath, &palette); + + if (numColors != 0) + palette.numColors = numColors; + + WriteNtrPalette(outputPath, &palette, ncpr, ir, bitdepth, !nopad, compNum, pcmp, inverted); +} + +void HandleJsonToNtrCellCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED) +{ + struct JsonToCellOptions *options; + + options = ParseNCERJson(inputPath); + + WriteNtrCell(outputPath, options); + + FreeNCERCell(options); +} + +void HandleJsonToNtrCellLzCommand(char *inputPath, char *outputPath, int argc, char **argv) +{ + HandleJsonToNtrCellCommand(inputPath, outputPath, argc, argv); + + HandleLZCompressCommand(outputPath, outputPath, argc, argv); +} + +void HandleNtrCellToJsonCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED) +{ + struct JsonToCellOptions *options = malloc(sizeof(struct JsonToCellOptions)); + + ReadNtrCell(inputPath, options); + + char *json = GetNCERJson(options); + + WriteWholeStringToFile(outputPath, json); + + FreeNCERCell(options); +} + +void HandleNtrCellLzToJsonCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED) +{ + HandleLZDecompressCommand(inputPath, outputPath, argc, argv); + + HandleNtrCellToJsonCommand(outputPath, outputPath, argc, argv); +} + +void HandleJsonToNtrScreenCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED) +{ + struct JsonToScreenOptions *options; + + options = ParseNSCRJson(inputPath); + + int bitdepth = 4; + + for (int i = 3; i < argc; i++) + { + char *option = argv[i]; + + if (strcmp(option, "-bitdepth") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No bitdepth following \"-bitdepth\".\n"); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &bitdepth)) + FATAL_ERROR("Failed to parse bitdepth.\n"); + + if (bitdepth != 4 && bitdepth != 8) + FATAL_ERROR("Bitdepth must be 4 or 8.\n"); + } + else + { + FATAL_ERROR("Unrecognized option \"%s\".\n", option); + } + } + + options->bitdepth = bitdepth; + + WriteNtrScreen(outputPath, options); + + FreeNSCRScreen(options); +} + +void HandleJsonToNtrAnimationCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED) +{ + struct JsonToAnimationOptions *options; + + options = ParseNANRJson(inputPath); + + options->multiCell = false; + + WriteNtrAnimation(outputPath, options); + + FreeNANRAnimation(options); +} + +void HandleJsonToNtrAnimationLzCommand(char *inputPath, char *outputPath, int argc, char **argv) +{ + HandleJsonToNtrAnimationCommand(inputPath, outputPath, argc, argv); + + HandleLZCompressCommand(outputPath, outputPath, argc, argv); +} + +void HandleNtrAnimationToJsonCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED) +{ + struct JsonToAnimationOptions *options = malloc(sizeof(struct JsonToAnimationOptions)); + + ReadNtrAnimation(inputPath, options); + + char *json = GetNANRJson(options); + + WriteWholeStringToFile(outputPath, json); + + FreeNANRAnimation(options); +} + +void HandleNtrAnimationLzToJsonCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED) +{ + HandleLZDecompressCommand(inputPath, outputPath, argc, argv); + + HandleNtrAnimationToJsonCommand(outputPath, outputPath, argc, argv); +} + +void HandleJsonToNtrMulticellAnimationCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED) +{ + struct JsonToAnimationOptions *options; + + options = ParseNANRJson(inputPath); + + options->multiCell = true; + + WriteNtrAnimation(outputPath, options); + + FreeNANRAnimation(options); +} + +void HandleLatinFontToPngCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED) +{ + struct Image image; + + ReadLatinFont(inputPath, &image); + WritePng(outputPath, &image); + + FreeImage(&image); +} + +void HandlePngToLatinFontCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED) +{ + struct Image image; + + image.bitDepth = 2; + + ReadPng(inputPath, &image); + WriteLatinFont(outputPath, &image); + + FreeImage(&image); +} + +void HandleHalfwidthJapaneseFontToPngCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED) +{ + struct Image image; + + ReadHalfwidthJapaneseFont(inputPath, &image); + WritePng(outputPath, &image); + + FreeImage(&image); +} + +void HandlePngToHalfwidthJapaneseFontCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED) +{ + struct Image image; + + image.bitDepth = 2; + + ReadPng(inputPath, &image); + WriteHalfwidthJapaneseFont(outputPath, &image); + + FreeImage(&image); +} + +void HandleFullwidthJapaneseFontToPngCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED) +{ + struct Image image; + + ReadFullwidthJapaneseFont(inputPath, &image); + WritePng(outputPath, &image); + + FreeImage(&image); +} + +void HandlePngToFullwidthJapaneseFontCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED) +{ + struct Image image; + + image.bitDepth = 2; + + ReadPng(inputPath, &image); + WriteFullwidthJapaneseFont(outputPath, &image); + + FreeImage(&image); +} + +static int CountLzCompressArgs(int argc, char **argv) +{ + int count = 0; + + for (int i = 3; i < argc; i++) + { + char *option = argv[i]; + + if (strcmp(option, "-overflow") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No size following \"-overflow\".\n"); + + i++; + + count++; + } + else if (strcmp(option, "-search") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No size following \"-overflow\".\n"); + + i++; + + count++; + } + else if (strcmp(option, "-reverse") == 0) + { + count++; + } + else if (strcmp(option, "-nopad") == 0) + { + count++; + } + } + + return count; +} + +static void HandleLZCompressCommand(char *inputPath, char *outputPath, int argc, char **argv) +{ + int overflowSize = 0; + int minDistance = 2; // default, for compatibility with LZ77UnCompVram() + bool forwardIteration = true; + bool nopad = false; + + for (int i = 3; i < argc; i++) + { + char *option = argv[i]; + + if (strcmp(option, "-overflow") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No size following \"-overflow\".\n"); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &overflowSize)) + FATAL_ERROR("Failed to parse overflow size.\n"); + + if (overflowSize < 1) + FATAL_ERROR("Overflow size must be positive.\n"); + } + else if (strcmp(option, "-search") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No size following \"-overflow\".\n"); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &minDistance)) + FATAL_ERROR("Failed to parse LZ min search distance.\n"); + + if (minDistance < 1) + FATAL_ERROR("LZ min search distance must be positive.\n"); + } + else if (strcmp(option, "-reverse") == 0) + { + forwardIteration = false; + } + else if (strcmp(option, "-nopad") == 0) + { + nopad = true; + } + else + { + FATAL_ERROR("Unrecognized option \"%s\".\n", option); + } + } + + // The overflow option allows a quirk in some of Ruby/Sapphire's tilesets + // to be reproduced. It works by appending a number of zeros to the data + // before compressing it and then amending the LZ header's size field to + // reflect the expected size. This will cause an overflow when decompressing + // the data. + + int fileSize; + unsigned char *buffer = ReadWholeFileZeroPadded(inputPath, &fileSize, overflowSize); + + int compressedSize; + unsigned char *compressedData = LZCompress(buffer, fileSize + overflowSize, &compressedSize, minDistance, forwardIteration, !nopad); + + compressedData[1] = (unsigned char)fileSize; + compressedData[2] = (unsigned char)(fileSize >> 8); + compressedData[3] = (unsigned char)(fileSize >> 16); + + free(buffer); + + WriteWholeFile(outputPath, compressedData, compressedSize); + + free(compressedData); +} + +static void HandleLZDecompressCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED) +{ + int fileSize; + unsigned char *buffer = ReadWholeFile(inputPath, &fileSize); + + int uncompressedSize; + unsigned char *uncompressedData = LZDecompress(buffer, fileSize, &uncompressedSize); + + free(buffer); + + WriteWholeFile(outputPath, uncompressedData, uncompressedSize); + + free(uncompressedData); +} + +void HandleRLCompressCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED) +{ + int fileSize; + unsigned char *buffer = ReadWholeFile(inputPath, &fileSize); + + int compressedSize; + unsigned char *compressedData = RLCompress(buffer, fileSize, &compressedSize); + + free(buffer); + + WriteWholeFile(outputPath, compressedData, compressedSize); + + free(compressedData); +} + +void HandleRLDecompressCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED) +{ + int fileSize; + unsigned char *buffer = ReadWholeFile(inputPath, &fileSize); + + int uncompressedSize; + unsigned char *uncompressedData = RLDecompress(buffer, fileSize, &uncompressedSize); + + free(buffer); + + WriteWholeFile(outputPath, uncompressedData, uncompressedSize); + + free(uncompressedData); +} + +void HandleHuffCompressCommand(char *inputPath, char *outputPath, int argc, char **argv) +{ + int fileSize; + int bitDepth = 4; + + for (int i = 3; i < argc; i++) + { + char *option = argv[i]; + + if (strcmp(option, "-depth") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No size following \"-depth\".\n"); + + i++; + + if (!ParseNumber(argv[i], NULL, 10, &bitDepth)) + FATAL_ERROR("Failed to parse bit depth.\n"); + + if (bitDepth != 4 && bitDepth != 8) + FATAL_ERROR("GBA only supports bit depth of 4 or 8.\n"); + } + else + { + FATAL_ERROR("Unrecognized option \"%s\".\n", option); + } + } + + unsigned char *buffer = ReadWholeFile(inputPath, &fileSize); + + int compressedSize; + unsigned char *compressedData = HuffCompress(buffer, fileSize, &compressedSize, bitDepth); + + free(buffer); + + WriteWholeFile(outputPath, compressedData, compressedSize); + + free(compressedData); +} + +void HandleHuffDecompressCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED) +{ + int fileSize; + unsigned char *buffer = ReadWholeFile(inputPath, &fileSize); + + int uncompressedSize; + unsigned char *uncompressedData = HuffDecompress(buffer, fileSize, &uncompressedSize); + + free(buffer); + + WriteWholeFile(outputPath, uncompressedData, uncompressedSize); + + free(uncompressedData); +} + +void HandleNtrFontToPngCommand(char *inputPath, char *outputPath, int argc, char **argv) +{ + struct NtrFontOptions options; + options.metadataFilePath = NULL; + options.useSubscreenPalette = false; + + for (int i = 3; i < argc; i++) + { + char *option = argv[i]; + + if (strcmp(option, "-metadata") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No file path following \"-metadata\".\n"); + + options.metadataFilePath = argv[++i]; + } + else if (strcmp(option, "-subscreen") == 0) + { + options.useSubscreenPalette = true; + } + } + + if (options.metadataFilePath == NULL) + FATAL_ERROR("No file path given for \"-metadata\".\n"); + + struct Image image; + struct NtrFontMetadata metadata; + ReadNtrFont(inputPath, &image, &metadata, options.useSubscreenPalette); + WritePng(outputPath, &image); + + char *metadataJson = GetNtrFontMetadataJson(&metadata); + WriteWholeStringToFile(options.metadataFilePath, metadataJson); + + free(metadata.glyphWidthTable); + FreeImage(&image); +} + +void HandlePngToNtrFontCommand(char *inputPath, char *outputPath, int argc, char **argv) +{ + struct NtrFontOptions options; + options.metadataFilePath = NULL; + + for (int i = 3; i < argc; i++) + { + char *option = argv[i]; + + if (strcmp(option, "-metadata") == 0) + { + if (i + 1 >= argc) + FATAL_ERROR("No file path following \"-metadata\".\n"); + + options.metadataFilePath = argv[++i]; + } + } + + if (options.metadataFilePath == NULL) + FATAL_ERROR("No file path given for \"-metadata\".\n"); + + struct NtrFontMetadata *metadata = ParseNtrFontMetadataJson(options.metadataFilePath); + struct Image image = { .bitDepth = 2 }; + + ReadPng(inputPath, &image); + WriteNtrFont(outputPath, &image, metadata); + + FreeNtrFontMetadata(metadata); + FreeImage(&image); +} + +int main(int argc, char **argv) +{ + if (argc < 3) + FATAL_ERROR("Usage: nitrogfx INPUT_PATH OUTPUT_PATH [options...]\n"); + + struct CommandHandler handlers[] = + { + { "1bpp", "png", HandleGbaToPngCommand }, + { "4bpp", "png", HandleGbaToPngCommand }, + { "8bpp", "png", HandleGbaToPngCommand }, + { "nbfc", "png", HandleGbaToPngCommand }, + { "NCGR", "png", HandleNtrToPngCommand }, + { "NCGR.lz", "png", HandleNtrLzToPngCommand }, + { "png", "1bpp", HandlePngToGbaCommand }, + { "png", "4bpp", HandlePngToGbaCommand }, + { "png", "nbfc", HandlePngToGbaCommand }, + { "png", "8bpp", HandlePngToGbaCommand }, + { "png", "NCGR", HandlePngToNtrCommand }, + { "png", "NCGR.lz", HandlePngToNtrLzCommand }, + { "png", "gbapal", HandlePngToGbaPaletteCommand }, + { "png", "nbfp", HandlePngToGbaPaletteCommand }, + { "png", "NCLR", HandlePngToNtrPaletteCommand }, + { "gbapal", "pal", HandleGbaToJascPaletteCommand }, + { "NCLR", "pal", HandleNtrToJascPaletteCommand }, + { "NCPR", "pal", HandleNtrToJascPaletteCommand }, + { "pal", "gbapal", HandleJascToGbaPaletteCommand }, + { "pal", "NCLR", HandleJascToNtrPaletteCommand }, + { "latfont", "png", HandleLatinFontToPngCommand }, + { "png", "latfont", HandlePngToLatinFontCommand }, + { "hwjpnfont", "png", HandleHalfwidthJapaneseFontToPngCommand }, + { "png", "hwjpnfont", HandlePngToHalfwidthJapaneseFontCommand }, + { "fwjpnfont", "png", HandleFullwidthJapaneseFontToPngCommand }, + { "png", "fwjpnfont", HandlePngToFullwidthJapaneseFontCommand }, + { "json", "NCER", HandleJsonToNtrCellCommand }, + { "json", "NCER.lz", HandleJsonToNtrCellLzCommand }, + { "NCER", "json", HandleNtrCellToJsonCommand }, + { "NCER.lz", "json", HandleNtrCellLzToJsonCommand }, + { "json", "NSCR", HandleJsonToNtrScreenCommand }, + { "json", "NANR", HandleJsonToNtrAnimationCommand }, + { "json", "NANR.lz", HandleJsonToNtrAnimationLzCommand }, + { "NANR", "json", HandleNtrAnimationToJsonCommand }, + { "NANR.lz", "json", HandleNtrAnimationLzToJsonCommand }, + { "json", "NMAR", HandleJsonToNtrMulticellAnimationCommand }, + { "NMAR", "json", HandleNtrAnimationToJsonCommand }, + { NULL, "huff", HandleHuffCompressCommand }, + { NULL, "lz", HandleLZCompressCommand }, + { "huff", NULL, HandleHuffDecompressCommand }, + { "lz", NULL, HandleLZDecompressCommand }, + { NULL, "rl", HandleRLCompressCommand }, + { "rl", NULL, HandleRLDecompressCommand }, + { "NFGR", "png", HandleNtrFontToPngCommand }, + { "png", "NFGR", HandlePngToNtrFontCommand }, + { NULL, NULL, NULL } + }; + + char *inputPath = argv[1]; + char *outputPath = argv[2]; + char *inputFileExtension = GetFileExtension(inputPath); + char *outputFileExtension = GetFileExtension(outputPath); + + if (inputFileExtension == NULL) + FATAL_ERROR("Input file \"%s\" has no extension.\n", inputPath); + + if (outputFileExtension == NULL) + FATAL_ERROR("Output file \"%s\" has no extension.\n", outputPath); + + for (int i = 0; handlers[i].function != NULL; i++) + { + if (((handlers[i].inputFileExtension == NULL || strcmp(handlers[i].inputFileExtension, inputFileExtension) == 0) + && (handlers[i].outputFileExtension == NULL || strcmp(handlers[i].outputFileExtension, outputFileExtension) == 0)) + || (handlers[i].inputFileExtension == NULL && strrchr(outputFileExtension, '.') && strstr(outputFileExtension, handlers[i].outputFileExtension)) + || (handlers[i].outputFileExtension == NULL && strrchr(inputFileExtension, '.') && strstr(inputFileExtension, handlers[i].inputFileExtension))) + { + handlers[i].function(inputPath, outputPath, argc, argv); + return 0; + } + } + + FATAL_ERROR("Don't know how to convert \"%s\" to \"%s\".\n", inputPath, outputPath); +} diff --git a/tools/nitrogfx/meson.build b/tools/nitrogfx/meson.build new file mode 100644 index 0000000000..9ba6401206 --- /dev/null +++ b/tools/nitrogfx/meson.build @@ -0,0 +1,19 @@ +libpng_dep = dependency('libpng', native: true) + +nitrogfx_exe = executable('nitrogfx', + sources: [ + 'main.c', + 'convert_png.c', + 'gfx.c', + 'jasc_pal.c', + 'lz.c', + 'rl.c', + 'util.c', + 'font.c', + 'huff.c', + 'json.c', + 'cJSON.c', + ], + dependencies: libpng_dep, + native: true, +) diff --git a/tools/nitrogfx/meson_options.txt b/tools/nitrogfx/meson_options.txt new file mode 100644 index 0000000000..ee09d88f9f --- /dev/null +++ b/tools/nitrogfx/meson_options.txt @@ -0,0 +1 @@ +option('native', type : 'boolean', value : true, description: 'Force native compilation, even in a cross-compilation setup') diff --git a/tools/nitrogfx/options.h b/tools/nitrogfx/options.h new file mode 100644 index 0000000000..0880ce37ea --- /dev/null +++ b/tools/nitrogfx/options.h @@ -0,0 +1,197 @@ +// Copyright (c) 2018 huderlem, 2021-2024 red031000 + +#ifndef OPTIONS_H +#define OPTIONS_H + +#include +#include + +struct GbaToPngOptions { + char *paletteFilePath; + int bitDepth; + bool hasTransparency; + int width; + int colsPerChunk; + int rowsPerChunk; + int palIndex; +}; + +struct PngToGbaOptions { + int numTiles; + int bitDepth; + int colsPerChunk; + int rowsPerChunk; +}; + +struct PngToNtrOptions { + char *cellFilePath; + int numTiles; + int bitDepth; + int colsPerChunk; + int rowsPerChunk; + bool clobberSize; + bool byteOrder; + bool version101; + bool sopc; + uint32_t scanMode; + bool wrongSize; + bool handleEmpty; + bool vramTransfer; + int mappingType; +}; + +struct NtrToPngOptions { + char *paletteFilePath; + char *cellFilePath; + int bitDepth; + bool hasTransparency; + int width; + int colsPerChunk; + int rowsPerChunk; + int palIndex; + bool scanFrontToBack; + bool handleEmpty; +}; + +struct CellVramTransferData { + int sourceDataOffset; + int size; +}; + +struct Attr0 { + int YCoordinate; + bool Rotation; + bool SizeDisable; + int Mode; + bool Mosaic; + int Colours; + int Shape; +}; + +struct Attr1 { + int XCoordinate; + int RotationScaling; + int Size; +}; + +struct Attr2 { + int CharName; + int Priority; + int Palette; +}; + +struct OAM { + struct Attr0 attr0; + struct Attr1 attr1; + struct Attr2 attr2; +}; + +struct CellAttributes { + bool hFlip; // 1 << 8 + bool vFlip; // 1 << 9 + bool hvFlip; // 1 << 10 + bool boundingRect; // 1 << 11 + int boundingSphereRadius; // 1 << 0 (6 bits); +}; + +struct Cell { + struct CellAttributes attributes; + short maxX; + short maxY; + short minX; + short minY; + short oamCount; + struct OAM *oam; +}; + +struct JsonToCellOptions { + bool labelEnabled; + bool extended; + bool vramTransferEnabled; + int mappingType; + int cellCount; + struct Cell **cells; + int vramTransferMaxSize; + struct CellVramTransferData **transferData; + char **labels; + int labelCount; +}; + +struct JsonToScreenOptions { + int height; + int width; + unsigned short *data; + int bitdepth; +}; + +struct FrameData { + int resultId; + short frameDelay; + int resultOffset; +}; + +struct SequenceData { + short frameCount; + short loopStartFrame; + short animationElement; + short animationType; + int playbackMode; + struct FrameData **frameData; +}; + +struct AnimationDataSRT { + short index; + unsigned short rotation; + int scaleX; + int scaleY; + short positionX; + short positionY; +}; + +struct AnimationDataT { + short index; + //unsigned short rotation; + short positionX; + short positionY; +}; + +struct AnimationResults { + short resultType; + bool padded; + union { + short index; + struct AnimationDataSRT dataSrt; + struct AnimationDataT dataT; + }; +}; + +struct JsonToAnimationOptions { + bool multiCell; + short sequenceCount; + short frameCount; + struct SequenceData **sequenceData; + struct AnimationResults **animationResults; + bool labelEnabled; + char **labels; + int labelCount; + short resultCount; +}; + +struct NtrFontOptions { + char *metadataFilePath; + bool useSubscreenPalette; +}; + +struct NtrFontMetadata { + uint32_t size; + uint32_t widthTableOffset; + uint32_t numGlyphs; + uint8_t maxWidth; + uint8_t maxHeight; + uint8_t glyphWidth; + uint8_t glyphHeight; + + uint8_t *glyphWidthTable; +}; + +#endif // OPTIONS_H diff --git a/tools/nitrogfx/rl.c b/tools/nitrogfx/rl.c new file mode 100644 index 0000000000..993ac64497 --- /dev/null +++ b/tools/nitrogfx/rl.c @@ -0,0 +1,149 @@ +// Copyright (c) 2016 YamaArashi + +#include +#include +#include "global.h" +#include "rl.h" + +unsigned char *RLDecompress(unsigned char *src, int srcSize, int *uncompressedSize) +{ + if (srcSize < 4) + goto fail; + + int destSize = (src[3] << 16) | (src[2] << 8) | src[1]; + + unsigned char *dest = malloc(destSize); + + if (dest == NULL) + goto fail; + + int srcPos = 4; + int destPos = 0; + + for (;;) + { + if (srcPos >= srcSize) + goto fail; + + unsigned char flags = src[srcPos++]; + bool compressed = ((flags & 0x80) != 0); + + if (compressed) + { + int length = (flags & 0x7F) + 3; + unsigned char data = src[srcPos++]; + + if (destPos + length > destSize) + goto fail; + + for (int i = 0; i < length; i++) + dest[destPos++] = data; + } + else + { + int length = (flags & 0x7F) + 1; + + if (destPos + length > destSize) + goto fail; + + for (int i = 0; i < length; i++) + dest[destPos++] = src[srcPos++]; + } + + if (destPos == destSize) + { + *uncompressedSize = destSize; + return dest; + } + } + +fail: + FATAL_ERROR("Fatal error while decompressing RL file.\n"); +} + +unsigned char *RLCompress(unsigned char *src, int srcSize, int *compressedSize) +{ + if (srcSize <= 0) + goto fail; + + int worstCaseDestSize = 4 + srcSize * 2; + + // Round up to the next multiple of four. + worstCaseDestSize = (worstCaseDestSize + 3) & ~3; + + unsigned char *dest = malloc(worstCaseDestSize); + + if (dest == NULL) + goto fail; + + // header + dest[0] = 0x30; // RL compression type + dest[1] = (unsigned char)srcSize; + dest[2] = (unsigned char)(srcSize >> 8); + dest[3] = (unsigned char)(srcSize >> 16); + + int srcPos = 0; + int destPos = 4; + + for (;;) + { + bool compress = false; + int uncompressedStart = srcPos; + int uncompressedLength = 0; + + while (srcPos < srcSize && uncompressedLength < (0x7F + 1)) + { + compress = (srcPos + 2 < srcSize && src[srcPos] == src[srcPos + 1] && src[srcPos] == src[srcPos + 2]); + + if (compress) + break; + + srcPos++; + uncompressedLength++; + } + + if (uncompressedLength > 0) + { + dest[destPos++] = uncompressedLength - 1; + + for (int i = 0; i < uncompressedLength; i++) + dest[destPos++] = src[uncompressedStart + i]; + } + + if (compress) + { + unsigned char data = src[srcPos]; + int compressedLength = 0; + + while (compressedLength < (0x7F + 3) + && srcPos + compressedLength < srcSize + && src[srcPos + compressedLength] == data) + { + compressedLength++; + } + + dest[destPos++] = 0x80 | (compressedLength - 3); + dest[destPos++] = data; + + srcPos += compressedLength; + } + + if (srcPos == srcSize) + { + // Pad to multiple of 4 bytes. + int remainder = destPos % 4; + + if (remainder != 0) + { + for (int i = 0; i < 4 - remainder; i++) + dest[destPos++] = 0; + } + + *compressedSize = destPos; + return dest; + } + } + +fail: + FATAL_ERROR("Fatal error while compressing RL file.\n"); +} diff --git a/tools/nitrogfx/rl.h b/tools/nitrogfx/rl.h new file mode 100644 index 0000000000..02ad8d6d3b --- /dev/null +++ b/tools/nitrogfx/rl.h @@ -0,0 +1,9 @@ +// Copyright (c) 2016 YamaArashi + +#ifndef RL_H +#define RL_H + +unsigned char *RLDecompress(unsigned char *src, int srcSize, int *uncompressedSize); +unsigned char *RLCompress(unsigned char *src, int srcSize, int *compressedSize); + +#endif // RL_H diff --git a/tools/nitrogfx/util.c b/tools/nitrogfx/util.c new file mode 100644 index 0000000000..0ac86be8a3 --- /dev/null +++ b/tools/nitrogfx/util.c @@ -0,0 +1,183 @@ +// Copyright (c) 2015 YamaArashi + +#include +#include +#include +#include +#include +#include +#include +#include "global.h" +#include "util.h" + +bool ParseNumber(char *s, char **end, int radix, int *intValue) +{ + char *localEnd; + + if (end == NULL) + end = &localEnd; + + errno = 0; + + const long longValue = strtol(s, end, radix); + + if (*end == s) + return false; // not a number + + if ((longValue == LONG_MIN || longValue == LONG_MAX) && errno == ERANGE) + return false; + + if (longValue > INT_MAX) + return false; + + if (longValue < INT_MIN) + return false; + + *intValue = (int)longValue; + + return true; +} + +char *GetFileExtension(char *path) +{ + char *extension = path; + + while (*extension != 0) + extension++; + + while (extension > path && *extension != '.') + extension--; + + if (extension == path) + return NULL; + + extension++; + + if (*extension == 0) + return NULL; + + if (strcmp(extension,"lz") == 0) + { + char *plainName = malloc(strlen(path) + 1); + strcpy(plainName, path); + plainName[strlen(path) - 3] = 0; + char *newExtension = GetFileExtension(plainName); + if (newExtension != NULL) + { + extension -= strlen(newExtension) + 1; + } + free(plainName); + } + + return extension; +} + +unsigned char *ReadWholeFile(char *path, int *size) +{ + FILE *fp = fopen(path, "rb"); + + if (fp == NULL) + FATAL_ERROR("Failed to open \"%s\" for reading.\n", path); + + fseek(fp, 0, SEEK_END); + + *size = ftell(fp); + + unsigned char *buffer = malloc(*size); + + if (buffer == NULL) + FATAL_ERROR("Failed to allocate memory for reading \"%s\".\n", path); + + rewind(fp); + + if (fread(buffer, *size, 1, fp) != 1) + FATAL_ERROR("Failed to read \"%s\".\n", path); + + fclose(fp); + + return buffer; +} + +unsigned char *ReadWholeFileZeroPadded(char *path, int *size, int padAmount) +{ + FILE *fp = fopen(path, "rb"); + + if (fp == NULL) + FATAL_ERROR("Failed to open \"%s\" for reading.\n", path); + + fseek(fp, 0, SEEK_END); + + *size = ftell(fp); + + unsigned char *buffer = calloc(*size + padAmount, 1); + + if (buffer == NULL) + FATAL_ERROR("Failed to allocate memory for reading \"%s\".\n", path); + + rewind(fp); + + if (fread(buffer, *size, 1, fp) != 1) + FATAL_ERROR("Failed to read \"%s\".\n", path); + + fclose(fp); + + return buffer; +} + +void WriteWholeStringToFile(char *path, char *string) +{ + FILE *fp = fopen(path, "wb"); + + if (fp == NULL) + FATAL_ERROR("Failed to open \"%s\" for writing.\n", path); + + if (fputs(string, fp) == EOF) + FATAL_ERROR("Failed to write to \"%s\".\n", path); + + fclose(fp); +} + +void WriteWholeFile(char *path, void *buffer, int bufferSize) +{ + FILE *fp = fopen(path, "wb"); + + if (fp == NULL) + FATAL_ERROR("Failed to open \"%s\" for writing.\n", path); + + if (fwrite(buffer, bufferSize, 1, fp) != 1) + FATAL_ERROR("Failed to write to \"%s\".\n", path); + + fclose(fp); +} + +void WriteGenericNtrHeader(FILE* fp, const char* magicNumber, uint32_t size, bool byteorder, bool version101, uint16_t sectionCount) +{ + unsigned char header[0x10] = + { 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFE, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x01, 0x00 }; + //magic number + memcpy(header, magicNumber, 4); + + if (version101) + { + header[6] = 0x01; + } + + //byte order + if (!byteorder) + { + memset(header + 4, 0, 2); + } + + //size + size += 0x10; //add header size + header[8] = size & 0xFF; + header[9] = (size >> 8) & 0xFF; + header[10] = (size >> 16) & 0xFF; + header[11] = (size >> 24) & 0xFF; + + //section count + header[14] = sectionCount & 0xFF; + header[15] = (sectionCount >> 8) & 0xFF; + + fwrite(header, 1, 0x10, fp); +} diff --git a/tools/nitrogfx/util.h b/tools/nitrogfx/util.h new file mode 100644 index 0000000000..a7bf3f1af6 --- /dev/null +++ b/tools/nitrogfx/util.h @@ -0,0 +1,58 @@ +// Copyright (c) 2015 YamaArashi + +#ifndef UTIL_H +#define UTIL_H + +#include +#include + +bool ParseNumber(char *s, char **end, int radix, int *intValue); +char *GetFileExtension(char *path); +unsigned char *ReadWholeFile(char *path, int *size); +unsigned char *ReadWholeFileZeroPadded(char *path, int *size, int padAmount); +void WriteWholeStringToFile(char *path, char *string); +void WriteWholeFile(char *path, void *buffer, int bufferSize); +void WriteGenericNtrHeader(FILE* fp, const char* magicNumber, uint32_t size, bool byteorder, bool version101, uint16_t sectionCount); + +// Unaligned IO +static inline uint8_t ReadU8(const unsigned char *ptr, const size_t offset) { + return ptr[offset]; +} + +static inline uint16_t ReadU16(const unsigned char *ptr, const size_t offset) { + return ptr[offset] | (ptr[offset + 1] << 8); +} + +static inline uint32_t ReadU32(const unsigned char *ptr, const size_t offset) { + return ptr[offset] | (ptr[offset + 1] << 8) | (ptr[offset + 2] << 16) | (ptr[offset + 3] << 24); +} + +static inline int8_t ReadS8(const unsigned char *ptr, const size_t offset) { + return ptr[offset]; +} + +static inline int16_t ReadS16(const unsigned char *ptr, const size_t offset) { + return ptr[offset] | (ptr[offset + 1] << 8); +} + +static inline int32_t ReadS32(const unsigned char *ptr, const size_t offset) { + return ptr[offset] | (ptr[offset + 1] << 8) | (ptr[offset + 2] << 16) | (ptr[offset + 3] << 24); +} + +static inline void WriteU8(unsigned char *ptr, const size_t offset, uint8_t value) { + ptr[offset] = value; +} + +static inline void WriteU16(unsigned char *ptr, const size_t offset, uint16_t value) { + ptr[offset] = value; + ptr[offset + 1] = value >> 8; +} + +static inline void WriteU32(unsigned char *ptr, const size_t offset, uint32_t value) { + ptr[offset] = value; + ptr[offset + 1] = value >> 8; + ptr[offset + 2] = value >> 16; + ptr[offset + 3] = value >> 24; +} + +#endif // UTIL_H