X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=ttf2png.c;h=e890e33643084f7784c8d23e280555c425e8fec4;hb=2bd053c9c2207a7c0afa2defee10568fde2e7c50;hp=ebc0ccce76f43fee0e93b3c43d756bc129a900bc;hpb=9d1111afe554231e89dcaa574234ecd1813526a4;p=ttf2png.git

diff --git a/ttf2png.c b/ttf2png.c
index ebc0ccc..e890e33 100644
--- a/ttf2png.c
+++ b/ttf2png.c
@@ -28,18 +28,18 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 typedef struct sImage
 {
 	unsigned w, h;
-	char     *data;
+	unsigned char *data;
 } Image;
 
 typedef struct sGlyph
 {
 	unsigned index;
 	unsigned code;
-	Image    image;
+	Image image;
 	unsigned x, y;
-	int      offset_x;
-	int      offset_y;
-	int      advance;
+	int offset_x;
+	int offset_y;
+	int advance;
 } Glyph;
 
 typedef struct sKerning
@@ -52,20 +52,37 @@ typedef struct sKerning
 typedef struct sFont
 {
 	unsigned size;
-	int      ascent;
-	int      descent;
+	int ascent;
+	int descent;
 	unsigned n_glyphs;
-	Glyph    *glyphs;
+	Glyph *glyphs;
 	unsigned n_kerning;
-	Kerning  *kerning;
-	Image    image;
+	Kerning *kerning;
+	Image image;
 } Font;
 
+typedef struct sRange
+{
+	unsigned first;
+	unsigned last;
+} Range;
+
+typedef int 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 **);
+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 usage();
-void init_font(Font *, FT_Face, unsigned, unsigned, int);
-void render_grid(Font *, unsigned, unsigned, unsigned, int);
-void render_packed(Font *);
+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 copy_bitmap(const FT_Bitmap *, Image *);
+int render_grid(Font *, unsigned, unsigned, unsigned, bool, bool);
+int render_packed(Font *, unsigned, unsigned, bool);
 int save_defs(const char *, const Font *);
 int save_png(const char *, const Image *, char);
 
@@ -74,23 +91,26 @@ char verbose = 0;
 int main(int argc, char **argv)
 {
 	char *fn;
-	int  begin = 0;
-	int  end = 255;
-	int  size = 10;
-	int  cpl = 0;
-	int  cellw = 0;
-	int  cellh = 0;
-	char autohinter = 0;
-	char seq = 0;
-	char alpha = 0;
-	char invert = 0;
-	char pack = 0;
+	Range *ranges = NULL;
+	unsigned n_ranges = 0;
+	unsigned size = 10;
+	unsigned cpl = 0;
+	unsigned cellw = 0;
+	unsigned cellh = 0;
+	bool autohinter = 0;
+	bool seq = 0;
+	bool alpha = 0;
+	bool invert = 0;
+	bool pack = 0;
+	unsigned margin = 0;
+	unsigned padding = 1;
+	bool npot = 0;
 
 	FT_Library freetype;
-	FT_Face    face;
+	FT_Face face;
 
-	int  err;
-	int  i;
+	int err;
+	int i;
 
 	char *out_fn = "font.png";
 	char *def_fn = NULL;
@@ -103,63 +123,22 @@ int main(int argc, char **argv)
 		return 1;
 	}
 
