X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=ttf2png.c;h=6543a8d8a009b2de12f898c6effcb964707012b1;hb=050869535277b43b09f1d306605bb3a70f4ad6c5;hp=d7079d53794f5e7091ff029e4949744a9d92df1d;hpb=95a574b6cbf90e1ceee50a71643fc1bec43f554a;p=ttf2png.git

diff --git a/ttf2png.c b/ttf2png.c
index d7079d5..6543a8d 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-2018 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
@@ -28,7 +28,7 @@ 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
@@ -78,13 +78,16 @@ 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_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 +108,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 +128,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 +179,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 +224,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 +249,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 +260,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;
 
@@ -265,6 +278,7 @@ int main(int argc, char **argv)
 	free(font.glyphs);
 	free(font.kerning);
 	free(font.image.data);
+	free(ranges);
 
 	FT_Done_Face(face);
 	FT_Done_FreeType(freetype);
@@ -294,7 +308,8 @@ 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"
+		"  -f  Create a distance field texture\n"
 		"  -d  File name for writing glyph definitions\n"
 		"  -h  Print this message\n");
 }
@@ -496,13 +511,14 @@ void *alloc_image_data(size_t a, size_t b)
 	return ptr;
 }
 
-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)
 	{
@@ -513,7 +529,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)
@@ -542,7 +558,7 @@ 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->distance = (kerning.x/scale+32)/64;
 			}
 		}
 
@@ -552,10 +568,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)
 	{
@@ -571,7 +588,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)
 		{
@@ -591,7 +608,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)
@@ -609,15 +626,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;
@@ -627,7 +653,7 @@ int copy_bitmap(const FT_Bitmap *bmp, Image *image)
 {
 	unsigned x, y;
 	unsigned char *src;
-	char *dst;
+	unsigned char *dst;
 
 	image->w = bmp->width;
 	image->h = bmp->rows;
@@ -637,7 +663,7 @@ int copy_bitmap(const FT_Bitmap *bmp, Image *image)
 		return 0;
 	}
 
-	image->data = (char *)malloc(image->w*image->h);
+	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);
@@ -670,7 +696,95 @@ 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(!bmp->width || !bmp->rows)
+	{
+		image->w = 0;
+		image->h = 0;
+		image->data = NULL;
+		return 0;
+	}
+
+	if(copy_bitmap(bmp, &base_image))
+		return -1;
+
+	image->w = (base_image.w-1)/scale+2*margin+1;
+	image->h = (base_image.h-1)/scale+2*margin+1;
+	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);
+		free(base_image.data);
+		return -1;
+	}
+
+	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;
@@ -735,19 +849,15 @@ int render_grid(Font *font, unsigned cellw, unsigned cellh, unsigned cpl, bool s
 	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;
 	else
 		font->image.h = (last-first+cpl)/cpl*cellh;
-	if(!npot)
-		font->image.h = round_to_pot(font->image.h);
 
-	font->image.data = (char *)alloc_image_data(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);
+	memset(font->image.data, 0, font->image.w*font->image.h);
 
 	for(i=0; i<font->n_glyphs; ++i)
 	{
@@ -776,14 +886,14 @@ 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;
@@ -804,27 +914,27 @@ 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 = (char *)alloc_image_data(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);
+	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);
@@ -895,7 +1005,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)
 		{
@@ -912,8 +1022,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);
@@ -956,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;
@@ -992,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);