X-Git-Url: http://git.tdb.fi/?p=ttf2png.git;a=blobdiff_plain;f=ttf2png.c;h=770f0c633119efc6a3e6219a287bb85de48a193e;hp=eabe1ca93b588f6419c6ac76479cd44b4b99eef4;hb=HEAD;hpb=59f8fe66098f933c68dd61e8f0b94f3cf8d698a7

diff --git a/ttf2png.c b/ttf2png.c
index eabe1ca..76c2e0d 100644
--- a/ttf2png.c
+++ b/ttf2png.c
@@ -1,6 +1,6 @@
 /*
 ttf2png - True Type Font to PNG converter
-Copyright (c) 2004-2008 Mikko Rasa
+Copyright (c) 2004-2021 Mikko Rasa, Mikkosoft Productions
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -29,6 +29,7 @@ typedef struct sImage
 {
 	unsigned w, h;
 	unsigned char *data;
+	unsigned border;
 } Image;
 
 typedef struct sGlyph
@@ -44,8 +45,8 @@ typedef struct sGlyph
 
 typedef struct sKerning
 {
-	unsigned left_code;
-	unsigned right_code;
+	Glyph *left_glyph;
+	Glyph *right_glyph;
 	int distance;
 } Kerning;
 
@@ -67,24 +68,27 @@ typedef struct sRange
 	unsigned last;
 } Range;
 
-typedef int bool;
+typedef unsigned char bool;
 
 void usage(void);
 int convert_numeric_option(char, int);
 void convert_code_point_range(char, Range *);
-unsigned str_to_code_point(const char *, char **);
+int str_to_code_point(const char *, char **);
 void convert_size(char, unsigned *, unsigned *);
 void sort_and_compact_ranges(Range *, unsigned *);
 int range_cmp(const void *, const void *);
 unsigned round_to_pot(unsigned);
-void *alloc_image_data(size_t, size_t);
-int init_font(Font *, FT_Face, const Range *, unsigned, bool);
-int init_glyphs(Font *, FT_Face, const Range *, bool);
+int init_image(Image *, size_t, size_t);
+int init_font(Font *, FT_Face, const Range *, unsigned, bool, unsigned, unsigned);
+int init_glyphs(Font *, FT_Face, const Range *, bool, unsigned, unsigned);
 int copy_bitmap(const FT_Bitmap *, Image *);
-int render_grid(Font *, unsigned, unsigned, unsigned, bool, bool);
-int render_packed(Font *, unsigned, unsigned, bool);
+unsigned sqrti(unsigned);
+unsigned find_distance_to_edge(const Image *, int, int, unsigned);
+int create_distance_field(const FT_Bitmap *, Image *, unsigned, unsigned);
+int render_grid(Font *, unsigned, unsigned, unsigned, bool);
+int render_packed(Font *, unsigned, unsigned);
 int save_defs(const char *, const Font *);
-int save_png(const char *, const Image *, char);
+int save_png(const char *, const Image *, bool, bool, bool);
 
 char verbose = 0;
 
@@ -105,6 +109,8 @@ int main(int argc, char **argv)
 	unsigned margin = 0;
 	unsigned padding = 1;
 	bool npot = 0;
+	unsigned distfield = 0;
+	unsigned border = 0;
 
 	FT_Library freetype;
 	FT_Face face;
@@ -123,7 +129,7 @@ int main(int argc, char **argv)
 		return 1;
 	}
 
-	while((i = getopt(argc, argv, "r:s:l:c:o:atvh?ed:pim:n:f")) != -1)
+	while((i = getopt(argc, argv, "r:s:l:c:o:atvh?ed:pim:n:gf:b:")) != -1)
 	{
 		switch(i)
 		{
@@ -174,9 +180,15 @@ int main(int argc, char **argv)
 		case 'n':
 			padding = convert_numeric_option('n', 0);
 			break;
-		case 'f':
+		case 'g':
 			npot = 1;
 			break;
+		case 'f':
+			distfield = convert_numeric_option('f', 1);
+			break;
+		case 'b':
+			border = convert_numeric_option('b', 1);
+			break;
 		}
 	}
 	if(!strcmp(out_fn, "-"))
@@ -213,6 +225,14 @@ int main(int argc, char **argv)
 		printf("Glyphs:    %ld\n", face->num_glyphs);
 	}
 
+	font.size = size;
+	if(distfield)
+	{
+		if(!border)
+			border = sqrti(font.size);
+		size *= distfield;
+	}
+
 	err = FT_Set_Pixel_Sizes(face, 0, size);
 	if(err)
 	{
@@ -230,8 +250,7 @@ int main(int argc, char **argv)
 	else
 		sort_and_compact_ranges(ranges, &n_ranges);
 
-	font.size = size;
-	err = init_font(&font, face, ranges, n_ranges, autohinter);
+	err = init_font(&font, face, ranges, n_ranges, autohinter, distfield, border);
 	if(err)
 		return 1;
 
@@ -242,18 +261,13 @@ int main(int argc, char **argv)
 	}
 
 	if(pack)
-		err = render_packed(&font, margin, padding, npot);
+		err = render_packed(&font, margin, padding);
 	else
-		err = render_grid(&font, cellw, cellh, cpl, seq, npot);
+		err = render_grid(&font, cellw, cellh, cpl, seq);
 	if(err)
 		return 1;
 
-	if(invert)
-	{
-		for(i=0; (unsigned)i<font.image.w*font.image.h; ++i)
-			font.image.data[i] = 255-font.image.data[i];
-	}
-	err = save_png(out_fn, &font.image, alpha);
+	err = save_png(out_fn, &font.image, (alpha && !distfield), (invert || distfield), npot);
 	if(err)
 		return 1;
 
@@ -275,8 +289,8 @@ int main(int argc, char **argv)
 
 void usage(void)
 {
-	printf("ttf2png 1.1 - True Type Font to PNG converter\n"
-		"Copyright (c) 2004-2018  Mikko Rasa, Mikkosoft Productions\n"
+	printf("ttf2png 2.0 - True Type Font to PNG converter\n"
+		"Copyright (c) 2004-2021  Mikko Rasa, Mikkosoft Productions\n"
 		"Distributed under the GNU General Public License\n\n");
 
 	printf("Usage: ttf2png [options] <TTF file>\n\n");
@@ -295,7 +309,9 @@ void usage(void)
 		"  -p  Pack the glyphs tightly instead of in a grid\n"
 		"  -m  Margin around image edges (packed mode only) [0]\n"
 		"  -n  Padding between glyphs (packed mode only) [1]\n"
-		"  -f  Allow non-power-of-two result\n"
+		"  -g  Allow non-power-of-two result\n");
+	printf("  -f  Create a distance field texture\n"
+		"  -b  Specify distance field border zone width\n"
 		"  -d  File name for writing glyph definitions\n"
 		"  -h  Print this message\n");
 }
@@ -328,11 +344,11 @@ void convert_code_point_range(char opt, Range *range)
 	}
 
 	value = str_to_code_point(optarg, &ptr);
-	if(value>0 && *ptr==',')
+	if(value>=0 && *ptr==',')
 	{
 		range->first = value;
 		value = str_to_code_point(ptr+1, &ptr);
-		if(value>0 && !*ptr)
+		if(value>=(int)range->first && !*ptr)
 		{
 			range->last = value;
 			return;
@@ -343,7 +359,7 @@ void convert_code_point_range(char opt, Range *range)
 	exit(1);
 }
 
-unsigned str_to_code_point(const char *nptr, char **endptr)
+int str_to_code_point(const char *nptr, char **endptr)
 {
 	if(nptr[0]=='U' && nptr[1]=='+')
 		return strtoul(nptr+2, endptr, 16);
@@ -358,9 +374,9 @@ unsigned str_to_code_point(const char *nptr, char **endptr)
 
 		for(bytes=1; (bytes<4 && (nptr[0]&(0x80>>bytes))); ++bytes)
 			if((nptr[bytes]&0xC0)!=0x80)
-				return 0;
+				return -1;
 		if(bytes<2)
-			return 0;
+			return -1;
 
 		code = nptr[0]&(0x3F>>bytes);
 		for(i=1; i<bytes; ++i)
@@ -473,37 +489,43 @@ unsigned round_to_pot(unsigned n)
 	return n+1;
 }
 
-void *alloc_image_data(size_t a, size_t b)
+int init_image(Image *image, size_t w, size_t h)
 {
-	void *ptr;
+	size_t s;
+
+	image->w = w;
+	image->h = h;
+	image->data = NULL;
+	image->border = 0;
 
-	/* Carry out the multiplication manually so we can check for overflow. */
-	while(b>1)
+	if(!image->w || !image->h)
+		return 0;
+
+	s = w*h;
+	if(s/h!=w)
 	{
-		size_t c = a;
-		a *= 2;
-		if(b&1)
-			a += c;
-		if(a<c)
-		{
-			fprintf(stderr, "Cannot allocate %lu kbytes of memory for image\n", (unsigned long)(c/1024*b));
-			return NULL;
-		}
-		b /= 2;
+		fprintf(stderr, "Cannot allocate memory for a %dx%d image\n", image->w, image->h);
+		return -1;
 	}