-	while((i = getopt(argc, argv, "r:s:l:c:o:atvh?ed:pi")) != -1)
+	while((i = getopt(argc, argv, "r:s:l:c:o:atvh?ed:pim:n:f")) != -1)
 	{
-		char *ptr;
-		int  temp;
 		switch(i)
 		{
 		case 'r':
-			if(!strcmp(optarg, "all"))
-			{
-				begin = 0;
-				end = 0x110000;
-			}
-			else
-			{
-				if(!isdigit(optarg[0]))
-					temp = -1;
-				else
-				{
-					temp = strtol(optarg, &ptr, 0);
-					if(ptr[0]!=',' || !isdigit(ptr[1]))
-						temp = -1;
-				}
-				if(temp<0)
-				{
-					printf("Not a valid range: %s\n", optarg);
-					exit(1);
-				}
-				else
-				{
-					begin = temp;
-					end = strtol(ptr+1, NULL, 0);
-				}
-			}
+			ranges = (Range *)realloc(ranges, (++n_ranges)*sizeof(Range));
+			convert_code_point_range('r', &ranges[n_ranges-1]);
 			break;
 		case 's':
-			size = strtol(optarg, NULL, 0);
+			size = convert_numeric_option('s', 1);
 			break;
 		case 'l':
-			cpl = strtol(optarg, NULL, 0);
+			cpl = convert_numeric_option('l', 1);
 			break;
 		case 'c':
-			if(!strcmp(optarg, "auto"))
-			{
-				cellw = 0;
-				cellh = 0;
-			}
-			else if(!strcmp(optarg, "autorect"))
-			{
-				cellw = 0;
-				cellh = 1;
-			}
-			else
-			{
-				cellw = strtol(optarg, &ptr, 0);
-				if(ptr[0]=='x' && isdigit(ptr[1]))
-					cellh = strtol(ptr+1, NULL, 0);
-			}
+			convert_size('c', &cellw, &cellh);
 			break;
 		case 'o':
 			out_fn = optarg;
@@ -189,6 +168,15 @@ int main(int argc, char **argv)
 		case 'i':
 			invert = 1;
 			break;
+		case 'm':
+			margin = convert_numeric_option('m', 0);
+			break;
+		case 'n':
+			padding = convert_numeric_option('n', 0);
+			break;
+		case 'f':
+			npot = 1;
+			break;
 		}
 	}
 	if(!strcmp(out_fn, "-"))
@@ -232,25 +220,52 @@ int main(int argc, char **argv)
 		return 1;
 	}
 
+	if(!n_ranges)
+	{
+		ranges = malloc(sizeof(Range));
+		ranges[0].first = 0;
+		ranges[0].last = 255;
+		n_ranges = 1;
+	}
+	else
+		sort_and_compact_ranges(ranges, &n_ranges);
+
 	font.size = size;
-	init_font(&font, face, begin, end, autohinter);
+	err = init_font(&font, face, ranges, n_ranges, autohinter);
+	if(err)
+		return 1;
+
+	if(!font.n_glyphs)
+	{
+		fprintf(stderr, "No glyphs found in the requested range\n");
+		return 1;
+	}
+
 	if(pack)
-		render_packed(&font);
+		err = render_packed(&font, margin, padding, npot);
 	else
-		render_grid(&font, cellw, cellh, cpl, seq);
+		err = render_grid(&font, cellw, cellh, cpl, seq, npot);
+	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];
 	}
-	save_png(out_fn, &font.image, alpha);
+	err = save_png(out_fn, &font.image, alpha);
+	if(err)
+		return 1;
+
 	if(def_fn)
 		save_defs(def_fn, &font);
 
 	for(i=0; (unsigned)i<font.n_glyphs; ++i)
 		free(font.glyphs[i].image.data);
 	free(font.glyphs);
+	free(font.kerning);
 	free(font.image.data);
+	free(ranges);
 
 	FT_Done_Face(face);
 	FT_Done_FreeType(freetype);
@@ -258,119 +273,253 @@ int main(int argc, char **argv)
 	return 0;
 }
 
