/*
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
typedef struct sImage
{
unsigned w, h;
- char *data;
+ unsigned char *data;
+ unsigned border;
} Image;
typedef struct sGlyph
typedef struct sKerning
{
- unsigned left_code;
- unsigned right_code;
+ Glyph *left_glyph;
+ Glyph *right_glyph;
int distance;
} Kerning;
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;
unsigned margin = 0;
unsigned padding = 1;
bool npot = 0;
+ unsigned distfield = 0;
+ unsigned border = 0;
FT_Library freetype;
FT_Face face;
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)
{
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, "-"))
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)
{
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;
}
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;
free(font.glyphs);
free(font.kerning);
free(font.image.data);
+ free(ranges);
FT_Done_Face(face);
FT_Done_FreeType(freetype);
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");
" -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");
}
}
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;
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);
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)
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;
+ }
+
+ image->data = malloc(s);
+ if(!image->data)
+ {
+ 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;
+
+ 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)>>6;
- font->descent = (face->size->metrics.descender+63)>>6;
+ font->ascent = (face->size->metrics.ascender/scale+63)/64;
+ font->descent = (face->size->metrics.descender/scale-63)/64;
if(verbose>=1)
{
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)
}
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;
}
}
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)
{
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)
{
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)
+ if(bmp->pixel_mode!=FT_PIXEL_MODE_GRAY && bmp->pixel_mode!=FT_PIXEL_MODE_MONO)
{
- fprintf(stderr, "Warning: Glyph %u skipped, not grayscale\n", n);
+ fprintf(stderr, "Warning: Glyph %u skipped, incompatible pixel mode\n", n);
continue;
}
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;
{
unsigned x, y;
unsigned char *src;
- char *dst;
+ 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 = (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;
for(y=0; y<bmp->rows; ++y)
{
- for(x=0; x<bmp->width; ++x)
- dst[x] = src[x];
+ 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 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. */
}
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 = (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)
{
{
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;
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);
- 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;)
{
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)
{
/* 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);
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);
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;
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)
+ {
+ row[x*2] = 255;
+ row[x*2+1] = flip_bits;
+ }
+ for(y=0; y<image->h; ++y)
{
- data2[i*2] = 255;
- data2[i*2+1] = 255-image->data[i];
+ for(x=0; x<image->w; ++x)
+ row[x*2+1] = *src++^flip_bits;
+ png_write_row(pngs, row);
}
- for(i=0; i<image->h; ++i)
- rows[i] = (png_byte *)(data2+i*image->w*2);
- color = PNG_COLOR_TYPE_GRAY_ALPHA;
+
+ 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);
projects / ttf2png.git / blobdiff