-	ptr = malloc(a);
-	if(!ptr)
-		fprintf(stderr, "Cannot allocate %lu kbytes of memory for image\n", (unsigned long)(a/1024*b));
-	return ptr;
+
+	image->data = malloc(s);
+	if(!image->data)
+	{
+		fprintf(stderr, "Cannot allocate memory for a %dx%d image\n", image->w, image->h);
+		return -1;
+	}
+
+	return 0;
 }
 
-int init_font(Font *font, FT_Face face, const Range *ranges, unsigned n_ranges, bool autohinter)
+int init_font(Font *font, FT_Face face, const Range *ranges, unsigned n_ranges, bool autohinter, unsigned distfield, unsigned border)
 {
 	unsigned i, j;
 	unsigned size = 0;
+	int scale = (distfield>0 ? distfield : 1);
 
-	font->ascent = (face->size->metrics.ascender+63)/64;
-	font->descent = (face->size->metrics.descender-63)/64;
+	font->ascent = (face->size->metrics.ascender/scale+63)/64;
+	font->descent = (face->size->metrics.descender/scale-63)/64;
 
 	if(verbose>=1)
 	{
@@ -514,7 +536,7 @@ int init_font(Font *font, FT_Face face, const Range *ranges, unsigned n_ranges,
 	font->n_glyphs = 0;
 	font->glyphs = NULL;
 	for(i=0; i<n_ranges; ++i)
-		if(init_glyphs(font, face, &ranges[i], autohinter))
+		if(init_glyphs(font, face, &ranges[i], autohinter, distfield, border))
 			return -1;
 
 	if(verbose>=1)
@@ -541,9 +563,9 @@ int init_font(Font *font, FT_Face face, const Range *ranges, unsigned n_ranges,
 				}
 
 				kern = &font->kerning[font->n_kerning++];
-				kern->left_code = font->glyphs[i].code;
-				kern->right_code = font->glyphs[j].code;
-				kern->distance = kerning.x/64;
+				kern->left_glyph = &font->glyphs[i];
+				kern->right_glyph = &font->glyphs[j];
+				kern->distance = (kerning.x/scale+32)/64;
 			}
 		}
 
@@ -553,10 +575,11 @@ int init_font(Font *font, FT_Face face, const Range *ranges, unsigned n_ranges,
 	return 0;
 }
 
-int init_glyphs(Font *font, FT_Face face, const Range *range, bool autohinter)
+int init_glyphs(Font *font, FT_Face face, const Range *range, bool autohinter, unsigned distfield, unsigned border)
 {
 	unsigned i, j;
 	unsigned size = font->n_glyphs;
+	int scale = (distfield>0 ? distfield : 1);
 
 	for(i=range->first; i<=range->last; ++i)
 	{
@@ -572,7 +595,7 @@ int init_glyphs(Font *font, FT_Face face, const Range *range, bool autohinter)
 		if(autohinter)
 			flags |= FT_LOAD_FORCE_AUTOHINT;
 		FT_Load_Glyph(face, n, flags);
-		FT_Render_Glyph(face->glyph, FT_RENDER_MODE_NORMAL);
+		FT_Render_Glyph(face->glyph, (distfield ? FT_RENDER_MODE_MONO : FT_RENDER_MODE_NORMAL));
 
 		if(verbose>=2)
 		{
@@ -592,7 +615,7 @@ int init_glyphs(Font *font, FT_Face face, const Range *range, bool autohinter)
 
 				printf(" (%s)", utf8);
 			}
-			printf(": glyph %u, size %dx%d\n", n, bmp->width, bmp->rows);
+			printf(": glyph %u, size %dx%d\n", n, bmp->width/scale, bmp->rows/scale);
 		}
 
 		if(bmp->pixel_mode!=FT_PIXEL_MODE_GRAY && bmp->pixel_mode!=FT_PIXEL_MODE_MONO)
@@ -610,15 +633,24 @@ int init_glyphs(Font *font, FT_Face face, const Range *range, bool autohinter)
 		glyph = &font->glyphs[font->n_glyphs++];
 		glyph->index = n;
 		glyph->code = i;
-		glyph->offset_x = face->glyph->bitmap_left;
-		glyph->offset_y = face->glyph->bitmap_top-bmp->rows;
-		glyph->advance = (int)(face->glyph->advance.x+32)/64;
+		glyph->offset_x = (int)(face->glyph->bitmap_left+scale/2)/scale;
+		glyph->offset_y = (int)(face->glyph->bitmap_top-bmp->rows+scale/2)/scale;
+		glyph->advance = (int)(face->glyph->advance.x/scale+32)/64;
 
 		/* Copy the glyph image since FreeType uses a global buffer, which would
 		be overwritten by the next glyph.  Negative pitch means the scanlines
 		start from the bottom. */
-		if(copy_bitmap(bmp, &glyph->image))
-			return -1;
+		if(distfield)
+		{
+			glyph->offset_x -= border;
+			glyph->offset_y -= border;
+			create_distance_field(bmp, &glyph->image, distfield, border);
+		}
+		else
+		{
+			if(copy_bitmap(bmp, &glyph->image))
+				return -1;
+		}
 	}
 
 	return 0;
@@ -630,20 +662,10 @@ int copy_bitmap(const FT_Bitmap *bmp, Image *image)
 	unsigned char *src;
 	unsigned char *dst;
 
-	image->w = bmp->width;
-	image->h = bmp->rows;
+	if(init_image(image, bmp->width, bmp->rows))
+		return -1;
 	if(!image->w || !image->h)
-	{
-		image->data = NULL;
 		return 0;
-	}
-
-	image->data = (unsigned char *)malloc(image->w*image->h);
-	if(!image->data)
-	{
-		fprintf(stderr, "Cannot allocate %d bytes of memory for glyph\n", image->w*image->h);
-		return -1;
-	}
 
 	if(bmp->pitch<0)
 		src = bmp->buffer+(bmp->rows-1)*-bmp->pitch;
@@ -671,11 +693,87 @@ int copy_bitmap(const FT_Bitmap *bmp, Image *image)
 	return 0;
 }
 