-unsigned round_to_pot(unsigned n)
+void usage(void)
 {
-	n -= 1;
-	n |= n>>1;
-	n |= n>>2;
-	n |= n>>4;
-	n |= n>>8;
-	n |= n>>16;
-
-	return n+1;
-}
-
-void usage()
-{
-	printf("ttf2png - True Type Font to PNG converter\n"
-		"Copyright (c) 2004-2008  Mikko Rasa, Mikkosoft Productions\n"
+	printf("ttf2png 1.1 - True Type Font to PNG converter\n"
+		"Copyright (c) 2004-2018  Mikko Rasa, Mikkosoft Productions\n"
 		"Distributed under the GNU General Public License\n\n");
 
 	printf("Usage: ttf2png [options] <TTF file>\n\n");
 
 	printf("Accepted options (default values in [brackets])\n"
-		"  -r  Range of characters to convert [0,255]\n"
+		"  -r  Range of code points to convert [0,255]\n"
 		"  -s  Font size to use, in pixels [10]\n"
-		"  -l  Number of characters to put in one line [auto]\n"
-		"  -c  Character cell size, in pixels [auto]\n"
+		"  -l  Number of glyphs to put in one line [auto]\n"
+		"  -c  Glyph cell size, in pixels (grid mode only) [auto]\n"
 		"  -o  Output file name (or - for stdout) [font.png]\n");
 	printf("  -a  Force autohinter\n"
 		"  -t  Render glyphs to alpha channel\n"
 		"  -i  Invert colors of the glyphs\n"
 		"  -v  Increase the level of verbosity\n"
-		"  -e  Use cells in sequence, without gaps\n"
+		"  -e  Use cells in sequence, without gaps (grid mode only)\n"
 		"  -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"
 		"  -d  File name for writing glyph definitions\n"
 		"  -h  Print this message\n");
 }
 
-void init_font(Font *font, FT_Face face, unsigned first, unsigned last, int autohinter)
+int convert_numeric_option(char opt, int min_value)
 {
-	unsigned i, j;
-	unsigned size = 0;
+	int value;
+	char *ptr;
 
-	font->ascent = (face->size->metrics.ascender+63)>>6;
-	font->descent = (face->size->metrics.descender+63)>>6;
+	value = strtol(optarg, &ptr, 0);
+	if(value<min_value || *ptr)
+	{
+		printf("Invalid option argument in -%c %s\n", opt, optarg);
+		exit(1);
+	}
 
-	if(verbose>=1)
+	return value;
+}
+
+void convert_code_point_range(char opt, Range *range)
+{
+	int value;
+	char *ptr;
+
+	if(!strcmp(optarg, "all"))
 	{
-		printf("Ascent:    %d\n", font->ascent);
-		printf("Descent:   %d\n", font->descent);
+		range->first = 0;
+		range->last = 0x10FFFF;
+		return;
 	}
 
-	font->n_glyphs = 0;
-	font->glyphs = NULL;
-	for(i=first; i<=last; ++i)
+	value = str_to_code_point(optarg, &ptr);
+	if(value>0 && *ptr==',')
 	{
-		unsigned  n;
-		FT_Bitmap *bmp = &face->glyph->bitmap;
-		int       x, y;
-		int       flags = 0;
-		Glyph     *glyph;
+		range->first = value;
+		value = str_to_code_point(ptr+1, &ptr);
+		if(value>0 && !*ptr)
+		{
+			range->last = value;
+			return;
+		}
+	}
 
-		n = FT_Get_Char_Index(face, i);
-		if(!n)
-			continue;
+	printf("Invalid option argument in -%c %s\n", opt, optarg);
+	exit(1);
+}
 
-		if(autohinter)
-			flags |= FT_LOAD_FORCE_AUTOHINT;
-		FT_Load_Glyph(face, n, flags);
-		FT_Render_Glyph(face->glyph, FT_RENDER_MODE_NORMAL);
+unsigned str_to_code_point(const char *nptr, char **endptr)
+{
+	if(nptr[0]=='U' && nptr[1]=='+')
+		return strtoul(nptr+2, endptr, 16);
+	else if(nptr[0]&0x80)
+	{
+		unsigned bytes;
+		unsigned code;
+		unsigned i;
 
-		if(verbose>=2)
-			printf("  Char %u: glyph %u, size %dx%d\n", i, n, bmp->width, bmp->rows);
+		if(endptr)
+			*endptr = (char *)nptr;
+
+		for(bytes=1; (bytes<4 && (nptr[0]&(0x80>>bytes))); ++bytes)
+			if((nptr[bytes]&0xC0)!=0x80)
+				return 0;
+		if(bytes<2)
+			return 0;
+
+		code = nptr[0]&(0x3F>>bytes);
+		for(i=1; i<bytes; ++i)
+			code = (code<<6)|(nptr[i]&0x3F);
+
+		if(endptr)
+			*endptr = (char *)nptr+bytes;
+
+		return code;
+	}
+	else if(isdigit(nptr[0]))
+		return strtoul(nptr, endptr, 0);
+	else
+	{
+		if(endptr)
+			*endptr = (char *)nptr+1;
+		return *nptr;
+	}
+}
 
-		if(bmp->pixel_mode!=FT_PIXEL_MODE_GRAY)
+void convert_size(char opt, unsigned *width, unsigned *height)
+{
+	int value;
+	char *ptr;
+
+	if(!strcmp(optarg, "auto"))
+	{
+		*width = 0;
+		*height = 0;
+		return;
+	}
+	else if(!strcmp(optarg, "autorect"))
+	{
+		*width = 0;
+		*height = 1;
+		return;
+	}
+
+	value = strtol(optarg, &ptr, 0);
+	if(value>0)
+	{
+		*width = value;
+		if(*ptr=='x')
 		{
-			fprintf(stderr, "Warning: Glyph %u skipped, not grayscale\n", n);
-			continue;
+			value = strtol(ptr+1, &ptr, 0);
+			if(value>0 && !*ptr)
+			{
+				*height = value;
+				return;
+			}
 		}
-
-		if(font->n_glyphs>=size)
+		else if(!*ptr)
 		{
-			size += 16;
-			font->glyphs = (Glyph *)realloc(font->glyphs, size*sizeof(Glyph));
+			*height = *width;
+			return;
 		}
+	}
 
-		glyph = &font->glyphs[font->n_glyphs++];
-		glyph->index = n;
-		glyph->code = i;
-		glyph->image.w = bmp->width;
-		glyph->image.h = bmp->rows;
-		glyph->image.data = (char *)malloc(bmp->width*bmp->rows);
-		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;
+	printf("Invalid option argument in -%c %s\n", opt, optarg);
+	exit(1);
+}
 
-		/* 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(bmp->pitch<0)
+void sort_and_compact_ranges(Range *ranges, unsigned *n_ranges)
+{
+	unsigned i, j;
+
+	if(!*n_ranges)
+		return;
+
+	qsort(ranges, *n_ranges, sizeof(Range), &range_cmp);
+	for(i=0, j=1; j<*n_ranges; ++j)
+	{
+		if(ranges[i].last+1>=ranges[j].first)
 		{
-			for(y=0; y<bmp->rows; ++y) for(x=0; x<bmp->width; ++x)
-				glyph->image.data[x+(glyph->image.h-1-y)*glyph->image.w] = bmp->buffer[x-y*bmp->pitch];
+			if(ranges[j].last>ranges[i].last)
+				ranges[i].last = ranges[j].last;
 		}
 		else
 		{
-			for(y=0; y<bmp->rows; ++y) for(x=0; x<bmp->width; ++x)
-				glyph->image.data[x+y*glyph->image.w] = bmp->buffer[x+y*bmp->pitch];
+			++i;
+			if(i!=j)
+				ranges[i] = ranges[j];
+		}
+	}
+
+	*n_ranges = i+1;
+}
+
+int range_cmp(const void *p1, const void *p2)
+{
+	const Range *r1 = (const Range *)p1;
+	const Range *r2 = (const Range *)p2;
+	if(r1->first!=r2->first)
+		return (r1->first<r2->first ? -1 : 1);
+	else if(r1->last!=r2->last)
+		return (r1->last<r2->last ? -1 : 1);
+	else
+		return 0;
+}
+
+unsigned round_to_pot(unsigned n)
+{
+	n -= 1;
+	n |= n>>1;
+	n |= n>>2;
+	n |= n>>4;
+	n |= n>>8;
+	n |= n>>16;
+
+	return n+1;
+}
+
+void *alloc_image_data(size_t a, size_t b)
+{
+	void *ptr;
+
+	/* Carry out the multiplication manually so we can check for overflow. */
+	while(b>1)
+	{
+		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;
 	}
+	ptr = malloc(a);
+	if(!ptr)
+		fprintf(stderr, "Cannot allocate %lu kbytes of memory for image\n", (unsigned long)(a/1024*b));
+	return ptr;
+}
+
+int init_font(Font *font, FT_Face face, const Range *ranges, unsigned n_ranges, bool autohinter)
+{
+	unsigned i, j;
+	unsigned size = 0;
+
+	font->ascent = (face->size->metrics.ascender+63)/64;
+	font->descent = (face->size->metrics.descender-63)/64;
+
+	if(verbose>=1)
+	{
+		printf("Ascent:    %d\n", font->ascent);
+		printf("Descent:   %d\n", font->descent);
+	}
+
+	font->n_glyphs = 0;
+	font->glyphs = NULL;
+	for(i=0; i<n_ranges; ++i)
+		if(init_glyphs(font, face, &ranges[i], autohinter))
+			return -1;
 
 	if(verbose>=1)
 		printf("Loaded %u glyphs\n", font->n_glyphs);
 
-	size = 0;
 	font->n_kerning = 0;
 	font->kerning = NULL;
 	for(i=0; i<font->n_glyphs; ++i) for(j=0; j<font->n_glyphs; ++j)
@@ -394,18 +543,138 @@ void init_font(Font *font, FT_Face face, unsigned first, unsigned last, int auto
 				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->distance = (kerning.x+32)/64;
 			}
 		}
 
 	if(verbose>=1)
 		printf("Loaded %d kerning pairs\n", font->n_kerning);
