From: John Tsiombikas <nuclear@member.fsf.org>
Date: Sun, 17 Feb 2019 04:08:30 +0000 (+0200)
Subject: initial commit
X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?p=img2tiles;a=commitdiff_plain;h=ad3c27df5b624f0ba85b42a5f7d2209b732bc5a7

initial commit
---

ad3c27df5b624f0ba85b42a5f7d2209b732bc5a7
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..9aa7267
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,5 @@
+*.o
+*.d
+*.swp
+img2tiles
+*.png
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..796b563
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,24 @@
+PREFIX = /usr/local
+
+src = $(wildcard src/*.c)
+obj = $(src:.c=.o)
+bin = img2tiles
+
+CFLAGS = -pedantic -Wall -g
+LDFLAGS = -lpng -lz
+
+$(bin): $(obj)
+	$(CC) -o $@ $(obj) $(LDFLAGS)
+
+.PHONY: clean
+clean:
+	rm -f $(obj) $(bin)
+
+.PHONY: install
+install: $(bin)
+	mkdir -p $(DESTDIR)$(PREFIX)/bin
+	cp $(bin) $(DESTDIR)$(PREFIX)/bin/$(bin)
+
+.PHONY: uninstall
+uninstall:
+	rm -f $(DESTDIR)$(PREFIX)/bin/$(bin)
diff --git a/src/dynarr.c b/src/dynarr.c
new file mode 100644
index 0000000..59bbf8c
--- /dev/null
+++ b/src/dynarr.c
@@ -0,0 +1,141 @@
+/* dynarr - dynamic resizable C array data structure
+ * author: John Tsiombikas <nuclear@member.fsf.org>
+ * license: public domain
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "dynarr.h"
+
+/* The array descriptor keeps auxilliary information needed to manipulate
+ * the dynamic array. It's allocated adjacent to the array buffer.
+ */
+struct arrdesc {
+	int nelem, szelem;
+	int max_elem;
+	int bufsz;	/* not including the descriptor */
+};
+
+#define DESC(x)		((struct arrdesc*)((char*)(x) - sizeof(struct arrdesc)))
+
+void *dynarr_alloc(int elem, int szelem)
+{
+	struct arrdesc *desc;
+
+	if(!(desc = malloc(elem * szelem + sizeof *desc))) {
+		return 0;
+	}
+	desc->nelem = desc->max_elem = elem;
+	desc->szelem = szelem;
+	desc->bufsz = elem * szelem;
+	return (char*)desc + sizeof *desc;
+}
+
+void dynarr_free(void *da)
+{
+	if(da) {
+		free(DESC(da));
+	}
+}
+
+void *dynarr_resize(void *da, int elem)
+{
+	int newsz;
+	void *tmp;
+	struct arrdesc *desc;
+
+	if(!da) return 0;
+	desc = DESC(da);
+
+	newsz = desc->szelem * elem;
+
+	if(!(tmp = realloc(desc, newsz + sizeof *desc))) {
+		return 0;
+	}
+	desc = tmp;
+
+	desc->nelem = desc->max_elem = elem;
+	desc->bufsz = newsz;
+	return (char*)desc + sizeof *desc;
+}
+
+int dynarr_empty(void *da)
+{
+	return DESC(da)->nelem ? 0 : 1;
+}
+
+int dynarr_size(void *da)
+{
+	return DESC(da)->nelem;
+}
+
+
+void *dynarr_clear(void *da)
+{
+	return dynarr_resize(da, 0);
+}
+
+/* stack semantics */
+void *dynarr_push(void *da, void *item)
+{
+	struct arrdesc *desc;
+	int nelem;
+
+	desc = DESC(da);
+	nelem = desc->nelem;
+
+	if(nelem >= desc->max_elem) {
+		/* need to resize */
+		struct arrdesc *tmp;
+		int newsz = desc->max_elem ? desc->max_elem * 2 : 1;
+
+		if(!(tmp = dynarr_resize(da, newsz))) {
+			fprintf(stderr, "failed to resize\n");
+			return da;
+		}
+		da = tmp;
+		desc = DESC(da);
+		desc->nelem = nelem;
+	}
+
+	if(item) {
+		memcpy((char*)da + desc->nelem * desc->szelem, item, desc->szelem);
+	}
+	desc->nelem++;
+	return da;
+}
+
+void *dynarr_pop(void *da)
+{
+	struct arrdesc *desc;
+	int nelem;
+
+	desc = DESC(da);
+	nelem = desc->nelem;
+
+	if(!nelem) return da;
+
+	if(nelem <= desc->max_elem / 3) {
+		/* reclaim space */
+		struct arrdesc *tmp;
+		int newsz = desc->max_elem / 2;
+
+		if(!(tmp = dynarr_resize(da, newsz))) {
+			fprintf(stderr, "failed to resize\n");
+			return da;
+		}
+		da = tmp;
+		desc = DESC(da);
+		desc->nelem = nelem;
+	}
+	desc->nelem--;
+
+	return da;
+}
+
+void *dynarr_finalize(void *da)
+{
+	struct arrdesc *desc = DESC(da);
+	memmove(desc, da, desc->bufsz);
+	return desc;
+}
diff --git a/src/dynarr.h b/src/dynarr.h
new file mode 100644
index 0000000..8690b5a
--- /dev/null
+++ b/src/dynarr.h
@@ -0,0 +1,80 @@
+/* dynarr - dynamic resizable C array data structure
+ * author: John Tsiombikas <nuclear@member.fsf.org>
+ * license: public domain
+ */
+#ifndef DYNARR_H_
+#define DYNARR_H_
+
+/* usage example:
+ * -------------
+ * int *arr = dynarr_alloc(0, sizeof *arr);
+ *
+ * int x = 10;
+ * arr = dynarr_push(arr, &x);
+ * x = 5;
+ * arr = dynarr_push(arr, &x);
+ * x = 42;
+ * arr = dynarr_push(arr, &x);
+ *
+ * for(i=0; i<dynarr_size(arr); i++) {
+ *     printf("%d\n", arr[i]);
+ *  }
+ *  dynarr_free(arr);
+ */
+
+void *dynarr_alloc(int elem, int szelem);
+void dynarr_free(void *da);
+void *dynarr_resize(void *da, int elem);
+
+/* dynarr_empty returns non-zero if the array is empty
+ * Complexity: O(1) */
+int dynarr_empty(void *da);
+/* dynarr_size returns the number of elements in the array
+ * Complexity: O(1) */
+int dynarr_size(void *da);
+
+void *dynarr_clear(void *da);
+
+/* stack semantics */
+void *dynarr_push(void *da, void *item);
+void *dynarr_pop(void *da);
+
+/* Finalize the array. No more resizing is possible after this call.
+ * Use free() instead of dynarr_free() to deallocate a finalized array.
+ * Returns pointer to the finalized array.
+ * dynarr_finalize can't fail.
+ * Complexity: O(n)
+ */
+void *dynarr_finalize(void *da);
+
+/* helper macros */
+#define DYNARR_RESIZE(da, n) \
+	do { (da) = dynarr_resize((da), (n)); } while(0)
+#define DYNARR_CLEAR(da) \
+	do { (da) = dynarr_clear(da); } while(0)
+#define DYNARR_PUSH(da, item) \
+	do { (da) = dynarr_push((da), (item)); } while(0)
+#define DYNARR_POP(da) \
+	do { (da) = dynarr_pop(da); } while(0)
+
+/* utility macros to push characters to a string. assumes and maintains
+ * the invariant that the last element is always a zero
+ */
+#define DYNARR_STRPUSH(da, c) \
+	do { \
+		char cnull = 0, ch = (char)(c); \
+		(da) = dynarr_pop(da); \
+		(da) = dynarr_push((da), &ch); \
+		(da) = dynarr_push((da), &cnull); \
+	} while(0)
+
+#define DYNARR_STRPOP(da) \
+	do { \
+		char cnull = 0; \
+		(da) = dynarr_pop(da); \
+		(da) = dynarr_pop(da); \
+		(da) = dynarr_push((da), &cnull); \
+	} while(0)
+
+
+#endif	/* DYNARR_H_ */
diff --git a/src/image.c b/src/image.c
new file mode 100644
index 0000000..0ae86f9
--- /dev/null
+++ b/src/image.c
@@ -0,0 +1,237 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+#include <png.h>
+#include "image.h"
+
+int alloc_image(struct image *img, int x, int y, int bpp)
+{
+	memset(img, 0, sizeof *img);
+	img->width = x;
+	img->height = y;
+	img->bpp = bpp;
+	img->scansz = img->pitch = x * bpp / 8;
+
+	if(!(img->pixels = malloc(y * img->scansz))) {
+		fprintf(stderr, "failed to allocate %dx%d (%dbpp) pixel buffer\n", x, y, bpp);
+		return -1;
+	}
+
+	/* just a guess, assume the user will fill the details, but set up reasonable
+	 * defaults just in case...
+	 */
+	if(bpp <= 8) {
+		img->nchan = 1;
+		img->cmap_ncolors = 1 << bpp;
+	} else if(bpp <= 24) {
+		img->nchan = 3;
+	} else {
+		img->nchan = 4;
+	}
+	return 0;
+}
+
+int load_image(struct image *img, const char *fname)
+{
+	int i;
+	FILE *fp;
+	png_struct *png;
+	png_info *info;
+	int chan_bits, color_type;
+	png_uint_32 xsz, ysz;
+	png_color *palette;
+	unsigned char **scanline;
+	unsigned char *dptr;
+
+	if(!(fp = fopen(fname, "rb"))) {
+		fprintf(stderr, "failed to open: %s: %s\n", fname, strerror(errno));
+		return -1;
+	}
+
+	if(!(png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0))) {
+		fclose(fp);
+		return -1;
+	}
+	if(!(info = png_create_info_struct(png))) {
+		fclose(fp);
+		png_destroy_read_struct(&png, 0, 0);
+		return -1;
+	}
+	if(setjmp(png_jmpbuf(png))) {
+		fclose(fp);
+		png_destroy_read_struct(&png, &info, 0);
+		return -1;
+	}
+
+	png_init_io(png, fp);
+	png_read_png(png, info, 0, 0);
+
+	png_get_IHDR(png, info, &xsz, &ysz, &chan_bits, &color_type, 0, 0, 0);
+	img->width = xsz;
+	img->height = ysz;
+	img->nchan = png_get_channels(png, info);
+	img->bpp = img->nchan * chan_bits;
+	img->scansz = img->pitch = xsz * img->bpp / 8;
+	img->cmap_ncolors = 0;
+
+	if(color_type == PNG_COLOR_TYPE_PALETTE) {
+		png_get_PLTE(png, info, &palette, &img->cmap_ncolors);
+		memcpy(img->cmap, palette, img->cmap_ncolors * sizeof *img->cmap);
+	}
+
+	if(!(img->pixels = malloc(ysz * img->scansz))) {
+		perror("failed to allocate pixel buffer");
+		fclose(fp);
+		png_destroy_read_struct(&png, &info, 0);
+		return -1;
+	}
+	dptr = img->pixels;
+
+	scanline = (unsigned char**)png_get_rows(png, info);
+	for(i=0; i<ysz; i++) {
+		memcpy(dptr, scanline[i], img->scansz);
+		dptr += img->pitch;
+	}
+
+	fclose(fp);
+	png_destroy_read_struct(&png, &info, 0);
+	return 0;
+}
+
+int save_image(struct image *img, const char *fname)
+{
+	int i, chan_bits, coltype;
+	FILE *fp;
+	png_struct *png;
+	png_info *info;
+	png_text txt;
+	unsigned char **scanline = 0;
+	unsigned char *pptr;
+
+	if(!(fp = fopen(fname, "wb"))) {
+		fprintf(stderr, "save_image: failed to open: %s: %s\n", fname, strerror(errno));
+		return -1;
+	}
+
+	if(!(png = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0))) {
+		fclose(fp);
+		return -1;
+	}
+	if(!(info = png_create_info_struct(png))) {
+		png_destroy_write_struct(&png, 0);
+		fclose(fp);
+		return -1;
+	}
+
+	txt.compression = PNG_TEXT_COMPRESSION_NONE;
+	txt.key = "Software";
+	txt.text = "img2tiles";
+	txt.text_length = 0;
+
+	if(setjmp(png_jmpbuf(png))) {
+		png_destroy_write_struct(&png, &info);
+		free(scanline);
+		fclose(fp);
+		return -1;
+	}
+
+	switch(img->nchan) {
+	case 1:
+		if(img->cmap_ncolors > 0) {
+			coltype = PNG_COLOR_TYPE_PALETTE;
+		} else {
+			coltype = PNG_COLOR_TYPE_GRAY;
+		}
+		break;
+	case 2:
+		coltype = PNG_COLOR_TYPE_GRAY_ALPHA;
+		break;
+	case 3:
+		coltype = PNG_COLOR_TYPE_RGB;
+		break;
+	case 4:
+		coltype = PNG_COLOR_TYPE_RGB_ALPHA;
+		break;
+	}
+
+	chan_bits = img->bpp / img->nchan;
+	png_set_IHDR(png, info, img->width, img->height, chan_bits, coltype, PNG_INTERLACE_NONE,
+			PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+	png_set_text(png, info, &txt, 1);
+
+	if(img->cmap_ncolors > 0) {
+		png_set_PLTE(png, info, (png_color*)img->cmap, img->cmap_ncolors);
+	}
+
+	if(!(scanline = malloc(img->height * sizeof *scanline))) {
+		png_destroy_write_struct(&png, &info);
+		fclose(fp);
+		return -1;
+	}
+
+	pptr = img->pixels;
+	for(i=0; i<img->height; i++) {
+		scanline[i] = pptr;
+		pptr += img->pitch;
+	}
+	png_set_rows(png, info, scanline);
+
+	png_init_io(png, fp);
+	png_write_png(png, info, 0, 0);
+	png_destroy_write_struct(&png, &info);
+	free(scanline);
+	fclose(fp);
+	return 0;
+}
+
+
+int cmp_image(struct image *a, struct image *b)
+{
+	int i;
+	unsigned char *aptr = a->pixels;
+	unsigned char *bptr = b->pixels;
+
+	if(a->width != b->width || a->height != b->height || a->bpp != b->bpp || a->nchan != b->nchan) {
+		return -1;
+	}
+
+	for(i=0; i<a->height; i++) {
+		if(memcmp(aptr, bptr, a->scansz) != 0) {
+			return -1;
+		}
+		aptr += a->pitch;
+		bptr += b->pitch;
+	}
+	return 0;
+}
+
+void blit(struct image *src, int sx, int sy, int w, int h, struct image *dst, int dx, int dy)
+{
+	int i;
+	unsigned char *sptr, *dptr;
+
+	assert(src->bpp == dst->bpp);
+	assert(src->nchan == dst->nchan);
+
+	if(sx < 0) { w += sx; sx = 0; }
+	if(sy < 0) { h += sy; sy = 0; }
+	if(dx < 0) { w += dx; sx -= dx; dx = 0; }
+	if(dy < 0) { h += dy; sy -= dy; dy = 0; }
+	if(sx + w >= src->width) w = src->width - sx;
+	if(sy + h >= src->height) h = src->height - sy;
+	if(dx + w >= dst->width) w = dst->width - dx;
+	if(dy + h >= dst->height) h = dst->height - dy;
+
+	if(w <= 0 || h <= 0) return;
+
+	sptr = src->pixels + sy * src->pitch + sx * src->bpp / 8;
+	dptr = dst->pixels + dy * dst->pitch + dx * dst->bpp / 8;
+
+	for(i=0; i<h; i++) {
+		memcpy(dptr, sptr, w * dst->bpp / 8);
+		dptr += dst->pitch;
+		sptr += src->pitch;
+	}
+}
diff --git a/src/image.h b/src/image.h
new file mode 100644
index 0000000..b9f24b4
--- /dev/null
+++ b/src/image.h
@@ -0,0 +1,26 @@
+#ifndef IMAGE_H_
+#define IMAGE_H_
+
+struct cmapent {
+	unsigned char r, g, b;
+};
+
+struct image {
+	int width, height;
+	int bpp;
+	int nchan;
+	int scansz, pitch;
+	int cmap_ncolors;
+	struct cmapent cmap[256];
+	unsigned char *pixels;
+};
+
+int alloc_image(struct image *img, int x, int y, int bpp);
+int load_image(struct image *img, const char *fname);
+int save_image(struct image *img, const char *fname);
+
+int cmp_image(struct image *a, struct image *b);
+
+void blit(struct image *src, int sx, int sy, int w, int h, struct image *dst, int dx, int dy);
+
+#endif	/* IMAGE_H_ */
diff --git a/src/main.c b/src/main.c
new file mode 100644
index 0000000..a2845ac
--- /dev/null
+++ b/src/main.c
@@ -0,0 +1,196 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "image.h"
+#include "dynarr.h"
+
+void print_usage(const char *argv0);
+int proc_image(const char *fname);
+
+enum { OUT_IMG, OUT_C, OUT_ASM } outmode;
+int tile_xsz = 8, tile_ysz = 8;
+
+int main(int argc, char **argv)
+{
+	int i;
+
+	for(i=1; i<argc; i++) {
+		if(argv[i][0] == '-') {
+			if(argv[i][2] == 0) {
+				switch(argv[i][1]) {
+				case 't':
+					if(sscanf(argv[++i], "%dx%d", &tile_xsz, &tile_ysz) != 2) {
+						fprintf(stderr, "-t must be followed by the tile size (WxH)\n");
+						return 1;
+					}
+					break;
+
+				case 'c':
+					outmode = OUT_C;
+					break;
+
+				case 's':
+					outmode = OUT_ASM;
+					break;
+
+				case 'h':
+					print_usage(argv[0]);
+					return 0;
+
+				default:
+					fprintf(stderr, "invalid option: %s\n", argv[i]);
+					print_usage(argv[0]);
+					return 1;
+				}
+			} else {
+				fprintf(stderr, "invalid option: %s\n", argv[i]);
+				print_usage(argv[0]);
+				return 1;
+			}
+
+		} else {
+			if(proc_image(argv[i]) == -1) {
+				return 1;
+			}
+		}
+	}
+
+	return 0;
+}
+
+void print_usage(const char *argv0)
+{
+	printf("Usage: %s [options] <img1> [<img2> ... <imgN>]\n", argv0);
+	printf("Options:\n");
+	printf(" -t WxH: tile size (default 8x8)\n");
+	printf(" -c: output C array\n");
+	printf(" -s: output GNU assembler data\n");
+	printf(" -h: print usage and exit\n\n");
+}
+
+int find_tile(struct image *tile, struct image *tiles)
+{
+	int i, count;
+	count = dynarr_size(tiles);
+	for(i=0; i<count; i++) {
+		if(cmp_image(tile, tiles + i) == 0) {
+			return i;
+		}
+	}
+	return -1;
+}
+
+int proc_image(const char *fname)
+{
+	int i, j, k, idx, xtiles, ytiles, ntiles, result = -1;
+	struct image img, tile;
+	struct image *tiles = 0;
+	unsigned char *tiles_pixels, *tptr;
+	unsigned char *sptr;
+	int *tilemap = 0, *mapptr;
+
+	if(load_image(&img, fname) == -1) {
+		fprintf(stderr, "failed to load image: %s\n", fname);
+		return -1;
+	}
+
+	xtiles = img.width / tile_xsz;
+	ytiles = img.height / tile_ysz;
+	if(img.width % tile_xsz != 0 || img.height % tile_ysz != 0) {
+		fprintf(stderr, "image size (%dx%d) not evenly divisible into %dx%d tiles\n",
+				img.width, img.height, tile_xsz, tile_ysz);
+		goto err;
+	}
+
+	if(!(tilemap = malloc(xtiles * ytiles * sizeof *tilemap))) {
+		fprintf(stderr, "failed to allocate %dx%d tilemap\n", xtiles, ytiles);
+		goto err;
+	}
+	mapptr = tilemap;
+
+	if(!(tiles = dynarr_alloc(0, sizeof *tiles))) {
+		fprintf(stderr, "failed to allocate tile array\n");
+		goto err;
+	}
+	/* alloc a contiguous buffer for the full tileset pixels, to make it easier to write it
+	 * out as a single image in the end
+	 */
+	if(!(tiles_pixels = dynarr_alloc(0, tile_xsz * tile_ysz * img.bpp / 8))) {
+		fprintf(stderr, "failed to allocate tile pixel buffer\n");
+		goto err;
+	}
+
+	tile = img;
+	tile.width = tile_xsz;
+	tile.height = tile_ysz;
+	tile.scansz = tile_xsz * tile.bpp / 8;
+
+	sptr = img.pixels;
+	for(i=0; i<ytiles; i++) {
+		for(j=0; j<xtiles; j++) {
+			tile.pixels = sptr;
+
+			if((idx = find_tile(&tile, tiles)) == -1) {
+				/* we don't have a duplicate of this tile */
+				idx = dynarr_size(tiles);
+
+				if(!(tiles = dynarr_push(tiles, 0))) {
+					goto err;
+				}
+				if(!(tptr = dynarr_push(tiles_pixels, 0))) {
+					goto err;
+				}
+
+				tiles[idx] = tile;
+				tiles[idx].scansz = tiles[idx].pitch = tile.scansz;
+
+				/* did the array get relocated? */
+				if(tptr != tiles_pixels) {
+					tiles_pixels = tptr;
+					/* make each tile's pixels pointer point to the right place in the large pixelbuffer */
+					for(k=0; k<idx+1; k++) {
+						tiles[k].pixels = tptr;
+						tptr += tile_ysz * tiles[idx].pitch;
+					}
+				} else {
+					/* otherwise just set the new one */
+					tiles[idx].pixels = tiles_pixels + idx * tile_ysz * tiles[idx].pitch;
+				}
+
+				blit(&tile, 0, 0, tile_xsz, tile_ysz, tiles + idx, 0, 0);
+			}
+
+			*mapptr++ = idx;
+
+			sptr += tile.scansz;
+		}
+		sptr += (tile_ysz - 1) * tile.scansz;
+	}
+
+	ntiles = dynarr_size(tiles);
+	fprintf(stderr, "%s (%dx%d) -> %d tiles, %d unique\n", fname, img.width, img.height,
+			xtiles * ytiles, ntiles);
+
+
+	if(ntiles > 0) {
+		FILE *fp;
+
+		/* make a big image out of the tiles and write it out */
+		tile = tiles[0];
+		tile.height = ntiles * tile_ysz;
+		if(save_image(&tile, "test.png") == -1) {
+			fprintf(stderr, "failed to write output image\n");
+			goto err;
+		}
+	}
+	/* TODO cont. */
+
+	result = 0;
+
+err:
+	dynarr_free(tiles_pixels);
+	dynarr_free(tiles);
+	free(tilemap);
+	free(img.pixels);
+	return result;
+}