-int render_grid(Font *font, unsigned cellw, unsigned cellh, unsigned cpl, bool seq, bool npot)
+unsigned sqrti(unsigned num)
+{
+	unsigned result = (num>0xFFFF ? 0xFFFF : 0x100);
+	while(result && result*result>=result+num)
+		result -= (result*result+result-num)/(result*2);
+
+	return result;
+}
+
+unsigned find_distance_to_edge(const Image *image, int origin_x, int origin_y, unsigned range)
+{
+	unsigned i, j;
+	int x, y;
+	unsigned char origin_pixel = 0;
+	unsigned closest = range*range;
+
+	if(origin_x>=0 && (unsigned)origin_x<image->w && origin_y>=0 && (unsigned)origin_y<image->h)
+		origin_pixel = image->data[origin_x+origin_y*image->w];
+
+	x = origin_x-1;
+	y = origin_y-1;
+	for(i=1; (i<range && i*i<=closest); ++i, --x, --y) for(j=0; j<4; ++j)
+	{
+		unsigned k;
+		int dx = (j==0 ? 1 : j==2 ? -1 : 0);
+		int dy = (j==1 ? 1 : j==3 ? -1 : 0);
+
+		for(k=0; k<i*2; ++k, x+=dx, y+=dy)
+		{
+			unsigned char pixel = 0;
+			if(x>=0 && (unsigned)x<image->w && y>=0 && (unsigned)y<image->h)
+				pixel = image->data[x+y*image->w];
+				
+			if((pixel^origin_pixel)&0x80)
+			{
+				unsigned d = 2*i*i + k*k - 2*k*i;
+				if(d<closest)
+					closest = d;
+			}
+		}
+	}
+
+	return sqrti(closest*0x3F01)/range;
+}
+
+int create_distance_field(const FT_Bitmap *bmp, Image *image, unsigned scale, unsigned margin)
+{
+	unsigned x, y;
+	Image base_image;
+
+	if(init_image(image, (bmp->width+scale-1)/scale+2*margin, (bmp->rows+scale-1)/scale+2*margin))
+		return -1;
+	if(!image->w || !image->h)
+		return 0;
+
+	if(copy_bitmap(bmp, &base_image))
+		return -1;
+
+	image->border = margin;
+	for(y=0; y<image->h; ++y) for(x=0; x<image->w; ++x)
+	{
+		int bx = (x-margin)*scale+scale/2;
+		int by = (y-margin)*scale+scale/2;
+		unsigned char pixel = find_distance_to_edge(&base_image, bx, by, margin*scale);
+		if(bx>=0 && (unsigned)bx<base_image.w && by>=0 && (unsigned)by<base_image.h)
+			pixel |= base_image.data[bx+by*base_image.w]&0x80;
+		if(!(pixel&0x80))
+			pixel = 0x80-pixel;
+		image->data[x+y*image->w] = pixel;
+	}
+
+	free(base_image.data);
+
+	return 0;
+}
+
+int render_grid(Font *font, unsigned cellw, unsigned cellh, unsigned cpl, bool seq)
 {
 	unsigned i;
 	int top = 0, bot = 0;
-	unsigned first, last;
+	unsigned first, n_cells;
 	unsigned maxw = 0, maxh = 0;
 
 	/* Find extremes of the glyph images. */
@@ -731,24 +829,17 @@ int render_grid(Font *font, unsigned cellw, unsigned cellh, unsigned cpl, bool s
 	}
 
 	first = font->glyphs[0].code;
-	if(!seq)
-		first -= first%cpl;
-	last = font->glyphs[font->n_glyphs-1].code;
-
-	font->image.w = cpl*cellw;
-	if(!npot)
-		font->image.w = round_to_pot(font->image.w);
 	if(seq)
-		font->image.h = (font->n_glyphs+cpl-1)/cpl*cellh;
+		n_cells = font->n_glyphs;
 	else
-		font->image.h = (last-first+cpl)/cpl*cellh;
-	if(!npot)
-		font->image.h = round_to_pot(font->image.h);
+	{
+		first -= first%cpl;
+		n_cells = font->glyphs[font->n_glyphs-1].code+1-first;
+	}
 
-	font->image.data = (unsigned char *)alloc_image_data(font->image.w, font->image.h);
-	if(!font->image.data)
+	if(init_image(&font->image, cpl*cellw, (n_cells+cpl-1)/cpl*cellh))
 		return -1;
-	memset(font->image.data, 255, font->image.w*font->image.h);
+	memset(font->image.data, 0, font->image.w*font->image.h);
 
 	for(i=0; i<font->n_glyphs; ++i)
 	{
@@ -777,18 +868,18 @@ int render_grid(Font *font, unsigned cellw, unsigned cellh, unsigned cpl, bool s
 		{
 			if(cx+x>=font->image.w || cy+y>=font->image.h)
 				continue;
-			font->image.data[cx+x+(cy+y)*font->image.w] = 255-glyph->image.data[x+y*glyph->image.w];
+			font->image.data[cx+x+(cy+y)*font->image.w] = glyph->image.data[x+y*glyph->image.w];
 		}
 	}
 
 	return 0;
 }
 
-int render_packed(Font *font, unsigned margin, unsigned padding, bool npot)
+int render_packed(Font *font, unsigned margin, unsigned padding)
 {
 	unsigned i;
 	size_t area = 0;
-	char *used_glyphs;
+	bool *used_glyphs;
 	unsigned *used_pixels;
 	unsigned cx = margin, cy;
 	unsigned used_h = 0;
@@ -805,30 +896,29 @@ int render_packed(Font *font, unsigned margin, unsigned padding, bool npot)
 		area = a;
 	}
 
-	/* Find an image size that's no higher than wide, allowing for some
-	imperfections in the packing. */
+	/* Find an image size that's approximately square. */
 	for(font->image.w=1;; font->image.w<<=1)
 	{
 		if(font->image.w<=margin*2)
 			continue;
-		font->image.h = (area*5/4)/(font->image.w-margin*2)+margin*2;
+		font->image.h = area/(font->image.w-margin*2)+margin*2;
 		if(font->image.h<=font->image.w)
 			break;
 	}
-	if(!npot)
-		font->image.h = round_to_pot(font->image.h);
+
+	/* Add some extra space to accommodate packing imperfections. */
+	font->image.h = font->image.h*3/2;
 
 	/* Allocate arrays for storing the image and keeping track of used pixels and
 	glyphs.  Since glyphs are rectangular and the image is filled starting from
 	the top, it's enough to track the number of used pixels at the top of each
 	column. */
-	font->image.data = (unsigned char *)alloc_image_data(font->image.w, font->image.h);
-	if(!font->image.data)
+	if(init_image(&font->image, font->image.w, font->image.h))
 		return -1;
-	memset(font->image.data, 255, font->image.w*font->image.h);
+	memset(font->image.data, 0, font->image.w*font->image.h);
 	used_pixels = (unsigned *)malloc(font->image.w*sizeof(unsigned));
 	memset(used_pixels, 0, font->image.w*sizeof(unsigned));
-	used_glyphs = (char *)malloc(font->n_glyphs);
+	used_glyphs = (bool *)malloc(font->n_glyphs);
 	memset(used_glyphs, 0, font->n_glyphs);
 
 	for(cy=margin; cy+margin<font->image.h;)
@@ -896,7 +986,7 @@ int render_packed(Font *font, unsigned margin, unsigned padding, bool npot)
 		{
 			if(cx+x>=font->image.w || cy+y>=font->image.h)
 				continue;
-			font->image.data[cx+x+(cy+y)*font->image.w] = 255-glyph->image.data[x+y*glyph->image.w];
+			font->image.data[cx+x+(cy+y)*font->image.w] = glyph->image.data[x+y*glyph->image.w];
 		}
 		for(x=0; x<glyph->image.w+2*padding; ++x)
 		{
@@ -913,8 +1003,6 @@ int render_packed(Font *font, unsigned margin, unsigned padding, bool npot)
 	/* Trim the image to the actually used size, in case the original estimate
 	was too pessimistic. */
 	font->image.h = used_h;
-	if(!npot)
-		font->image.h = round_to_pot(font->image.h);
 
 	free(used_glyphs);
 	free(used_pixels);
@@ -937,19 +1025,38 @@ int save_defs(const char *fn, const Font *font)
 	fprintf(out, "# Image/font info:\n");
 	fprintf(out, "# width height size ascent descent\n");
 	fprintf(out, "font %d %d %d %d %d\n", font->image.w, font->image.h, font->size, font->ascent, font->descent);
+
+	fprintf(out, "\n# Code point mapping:\n");
+	fprintf(out, "# code index\n");
+	for(i=0; i<font->n_glyphs; ++i)
+	{
+		const Glyph *g = &font->glyphs[i];
+		fprintf(out, "code %u %u\n", g->code, g->index);
+	}
+
+	fprintf(out, "\n# Metrics info:\n");
+	fprintf(out, "# index width height offset_x offset_y advance\n");
+	for(i=0; i<font->n_glyphs; ++i)
+	{
+		const Glyph *g = &font->glyphs[i];
+		int b = g->image.border;
+		fprintf(out, "metrics %u %u %u %d %d %d\n", g->index, g->image.w-2*b, g->image.h-2*b, g->offset_x+b, g->offset_y+b, g->advance);
+	}
+
 	fprintf(out, "\n# Glyph info:\n");
-	fprintf(out, "# code x y width height offset_x offset_y advance\n");
+	fprintf(out, "# index x y width height border\n");
 	for(i=0; i<font->n_glyphs; ++i)
 	{
 		const Glyph *g = &font->glyphs[i];
-		fprintf(out, "glyph %u %u %u %u %u %d %d %d\n", g->code, g->x, g->y, g->image.w, g->image.h, g->offset_x, g->offset_y, g->advance);
+		fprintf(out, "glyph %u %u %u %u %u %u\n", g->index, g->x, g->y, g->image.w, g->image.h, g->image.border);
 	}
+
 	fprintf(out, "\n# Kerning info:\n");
 	fprintf(out, "# left right distance\n");
 	for(i=0; i<font->n_kerning; ++i)
 	{
 		const Kerning *k = &font->kerning[i];
-		fprintf(out, "kern %u %u %d\n", k->left_code, k->right_code, k->distance);
+		fprintf(out, "kern %u %u %d\n", k->left_glyph->index, k->right_glyph->index, k->distance);
 	}
 
 	fclose(out);
@@ -957,15 +1064,17 @@ int save_defs(const char *fn, const Font *font)
 	return 0;
 }
 
-int save_png(const char *fn, const Image *image, char alpha)
+int save_png(const char *fn, const Image *image, bool alpha, bool invert, bool npot)
 {
 	FILE *out;
 	png_struct *pngs;
 	png_info *pngi;
-	png_byte **rows;
-	unsigned i;
-	png_byte *data2 = 0;
+	unsigned w, h;
+	png_byte *row;
+	unsigned x, y;
 	int color;
+	unsigned flip_bits = (invert==alpha ? 0xFF : 0x00);
+	unsigned char *src = image->data;
 
 	if(!strcmp(fn, "-"))
 		out = stdout;
@@ -993,38 +1102,53 @@ int save_png(const char *fn, const Image *image, char alpha)
 		return -1;
 	}
 
+	w = (npot ? image->w : round_to_pot(image->w));
+	h = (npot ? image->h : round_to_pot(image->h));
+	color = (alpha ? PNG_COLOR_TYPE_GRAY_ALPHA : PNG_COLOR_TYPE_GRAY);
+	png_set_IHDR(pngs, pngi, w, h, 8, color, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+
 	png_init_io(pngs, out);
-	rows = (png_byte **)malloc(image->h*sizeof(png_byte *));
+	png_write_info(pngs, pngi);
+	row = (png_byte *)malloc(w*(1+alpha));
 	if(alpha)
 	{
-		data2 = (png_byte *)alloc_image_data(image->w*2, image->h);
-		if(!data2)
-			return -1;
-		for(i=0; i<image->w*image->h; ++i)
+		for(x=0; x<w; ++x)
 		{
-			data2[i*2] = 255;
-			data2[i*2+1] = 255-image->data[i];
+			row[x*2] = 255;
+			row[x*2+1] = flip_bits;
 		}
-		for(i=0; i<image->h; ++i)
-			rows[i] = (png_byte *)(data2+i*image->w*2);
-		color = PNG_COLOR_TYPE_GRAY_ALPHA;
+		for(y=0; y<image->h; ++y)
+		{
+			for(x=0; x<image->w; ++x)
+				row[x*2+1] = *src++^flip_bits;
+			png_write_row(pngs, row);
+		}
+
+		for(x=0; x<w; ++x)
+			row[x*2+1] = 0;
 	}
 	else
 	{
-		for(i=0; i<image->h; ++i)
-			rows[i] = (png_byte *)(image->data+i*image->w);
-		color = PNG_COLOR_TYPE_GRAY;
+		memset(row+image->w, flip_bits, w-image->w);
+		for(y=0; y<image->h; ++y)
+		{
+			for(x=0; x<image->w; ++x)
+				row[x] = *src++^flip_bits;
+			png_write_row(pngs, row);
+		}
+
+		memset(row, flip_bits, w);
 	}
-	png_set_IHDR(pngs, pngi, image->w, image->h, 8, color, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
-	png_set_rows(pngs, pngi, rows);
-	png_write_png(pngs, pngi, PNG_TRANSFORM_IDENTITY, NULL);
+
+	for(; y<h; ++y)
+		png_write_row(pngs, row);
+
+	png_write_end(pngs, pngi);
 	png_destroy_write_struct(&pngs, &pngi);
-	free(rows);
-	if(alpha)
-		free(data2);
+	free(row);
 
 	if(verbose)
-		printf("Saved %dx%d PNG image to %s\n", image->w, image->h, fn);
+		printf("Saved %dx%d PNG image to %s\n", w, h, fn);
 
 	fclose(out);