+
+	return 0;
+}
+
+int init_glyphs(Font *font, FT_Face face, const Range *range, bool autohinter)
+{
+	unsigned i, j;
+	unsigned size = font->n_glyphs;
+
+	for(i=range->first; i<=range->last; ++i)
+	{
+		unsigned n;
+		FT_Bitmap *bmp = &face->glyph->bitmap;
+		int flags = 0;
+		Glyph *glyph;
+
+		n = FT_Get_Char_Index(face, i);
+		if(!n)
+			continue;
+
+		if(autohinter)
+			flags |= FT_LOAD_FORCE_AUTOHINT;
+		FT_Load_Glyph(face, n, flags);
+		FT_Render_Glyph(face->glyph, FT_RENDER_MODE_NORMAL);
+
+		if(verbose>=2)
+		{
+			printf("  Code point U+%04X", i);
+			if(i>=0x20 && i<0x7F)
+				printf(" (%c)", i);
+			else if(i>=0xA0 && i<=0x10FFFF)
+			{
+				char utf8[5];
+				unsigned bytes;
+
+				for(bytes=2; i>>(1+bytes*5); ++bytes) ;
+				for(j=0; j<bytes; ++j)
+					utf8[j] = 0x80 | ((i>>((bytes-j-1)*6))&0x3F);
+				utf8[0] |= 0xF0<<(4-bytes);
+				utf8[j] = 0;
+
+				printf(" (%s)", utf8);
+			}
+			printf(": glyph %u, size %dx%d\n", n, bmp->width, bmp->rows);
+		}
+
+		if(bmp->pixel_mode!=FT_PIXEL_MODE_GRAY && bmp->pixel_mode!=FT_PIXEL_MODE_MONO)
+		{
+			fprintf(stderr, "Warning: Glyph %u skipped, incompatible pixel mode\n", n);
+			continue;
+		}
+
+		if(font->n_glyphs>=size)
+		{
+			size += 16;
+			font->glyphs = (Glyph *)realloc(font->glyphs, size*sizeof(Glyph));
+		}
+
+		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;
+
+		/* 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;
+	}
+
+	return 0;
 }
 
-void render_grid(Font *font, unsigned cellw, unsigned cellh, unsigned cpl, int seq)
+int copy_bitmap(const FT_Bitmap *bmp, Image *image)
+{
+	unsigned x, y;
+	unsigned char *src;
+	unsigned char *dst;
+
+	image->w = bmp->width;
+	image->h = bmp->rows;
+	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;
+	else
+		src = bmp->buffer;
+	dst = image->data;
+
+	for(y=0; y<bmp->rows; ++y)
+	{
+		if(bmp->pixel_mode==FT_PIXEL_MODE_MONO)
+		{
+			for(x=0; x<bmp->width; ++x)
+				dst[x] = ((src[x/8]&(0x80>>(x%8))) ? 0xFF : 0x00);
+		}
+		else
+		{
+			for(x=0; x<bmp->width; ++x)
+				dst[x] = src[x];
+		}
+
+		src += bmp->pitch;
+		dst += image->w;
+	}
+
+	return 0;
+}
+
+int render_grid(Font *font, unsigned cellw, unsigned cellh, unsigned cpl, bool seq, bool npot)
 {
 	unsigned i;
-	int      top = 0, bot = 0;
+	int top = 0, bot = 0;
 	unsigned first, last;
 	unsigned maxw = 0, maxh = 0;
 
@@ -466,15 +735,24 @@ void render_grid(Font *font, unsigned cellw, unsigned cellh, unsigned cpl, int s
 		first -= first%cpl;
 	last = font->glyphs[font->n_glyphs-1].code;
 
-	font->image.w = round_to_pot(cpl*cellw);
-	font->image.h = round_to_pot((last-first+cpl)/cpl*cellh);
+	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;
+	else
+		font->image.h = (last-first+cpl)/cpl*cellh;
+	if(!npot)
+		font->image.h = round_to_pot(font->image.h);
 
-	font->image.data = (char *)malloc(font->image.w*font->image.h);
+	font->image.data = (unsigned char *)alloc_image_data(font->image.w, font->image.h);
+	if(!font->image.data)
+		return -1;
 	memset(font->image.data, 255, font->image.w*font->image.h);
 
 	for(i=0; i<font->n_glyphs; ++i)
 	{
-		Glyph    *glyph;
+		Glyph *glyph;
 		unsigned ci, cx, cy;
 		unsigned x, y;
 
@@ -502,65 +780,80 @@ void render_grid(Font *font, unsigned cellw, unsigned cellh, unsigned cpl, int s
 			font->image.data[cx+x+(cy+y)*font->image.w] = 255-glyph->image.data[x+y*glyph->image.w];
 		}
 	}
+
+	return 0;
 }
 
-void render_packed(Font *font)
+int render_packed(Font *font, unsigned margin, unsigned padding, bool npot)
 {
 	unsigned i;
-	unsigned area = 0;
-	char     *used_glyphs;
+	size_t area = 0;
+	char *used_glyphs;
 	unsigned *used_pixels;
-	unsigned cx = 0, cy;
+	unsigned cx = margin, cy;
 	unsigned used_h = 0;
 
 	/* Compute the total area occupied by glyphs and padding. */
 	for(i=0; i<font->n_glyphs; ++i)
-		area += (font->glyphs[i].image.w+1)*(font->glyphs[i].image.h+1);
+	{
+		size_t a = area+(font->glyphs[i].image.w+padding)*(font->glyphs[i].image.h+padding);
+		if(a<area)
+		{
+			fprintf(stderr, "Overflow in counting total glyph area\n");
+			return -1;
+		}
+		area = a;
+	}
 
 	/* Find an image size that's no higher than wide, allowing for some
 	imperfections in the packing. */
 	for(font->image.w=1;; font->image.w<<=1)
 	{
-		font->image.h = (area*5/4)/font->image.w;
+		if(font->image.w<=margin*2)
+			continue;
+		font->image.h = (area*5/4)/(font->image.w-margin*2)+margin*2;
 		if(font->image.h<=font->image.w)
 			break;
 	}
-	font->image.h = round_to_pot(font->image.h);
+	if(!npot)
+		font->image.h = round_to_pot(font->image.h);
 
 	/* 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 = (char *)malloc(font->image.w*font->image.h);
+	font->image.data = (unsigned char *)alloc_image_data(font->image.w, font->image.h);
+	if(!font->image.data)
+		return -1;
 	memset(font->image.data, 255, 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);
 	memset(used_glyphs, 0, font->n_glyphs);
 
-	for(cy=0; cy<font->image.h;)
+	for(cy=margin; cy+margin<font->image.h;)
 	{
 		unsigned w;
 		unsigned x, y;
-		Glyph    *glyph = NULL;
+		Glyph *glyph = NULL;
 		unsigned best_score = 0;
 		unsigned target_h = 0;
 
-		/* Find the leftmost free pixel on this row.    Also record the lowest extent of glyphs
-		to the left of the free position. */
-		for(; (cx<font->image.w && used_pixels[cx]>cy); ++cx)
-			if(used_pixels[cx]-cy-1>target_h)
-				target_h = used_pixels[cx]-cy-1;
+		/* Find the leftmost free pixel on this row.  Also record the lowest
+		extent of glyphs to the left of the free position. */
+		for(; (cx+margin<font->image.w && used_pixels[cx]>cy); ++cx)
+			if(used_pixels[cx]-cy-padding>target_h)
+				target_h = used_pixels[cx]-cy-padding;
 
-		if(cx>=font->image.w)
+		if(cx+margin>=font->image.w)
 		{
-			cx = 0;
+			cx = margin;
 			++cy;
 			continue;
 		}
 
 		/* Count the free pixel at this position. */
-		for(w=0; (cx+w<font->image.w && used_pixels[cx+w]<=cy); ++w) ;
+		for(w=0; (cx+w+margin<font->image.w && used_pixels[cx+w]<=cy); ++w) ;
 
 		/* Find a suitable glyph to put here. */
 		for(i=0; i<font->n_glyphs; ++i)
@@ -575,7 +868,7 @@ void render_packed(Font *font)
 				/* Prefer glyphs that would reach exactly as low as the ones left
 				of here.  This aims to create a straight edge at the bottom for
 				lining up further glyphs. */
-				score = g->image.h+1;
+				score = g->image.h+padding;
 				if(g->image.h==target_h)
 					score *= g->image.w;
 				else
@@ -605,26 +898,33 @@ void render_packed(Font *font)
 				continue;
 			font->image.data[cx+x+(cy+y)*font->image.w] = 255-glyph->image.data[x+y*glyph->image.w];
 		}
-		for(x=0; x<glyph->image.w+2; ++x)
+		for(x=0; x<glyph->image.w+2*padding; ++x)
 		{
-			if(cx+x<1 || cx+x>font->image.w)
+			if(cx+x<padding || cx+x>=font->image.w+padding)
 				continue;
-			if(used_pixels[cx+x-1]<cy+glyph->image.h+1)
-				used_pixels[cx+x-1] = cy+glyph->image.h+1;
+			if(used_pixels[cx+x-padding]<cy+glyph->image.h+padding)
+				used_pixels[cx+x-padding] = cy+glyph->image.h+padding;
 		}
 
-		if(cy+glyph->image.h>used_h)
-			used_h = cy+glyph->image.h;
+		if(cy+glyph->image.h+margin>used_h)
+			used_h = cy+glyph->image.h+margin;
 	}
 
 	/* Trim the image to the actually used size, in case the original estimate
 	was too pessimistic. */
