diff options
Diffstat (limited to 'tools')
| -rw-r--r-- | tools/.gitignore | 3 | ||||
| -rw-r--r-- | tools/Makefile | 16 | ||||
| -rw-r--r-- | tools/common.h | 40 | ||||
| -rw-r--r-- | tools/gfx.c | 296 | ||||
| -rw-r--r-- | tools/pkmncompress.c | 451 | ||||
| -rw-r--r-- | tools/scan_includes.c | 135 |
6 files changed, 941 insertions, 0 deletions
diff --git a/tools/.gitignore b/tools/.gitignore new file mode 100644 index 00000000..967af106 --- /dev/null +++ b/tools/.gitignore @@ -0,0 +1,3 @@ +scan_includes +gfx +pkmncompress diff --git a/tools/Makefile b/tools/Makefile new file mode 100644 index 00000000..13bab1fb --- /dev/null +++ b/tools/Makefile @@ -0,0 +1,16 @@ +.PHONY: all clean + +CC := gcc +CFLAGS := -O3 -std=c99 -Wall -Wextra + +tools := scan_includes gfx pkmncompress + +all: $(tools) + @: + +clean: + rm -f $(tools) + +gfx: common.h +%: %.c + $(CC) $(CFLAGS) -o $@ $< diff --git a/tools/common.h b/tools/common.h new file mode 100644 index 00000000..4da0b2ef --- /dev/null +++ b/tools/common.h @@ -0,0 +1,40 @@ +#ifndef GUARD_COMMON_H +#define GUARD_COMMON_H + +int __getopt_long_i__; +#define getopt_long(c, v, s, l) getopt_long(c, v, s, l, &__getopt_long_i__) + +FILE *fopen_verbose(char *filename, char *mode) { + FILE *f = fopen(filename, mode); + if (!f) { + fprintf(stderr, "Could not open file: \"%s\"\n", filename); + } + return f; +} + +uint8_t *read_u8(char *filename, int *size) { + FILE *f = fopen_verbose(filename, "rb"); + if (!f) { + exit(1); + } + fseek(f, 0, SEEK_END); + *size = ftell(f); + rewind(f); + uint8_t *data = malloc(*size); + if (*size != (int)fread(data, 1, *size, f)) { + fprintf(stderr, "Could not read file: \"%s\"\n", filename); + exit(1); + } + fclose(f); + return data; +} + +void write_u8(char *filename, uint8_t *data, int size) { + FILE *f = fopen_verbose(filename, "wb"); + if (f) { + fwrite(data, 1, size, f); + fclose(f); + } +} + +#endif // GUARD_COMMON_H diff --git a/tools/gfx.c b/tools/gfx.c new file mode 100644 index 00000000..8c4066ab --- /dev/null +++ b/tools/gfx.c @@ -0,0 +1,296 @@ +#include <stdio.h> +#include <stdlib.h> +#include <stdbool.h> +#include <getopt.h> +#include <string.h> +#include <stdint.h> + +#include "common.h" + +static void usage(void) { + fprintf(stderr, "Usage: gfx [--trim-whitespace] [--remove-whitespace] [--interleave] [--remove-duplicates [--keep-whitespace]] [--remove-xflip] [--remove-yflip] [--png filename] [-d depth] [-h] [-o outfile] infile\n"); +} + +static void error(char *message) { + fputs(message, stderr); + fputs("\n", stderr); +} + +struct Options { + int trim_whitespace; + int remove_whitespace; + int help; + char *outfile; + int depth; + int interleave; + int remove_duplicates; + int keep_whitespace; + int remove_xflip; + int remove_yflip; + char *png_file; +}; + +struct Options Options = { + .depth = 2, +}; + +void get_args(int argc, char *argv[]) { + struct option long_options[] = { + {"remove-whitespace", no_argument, &Options.remove_whitespace, 1}, + {"trim-whitespace", no_argument, &Options.trim_whitespace, 1}, + {"interleave", no_argument, &Options.interleave, 1}, + {"remove-duplicates", no_argument, &Options.remove_duplicates, 1}, + {"keep-whitespace", no_argument, &Options.keep_whitespace, 1}, + {"remove-xflip", no_argument, &Options.remove_xflip, 1}, + {"remove-yflip", no_argument, &Options.remove_yflip, 1}, + {"png", required_argument, 0, 'p'}, + {"depth", required_argument, 0, 'd'}, + {"help", no_argument, 0, 'h'}, + {0} + }; + for (int opt = 0; opt != -1;) { + switch (opt = getopt_long(argc, argv, "ho:d:p:", long_options)) { + case 'h': + Options.help = true; + break; + case 'o': + Options.outfile = optarg; + break; + case 'd': + Options.depth = strtoul(optarg, NULL, 0); + break; + case 'p': + Options.png_file = optarg; + break; + case 0: + case -1: + break; + default: + usage(); + exit(1); + break; + } + } +} + +struct Graphic { + int size; + uint8_t *data; +}; + +bool is_whitespace(uint8_t *tile, int tile_size) { + uint8_t WHITESPACE = 0; + for (int i = 0; i < tile_size; i++) { + if (tile[i] != WHITESPACE) { + return false; + } + } + return true; +} + +void trim_whitespace(struct Graphic *graphic) { + int tile_size = Options.depth * 8; + for (int i = graphic->size - tile_size; i > 0; i -= tile_size) { + if (is_whitespace(&graphic->data[i], tile_size)) { + graphic->size = i; + } else { + break; + } + } +} + +void remove_whitespace(struct Graphic *graphic) { + int tile_size = Options.depth * 8; + if (Options.interleave) tile_size *= 2; + int i = 0; + for (int j = 0; i < graphic->size && j < graphic->size; i += tile_size, j += tile_size) { + while (is_whitespace(&graphic->data[j], tile_size)) { + j += tile_size; + } + if (j >= graphic->size) { + break; + } + if (j > i) { + memcpy(&graphic->data[i], &graphic->data[j], tile_size); + } + } + graphic->size = i; +} + +bool tile_exists(uint8_t *tile, uint8_t *tiles, int tile_size, int num_tiles) { + for (int i = 0; i < num_tiles; i++) { + bool match = true; + for (int j = 0; j < tile_size; j++) { + if (tile[j] != tiles[i * tile_size + j]) { + match = false; + } + } + if (match) { + return true; + } + } + return false; +} + +void remove_duplicates(struct Graphic *graphic) { + int tile_size = Options.depth * 8; + if (Options.interleave) tile_size *= 2; + int num_tiles = 0; + for (int i = 0, j = 0; i < graphic->size && j < graphic->size; i += tile_size, j += tile_size) { + while (tile_exists(&graphic->data[j], graphic->data, tile_size, num_tiles)) { + if (Options.keep_whitespace && is_whitespace(&graphic->data[j], tile_size)) { + break; + } + j += tile_size; + } + if (j >= graphic->size) { + break; + } + if (j > i) { + memcpy(&graphic->data[i], &graphic->data[j], tile_size); + } + num_tiles++; + } + graphic->size = num_tiles * tile_size; +} + +bool flip_exists(uint8_t *tile, uint8_t *tiles, int tile_size, int num_tiles, bool xflip, bool yflip) { + uint8_t *flip = calloc(tile_size, 1); + int half_size = tile_size / 2; + for (int i = 0; i < tile_size; i++) { + int byte = i; + if (yflip) { + byte = tile_size - 1 - (i ^ 1); + if (Options.interleave && i < half_size) { + byte = half_size - 1 - (i ^ 1); + } + } + if (xflip) { + for (int bit = 0; bit < 8; bit++) { + flip[byte] |= ((tile[i] >> bit) & 1) << (7 - bit); + } + } else { + flip[byte] = tile[i]; + } + } + if (tile_exists(flip, tiles, tile_size, num_tiles)) { + return true; + } + return false; +} + +void remove_flip(struct Graphic *graphic, bool xflip, bool yflip) { + int tile_size = Options.depth * 8; + if (Options.interleave) tile_size *= 2; + int num_tiles = 0; + for (int i = 0, j = 0; i < graphic->size && j < graphic->size; i += tile_size, j += tile_size) { + while (flip_exists(&graphic->data[j], graphic->data, tile_size, num_tiles, xflip, yflip)) { + if (Options.keep_whitespace && is_whitespace(&graphic->data[j], tile_size)) { + break; + } + j += tile_size; + } + if (j >= graphic->size) { + break; + } + if (j > i) { + memcpy(&graphic->data[i], &graphic->data[j], tile_size); + } + num_tiles++; + } + graphic->size = num_tiles * tile_size; +} + +void interleave(struct Graphic *graphic, int width) { + int tile_size = Options.depth * 8; + int width_tiles = width / 8; + int num_tiles = graphic->size / tile_size; + uint8_t *interleaved = malloc(graphic->size); + for (int i = 0; i < num_tiles; i++) { + int tile = i * 2; + int row = i / width_tiles; + tile -= width_tiles * row; + if (row % 2) { + tile -= width_tiles; + tile += 1; + } + memcpy(&interleaved[tile * tile_size], &graphic->data[i * tile_size], tile_size); + } + graphic->size = num_tiles * tile_size; + memcpy(graphic->data, interleaved, graphic->size); + free(interleaved); +} + +int png_get_width(char *filename) { + FILE *f = fopen_verbose(filename, "rb"); + if (!f) { + exit(1); + } + + const int OFFSET_WIDTH = 16; + uint8_t bytes[4]; + fseek(f, OFFSET_WIDTH, SEEK_SET); + size_t size = 4; + size_t result = fread(bytes, 1, size, f); + fclose(f); + if (result != size) { + fprintf(stderr, "Could not read file at offset 0x%x: \"%s\"\n", OFFSET_WIDTH, filename); + exit(1); + } + + int width = 0; + for (int i = 0; i < 4; i++) { + width |= bytes[i] << (8 * (3 - i)); + } + return width; +} + + +int main(int argc, char *argv[]) { + get_args(argc, argv); + argc -= optind; + argv += optind; + if (Options.help) { + usage(); + return 0; + } + if (argc < 1) { + usage(); + exit(1); + } + char *infile = argv[0]; + struct Graphic graphic; + graphic.data = read_u8(infile, &graphic.size); + if (Options.trim_whitespace) { + trim_whitespace(&graphic); + } + if (Options.interleave) { + if (!Options.png_file) { + error("interleave: need --png to infer dimensions"); + usage(); + exit(1); + } + int width = png_get_width(Options.png_file); + interleave(&graphic, width); + } + if (Options.remove_duplicates) { + remove_duplicates(&graphic); + } + if (Options.remove_xflip) { + remove_flip(&graphic, true, false); + } + if (Options.remove_yflip) { + remove_flip(&graphic, false, true); + } + if (Options.remove_xflip && Options.remove_yflip) { + remove_flip(&graphic, true, true); + } + if (Options.remove_whitespace) { + remove_whitespace(&graphic); + } + if (Options.outfile) { + write_u8(Options.outfile, graphic.data, graphic.size); + } + free(graphic.data); + return 0; +} diff --git a/tools/pkmncompress.c b/tools/pkmncompress.c new file mode 100644 index 00000000..db707653 --- /dev/null +++ b/tools/pkmncompress.c @@ -0,0 +1,451 @@ +/* + * Copyright © 2013 stag019 <stag019@gmail.com> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <stdlib.h> +#include <stdio.h> +#include <stdint.h> +#include <string.h> + +typedef uint8_t u8; + +u8 *compressed = NULL; +int xrows = 0; +int xwidth = 0; +int curbit = 0; +int curbyte = 0; + +void writebit(int bit) +{ + if (++curbit == 8) + { + curbyte++; + curbit = 0; + } + compressed[curbyte] |= bit << (7 - curbit); +} + +void method_1(u8 *RAM) +{ + int i; + int j; + int nibble_1; + int nibble_2 = 0; + int code_1; + int code_2; + int table; + static int method_1[2][0x10] = { + {0x0, 0x1, 0x3, 0x2, 0x6, 0x7, 0x5, 0x4, 0xC, 0xD, 0xF, 0xE, 0xA, 0xB, 0x9, 0x8}, + {0x8, 0x9, 0xB, 0xA, 0xE, 0xF, 0xD, 0xC, 0x4, 0x5, 0x7, 0x6, 0x2, 0x3, 0x1, 0x0} + }; + + for (i = 0; i < xrows * xwidth * 8; i++) + { + j = i / xrows; + j += i % xrows * xwidth * 8; + if (!(i % xrows)) + { + nibble_2 = 0; + } + nibble_1 = (RAM[j] >> 4) & 0x0F; + table = 0; + if (nibble_2 & 1) + { + table = 1; + } + code_1 = method_1[table][nibble_1]; + nibble_2 = RAM[j] & 0x0F; + table = 0; + if (nibble_1 & 1) + { + table = 1; + } + code_2 = method_1[table][nibble_2]; + RAM[j] = (code_1 << 4) | code_2; + } +} + +// "Get the previous power of 2. Deriving the bitcount from that seems to be faster on average than using the lookup table." +void RLE(int nums) +{ + int v; + int j; + int bitcount; + int number; + + bitcount = -1; + v = ++nums; + v++; + v |= v >> 1; + v |= v >> 2; + v |= v >> 4; + v |= v >> 8; + v |= v >> 16; + v -= v >> 1; + v--; + + number = nums - v; + while(v) { + v >>= 1; + bitcount++; + } + for(j = 0; j < bitcount; j++) { + writebit(1); + } + writebit(0); + for(j = bitcount; j >= 0; j--) { + writebit((number >> j) & 1); + } +} + +void RLE_old(int nums) +{ + int search; + int i; + int j; + int bitcount; + int number; + static int RLE[0x10] = {0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF}; + + bitcount = -1; + search = ++nums; + while (search > 0) + { + for (i = 0; i < 0xF; i++) + { + if (RLE[i] == search) + { + bitcount = i; + break; + } + } + if (bitcount != -1) + { + break; + } + search--; + } + number = nums - RLE[bitcount]; + for (j = 0; j < bitcount; j++) + { + writebit(1); + } + writebit(0); + for (j = bitcount; j >= 0; j--) + { + writebit((number >> j) & 1); + } +} + +void data_packet(u8 *bitgroups, int bgi) +{ + int i; + for (i = 0; i < bgi; i++) + { + writebit((bitgroups[i] >> 1) & 1); + writebit(bitgroups[i] & 1); + } +} + +int interpret_compress(u8 *RAM_1, u8 *RAM_2, int interpretation, int switchram) +{ + u8 *_1_RAM; + u8 *_2_RAM; + int i; + int ram; + int type; + int nums; + u8 *bitgroups; + int x; + int y; + int byte; + int bit; + int bitgroup; + int bgi = 0; + + int ram_size = xrows * xwidth * 8; + _1_RAM = (u8 *)calloc(ram_size, 1); + _2_RAM = (u8 *)calloc(ram_size, 1); + if (switchram) + { + memcpy(_1_RAM, RAM_2, ram_size); + memcpy(_2_RAM, RAM_1, ram_size); + } + else + { + memcpy(_1_RAM, RAM_1, ram_size); + memcpy(_2_RAM, RAM_2, ram_size); + } + + switch(interpretation) + { + case 1: + method_1(_1_RAM); + method_1(_2_RAM); + break; + case 2: + case 3: + for (i = 0; i < xrows * xwidth * 8; i++) + { + _2_RAM[i] ^= _1_RAM[i]; + } + method_1(_1_RAM); + break; + } + if (interpretation == 3) + { + method_1(_2_RAM); + } + + curbit = 7; + curbyte = 0; + compressed = (u8 *)calloc(0x310, 1); + compressed[0] = (xrows << 4) | xwidth; + writebit(switchram); + + for (ram = 0; ram < 2; ram++) + { + type = 0; + nums = 0; + bitgroups = (u8 *)calloc(0x1000, 1); + + for (x = 0; x < xwidth; x++) + { + for (bit = 0; bit < 8; bit += 2) + { + byte = x * xrows * 8; + for (y=0; y < xrows * 8; y++) + { + if (ram) + { + bitgroup = (_2_RAM[byte] >> (6 - bit)) & 3; + } + else + { + bitgroup = (_1_RAM[byte] >> (6 - bit)) & 3; + } + if (!bitgroup) + { + if (!type) + { + writebit(0); + } + else if (type == 1) + { + nums++; + } + else + { + data_packet(bitgroups, bgi); + writebit(0); + writebit(0); + } + type = 1; + free(bitgroups); + bitgroups = (u8 *)calloc(0x1000, 1); + bgi = 0; + } + else + { + if (!type) + { + writebit(1); + } + else if (type == 1) + { + RLE(nums); + } + type = -1; + bitgroups[bgi++] = bitgroup; + nums = 0; + } + byte++; + } + } + } + if (type == 1) + { + RLE(nums); + } + else + { + data_packet(bitgroups, bgi); + } + if (!ram) + { + if (interpretation < 2) + { + writebit(0); + } + else + { + writebit(1); + writebit(interpretation - 2); + } + } + } + free(bitgroups); + free(_1_RAM); + free(_2_RAM); + return (curbyte + 1) * 8 + curbit; +} + +int compress(u8 *data, int width, int height) +{ + u8 *RAM_1; + u8 *RAM_2; + int i; + int mode; + int order; + int newsize; + int compressedsize; + int size = -1; + u8 *current = NULL; + int ram_size; + + xrows = height; + xwidth = width; + + ram_size = xrows * xwidth * 8; + + RAM_1 = (u8 *)calloc(ram_size, 1); + RAM_2 = (u8 *)calloc(ram_size, 1); + + for (i = 0; i < xrows * xwidth * 8; i++) + { + RAM_1[i] = data[(i << 1)]; + RAM_2[i] = data[(i << 1) | 1]; + } + + for (mode = 1; mode < 4; mode++) + { + for (order = 0; order < 2; order++) + { + if (!(mode == 1 && order == 0)) + { + newsize = interpret_compress(RAM_1, RAM_2, mode, order); + if (size == -1 || newsize < size) + { + if (current != NULL) + { + free(current); + } + current = (u8 *)calloc(0x310, 1); + memcpy(current, compressed, newsize / 8); + free(compressed); + size = newsize; + } + } + } + } + compressed = (u8 *)calloc(0x310, 1); + compressedsize = size / 8; + memcpy(compressed, current, compressedsize); + free(current); + + free(RAM_1); + free(RAM_2); + + return compressedsize; +} + +uint8_t *transpose_tiles(uint8_t *data, int width, int height) +{ + int i; + int j; + int tile_size = 0x10; + + int size = width * height * tile_size; + u8 *transposed = calloc(size, 1); + for (i = 0; i < size; i++) + { + j = (i / 0x10) * width * 0x10; + j = (j % size) + 0x10 * (j / size) + (i % 0x10); + transposed[j] = data[i]; + } + + free(data); + + return transposed; +} + +int main(int argc, char *argv[]) +{ + int width = 0; + int height = 0; + int transpose = 1; + + if (argc != 3) + { + fputs("Usage: pkmncompress infile.2bpp outfile.pic\n", stderr); + return EXIT_FAILURE; + } + + char *infile = argv[1]; + char *outfile = argv[2]; + + FILE *f = fopen(infile, "rb"); + if (!f) { + fprintf(stderr, "failed to open for reading: '%s'\n", infile); + return EXIT_FAILURE; + } + fseek(f, 0, SEEK_END); + int filesize = ftell(f); + + for (int i = 0; i < 32; i++) { + width = i; + height = i; + if (width * height * 16 >= filesize) { + break; + } + } + if (width * height * 16 < filesize) { + fprintf(stderr, "file too big: '%s' (%x)\n", infile, filesize); + return EXIT_FAILURE; + } + if (width * height * 16 > filesize) { + fprintf(stderr, "wrong filesize for '%s' (%x). must be a square image of 16-byte tiles\n", infile, filesize); + return EXIT_FAILURE; + } + + u8 *data = (u8 *)calloc(filesize, 1); + fseek(f, 0, SEEK_SET); + int size = fread(data, 1, filesize, f); + fclose(f); + if (size != filesize) { + fprintf(stderr, "failed to read: '%s'\n", infile); + return EXIT_FAILURE; + } + + if (transpose) { + data = transpose_tiles(data, width, height); + } + + int compressed_size = compress(data, width, height); + + free(data); + + f = fopen(outfile, "wb"); + if (!f) { + fprintf(stderr, "failed to open for writing: '%s'\n", outfile); + return EXIT_FAILURE; + } + fwrite(compressed, 1, compressed_size, f); + fclose(f); + + free(compressed); + + return EXIT_SUCCESS; +} diff --git a/tools/scan_includes.c b/tools/scan_includes.c new file mode 100644 index 00000000..63af3bcf --- /dev/null +++ b/tools/scan_includes.c @@ -0,0 +1,135 @@ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <stdbool.h> +#include <getopt.h> + +void usage(void) { + printf("Usage: scan_includes [-h] [-s] filename\n" + "-h, --help\n" + " Print usage and exit\n" + "-s, --strict\n" + " Fail if a file cannot be read\n"); +} + +struct Options { + bool help; + bool strict; +}; + +struct Options Options = {0}; + +void scan_file(char* filename) { + FILE *f = fopen(filename, "rb"); + if (!f) { + if (Options.strict) { + fprintf(stderr, "Could not open file: '%s'\n", filename); + exit(1); + } else { + return; + } + } + + fseek(f, 0, SEEK_END); + long size = ftell(f); + rewind(f); + + char *buffer = malloc(size + 1); + char *orig = buffer; + size = fread(buffer, 1, size, f); + buffer[size] = '\0'; + fclose(f); + + for (; buffer && (buffer - orig < size); buffer++) { + bool is_include = false; + bool is_incbin = false; + switch (*buffer) { + case ';': + buffer = strchr(buffer, '\n'); + if (!buffer) { + fprintf(stderr, "%s: no newline at end of file\n", filename); + break; + } + break; + + case '"': + buffer++; + buffer = strchr(buffer, '"'); + if (!buffer) { + fprintf(stderr, "%s: unterminated string\n", filename); + break; + } + buffer++; + break; + + case 'i': + case 'I': + if ((strncmp(buffer, "INCBIN", 6) == 0) || (strncmp(buffer, "incbin", 6) == 0)) { + is_incbin = true; + } else if ((strncmp(buffer, "INCLUDE", 7) == 0) || (strncmp(buffer, "include", 7) == 0)) { + is_include = true; + } + if (is_incbin || is_include) { + buffer = strchr(buffer, '"'); + if (!buffer) { + break; + } + buffer++; + int length = strcspn(buffer, "\""); + char *include = malloc(length + 1); + strncpy(include, buffer, length); + include[length] = '\0'; + printf("%s ", include); + if (is_include) { + scan_file(include); + } + free(include); + buffer = strchr(buffer, '"'); + } + break; + + } + if (!buffer) { + break; + } + + } + + free(orig); +} + +int main(int argc, char* argv[]) { + int i = 0; + struct option long_options[] = { + {"strict", no_argument, 0, 's'}, + {"help", no_argument, 0, 'h'}, + {0} + }; + int opt = -1; + while ((opt = getopt_long(argc, argv, "sh", long_options, &i)) != -1) { + switch (opt) { + case 's': + Options.strict = true; + break; + case 'h': + Options.help = true; + break; + default: + usage(); + exit(1); + break; + } + } + argc -= optind; + argv += optind; + if (Options.help) { + usage(); + return 0; + } + if (argc < 1) { + usage(); + exit(1); + } + scan_file(argv[0]); + return 0; +} |