-	font->image.h = round_to_pot(used_h);
+	font->image.h = used_h;
+	if(!npot)
+		font->image.h = round_to_pot(font->image.h);
+
+	free(used_glyphs);
+	free(used_pixels);
+
+	return 0;
 }
 
 int save_defs(const char *fn, const Font *font)
 {
-	FILE     *out;
+	FILE *out;
 	unsigned i;
 
 	out = fopen(fn, "w");
@@ -659,13 +959,13 @@ int save_defs(const char *fn, const Font *font)
 
 int save_png(const char *fn, const Image *image, char alpha)
 {
-	FILE       *out;
+	FILE *out;
 	png_struct *pngs;
-	png_info   *pngi;
-	png_byte   **rows;
-	unsigned   i;
-	png_byte   *data2;
-	int        color;
+	png_info *pngi;
+	png_byte **rows;
+	unsigned i;
+	png_byte *data2 = 0;
+	int color;
 
 	if(!strcmp(fn, "-"))
 		out = stdout;
@@ -697,7 +997,9 @@ int save_png(const char *fn, const Image *image, char alpha)
 	rows = (png_byte **)malloc(image->h*sizeof(png_byte *));
 	if(alpha)
 	{
-		data2 = (png_byte *)malloc(image->w*image->h*2);
+		data2 = (png_byte *)alloc_image_data(image->w*2, image->h);
+		if(!data2)
+			return -1;
 		for(i=0; i<image->w*image->h; ++i)
 		{
 			data2[i*2] = 255;