rgraves
/
freetype2
forked from minhngoc25a/freetype2
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Indentation change

This commit is contained in:
Kushal K S V S 2017-06-29 02:46:31 +05:30
parent d73dc59e0f
commit 68f7652dbb
4 changed files with 374 additions and 361 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

302
tests/make_png/bitmap.c
View File

@ -2,223 +2,225 @@
HASH_128 * Generate_Hash_x64_128(FT_Bitmap * bitmap, HASH_128 * murmur)
{
int seed = 99; // Dont change
int seed = 99; // Dont change
MurmurHash3_x64_128(bitmap->buffer, (bitmap->pitch * bitmap->rows), seed, murmur->hash);
MurmurHash3_x64_128(bitmap->buffer, (bitmap->pitch * bitmap->rows), seed, murmur->hash);
return murmur;
return murmur;
}
HASH_128 * Generate_Hash_x86_128(FT_Bitmap * bitmap, HASH_128 * murmur)
{
int seed = 99; // Dont change
int seed = 99; // Dont change
MurmurHash3_x86_128(bitmap->buffer, (bitmap->pitch * bitmap->rows), seed, murmur->hash);
MurmurHash3_x86_128(bitmap->buffer, (bitmap->pitch * bitmap->rows), seed, murmur->hash);
return murmur;
return murmur;
}
HASH_32 * Generate_Hash_x86_32(FT_Bitmap * bitmap, HASH_32 * murmur)
{
int seed = 99; // Dont change
int seed = 99; // Dont change
MurmurHash3_x86_32(bitmap->buffer, (bitmap->pitch * bitmap->rows), seed, murmur->hash);
MurmurHash3_x86_32(bitmap->buffer, (bitmap->pitch * bitmap->rows), seed, murmur->hash);
return murmur;
return murmur;
}
PIXEL * Pixel_At (IMAGE * bitmap, int x, int y)
{
return bitmap->pixels + bitmap->width * y + x;
return bitmap->pixels + bitmap->width * y + x;
}
int Generate_PNG (IMAGE *bitmap, const char *path,int render_mode)
{
FILE * fp;
png_structp png_ptr = NULL;
png_infop info_ptr = NULL;
size_t x, y;
png_byte ** row_pointers = NULL;
FILE * fp;
png_structp png_ptr = NULL;
png_infop info_ptr = NULL;
int status = -1;
size_t x, y;
png_byte ** row_pointers = NULL;
int pixel_size = 4;
int depth = 8;
fp = fopen (path, "wb");
if (! fp) {
goto fopen_failed;
}
int status = -1;
png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (png_ptr == NULL) {
goto png_create_write_struct_failed;
}
info_ptr = png_create_info_struct (png_ptr);
if (info_ptr == NULL) {
goto png_create_info_struct_failed;
}
int pixel_size = 4;
int depth = 8;
fp = fopen (path, "wb");
if (! fp) {
goto fopen_failed;
}
if (setjmp (png_jmpbuf (png_ptr))) {
goto png_failure;
}
png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (png_ptr == NULL) {
goto png_create_write_struct_failed;
}
info_ptr = png_create_info_struct (png_ptr);
if (info_ptr == NULL) {
goto png_create_info_struct_failed;
}
png_set_IHDR (png_ptr,
info_ptr,
bitmap->width,
bitmap->height,
depth,
PNG_COLOR_TYPE_RGBA,
PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT,
PNG_FILTER_TYPE_DEFAULT);
if (setjmp (png_jmpbuf (png_ptr))) {
goto png_failure;
}
row_pointers = png_malloc (png_ptr, bitmap->height * sizeof (png_byte *));
png_set_IHDR (png_ptr,
info_ptr,
bitmap->width,
bitmap->height,
depth,
PNG_COLOR_TYPE_RGBA,
PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT,
PNG_FILTER_TYPE_DEFAULT);
for (y = 0; y < bitmap->height; y++) {
row_pointers = png_malloc (png_ptr, bitmap->height * sizeof (png_byte *));
png_byte *row = png_malloc (png_ptr, sizeof (uint8_t) * bitmap->width * pixel_size);
row_pointers[y] = row;
for (y = 0; y < bitmap->height; y++) {
for (x = 0; x < bitmap->width; x++) {
png_byte *row = png_malloc (png_ptr, sizeof (uint8_t) * bitmap->width * pixel_size);
row_pointers[y] = row;
PIXEL * pixel = Pixel_At (bitmap, x, y);
for (x = 0; x < bitmap->width; x++) {
if (render_mode == 3 || render_mode == 5)
{
*row++ = pixel->blue;
*row++ = pixel->green;
*row++ = pixel->red;
*row++ = pixel->alpha;
continue;
}
*row++ = pixel->red;
*row++ = pixel->green;
*row++ = pixel->blue;
*row++ = pixel->alpha;
PIXEL * pixel = Pixel_At (bitmap, x, y);
if (render_mode == 3 || render_mode == 5)
{
*row++ = pixel->blue;
*row++ = pixel->green;
*row++ = pixel->red;
*row++ = pixel->alpha;
continue;
}
}
png_init_io (png_ptr, fp);
png_set_rows (png_ptr, info_ptr, row_pointers);
png_write_png (png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
status = 0;
for (y = 0; y < bitmap->height; y++) {
png_free (png_ptr, row_pointers[y]);
*row++ = pixel->red;
*row++ = pixel->green;
*row++ = pixel->blue;
*row++ = pixel->alpha;
}
png_free (png_ptr, row_pointers);
png_failure:
png_create_info_struct_failed:
png_destroy_write_struct (&png_ptr, &info_ptr);
png_create_write_struct_failed:
fclose (fp);
fopen_failed:
return status;
}
png_init_io (png_ptr, fp);
png_set_rows (png_ptr, info_ptr, row_pointers);
png_write_png (png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
status = 0;
for (y = 0; y < bitmap->height; y++) {
png_free (png_ptr, row_pointers[y]);
}
png_free (png_ptr, row_pointers);
png_failure:
png_create_info_struct_failed:
png_destroy_write_struct (&png_ptr, &info_ptr);
png_create_write_struct_failed:
fclose (fp);
fopen_failed:
return status;
}
void Make_PNG(FT_Bitmap* bitmap,char* name,int i,int render_mode){
IMAGE fruit;
int x;
int y;
IMAGE fruit;
int x;
int y;
unsigned char value;
int p;
unsigned char value;
int p;
switch(render_mode){
switch(render_mode){
case 0 :
case 1 : fruit.width = bitmap->width; // MONO and GRAY
fruit.height = bitmap->rows;
case 0 :
case 1 : fruit.width = bitmap->width; // MONO and GRAY
fruit.height = bitmap->rows;
fruit.pixels = calloc (fruit.width * fruit.height, sizeof (PIXEL));
fruit.pixels = calloc (fruit.width * fruit.height, sizeof (PIXEL));
for (y = 0; y < fruit.height; y++) {
for (x = 0; x < fruit.width; x++) {
for (y = 0; y < fruit.height; y++) {
for (x = 0; x < fruit.width; x++) {
PIXEL * pixel = Pixel_At (& fruit, x, y);
p = (y * bitmap->pitch ) + x;
PIXEL * pixel = Pixel_At (& fruit, x, y);
p = (y * bitmap->pitch ) + x;
value = bitmap->buffer[p];
value = bitmap->buffer[p];
pixel->red = 255- value;
pixel->green = 255- value;
pixel->blue = 255- value;
pixel->alpha = 255;
}
}
break;
pixel->red = 255- value;
pixel->green = 255- value;
pixel->blue = 255- value;
pixel->alpha = 255;
}
}
break;
case 2 :
case 3 : fruit.width = bitmap->width / 3; // LCD
fruit.height = bitmap->rows;
case 2 :
case 3 : fruit.width = bitmap->width / 3; // LCD
fruit.height = bitmap->rows;
fruit.pixels = calloc (fruit.width * fruit.height, sizeof (PIXEL));
fruit.pixels = calloc (fruit.width * fruit.height, sizeof (PIXEL));
for (y = 0; y < fruit.height; y++) {
for (x = 0; x < fruit.width; x++) {
for (y = 0; y < fruit.height; y++) {
for (x = 0; x < fruit.width; x++) {
PIXEL * pixel = Pixel_At (& fruit, x, y);
p = (y * bitmap->pitch ) + (x)*3;
PIXEL * pixel = Pixel_At (& fruit, x, y);
p = (y * bitmap->pitch ) + (x)*3;
value = bitmap->buffer[p];
pixel->red = 255- value;
p++;
value = bitmap->buffer[p];
pixel->red = 255- value;
p++;
value = bitmap->buffer[p];
pixel->green = 255- value;
p++;
value = bitmap->buffer[p];
pixel->green = 255- value;
p++;
value = bitmap->buffer[p];
pixel->blue = 255- value;
value = bitmap->buffer[p];
pixel->blue = 255- value;
pixel->alpha = 255;
}
}
break;
pixel->alpha = 255;
}
}
break;
case 4 :
case 5 : fruit.width = bitmap->width; // LCD_V
fruit.height = bitmap->rows / 3;
case 4 :
case 5 : fruit.width = bitmap->width; // LCD_V
fruit.height = bitmap->rows / 3;
fruit.pixels = calloc (fruit.width * fruit.height, sizeof (PIXEL));
fruit.pixels = calloc (fruit.width * fruit.height, sizeof (PIXEL));
for (y = 0; y < fruit.height; y++) {
for (x = 0; x < fruit.width; x++) {
for (y = 0; y < fruit.height; y++) {
for (x = 0; x < fruit.width; x++) {
PIXEL * pixel = Pixel_At (& fruit, x, y);
p = ((y*3) * bitmap->pitch ) + x;
PIXEL * pixel = Pixel_At (& fruit, x, y);
p = ((y*3) * bitmap->pitch ) + x;
value = bitmap->buffer[p];
pixel->red = 255- value;
p += bitmap->pitch;
value = bitmap->buffer[p];
pixel->red = 255- value;
p += bitmap->pitch;
value = bitmap->buffer[p];
pixel->green = 255- value;
p += bitmap->pitch;
value = bitmap->buffer[p];
pixel->green = 255- value;
p += bitmap->pitch;
value = bitmap->buffer[p];
pixel->blue = 255- value;
value = bitmap->buffer[p];
pixel->blue = 255- value;
pixel->alpha = 255;
}
}
break;
pixel->alpha = 255;
}
}
break;
default : fruit.width = bitmap->width;
fruit.height = bitmap->rows;
break;
}
default : fruit.width = bitmap->width;
fruit.height = bitmap->rows;
break;
}
char * file_name = ( char * )calloc(150,sizeof(char));
char * file_name = ( char * )calloc(150,sizeof(char));
sprintf(file_name, "%s_%d",name,i);
sprintf(file_name, "%s_%d",name,i);
Generate_PNG (& fruit, file_name,render_mode);
Generate_PNG (& fruit, file_name,render_mode);
free (fruit.pixels);
free (fruit.pixels);
}

33
tests/make_png/bitmap.h
View File

@ -21,33 +21,33 @@
#define BITS_PER_PIXEL_RGBA 32
typedef struct { // To store 32bit Hash
FT_UInt32 hash[1];
FT_UInt32 hash[1];
}HASH_32;
typedef struct { // To store 128bit Hash
FT_UInt32 hash[4];
FT_UInt32 hash[4];
}HASH_128;
typedef struct {
unsigned char red;
unsigned char green;
unsigned char blue;
unsigned char alpha;
unsigned char red;
unsigned char green;
unsigned char blue;
unsigned char alpha;
} PIXEL;
typedef struct {
unsigned char red;
unsigned char green;
unsigned char blue;
unsigned char alpha;
unsigned char red;
unsigned char green;
unsigned char blue;
unsigned char alpha;
} PIXEL_BGRA;
/* A picture. */
typedef struct {
PIXEL *pixels;
size_t width;
size_t height;
PIXEL *pixels;
size_t width;
size_t height;
} IMAGE;
//-------------------------------------------------------------------------------
@ -58,8 +58,9 @@ HASH_128 * Generate_Hash_x64_128(FT_Bitmap * bitmap, HASH_128 * murmur);
//-------------------------------------------------------------------------------
PIXEL * Pixel_At (IMAGE * bitmap, int x, int y);
PIXEL * Pixel_At (IMAGE * bitmap, int x, int y); // Returns a pointer to pixel
// at (x,y) co-ordinate
void Make_PNG(FT_Bitmap* bitmap,char* name,int i,int render_mode);
int Generate_PNG (IMAGE *bitmap, const char *path,int render_mode);
void Make_PNG(FT_Bitmap* bitmap,char* name,int i,int render_mode); // buffer to image
int Generate_PNG (IMAGE *bitmap, const char *path,int render_mode); // Image to file

186
tests/make_png/hash_to_file.c
View File

@ -2,107 +2,107 @@
int main (int argc, char const *argv[])
{
FT_Library library;
FT_Face face;
FT_GlyphSlot slot;
FT_Library library;
FT_Face face;
FT_GlyphSlot slot;
FT_Bitmap* bitmap;
FT_Bitmap* bitmap;
FT_Error error;
FT_Error error;
const char* font_file;
int size;
int render_mode; // argument
const char* font_file;
int size;
int render_mode; // argument
int load_flag; // FT_LOAD_XXX
int render_flag; // FT_RENDER_MODE_XXX
int target_flag; // FT_LOAD_TARGET_XXX
char* render_type; // for file_name
int load_flag; // FT_LOAD_XXX
int render_flag; // FT_RENDER_MODE_XXX
int target_flag; // FT_LOAD_TARGET_XXX
char* render_type; // for file_name
char name[100]; // hashes file name
int i; // for loop
char name[100]; // hashes file name
int i; // for loop
if (argc != 4)
{
printf("\nTo generate MurmurHash3 hash values of all glyphs\n");
printf("Hashes will be saved in a file named $(font)_$(pt_size)_$(render_mode).hash \n\n");
if (argc != 4)
{
printf("\nTo generate MurmurHash3 hash values of all glyphs\n");
printf("Hashes will be saved in a file named $(font)_$(pt_size)_$(render_mode).hash \n\n");
printf("By default, hashes of 256-level gray bitmaps will be generated\n\n");
printf("By default, hashes of 256-level gray bitmaps will be generated\n\n");
printf("Usage ./<exe> <font_file> <pt_size> <render_mode>\n\n");
printf("Usage ./<exe> <font_file> <pt_size> <render_mode>\n\n");
printf("Values for render_mode 0 - monochrome\n");
printf(" 1 - anti-aliased\n");
printf(" 2 - lcd horizontal-RGB\n");
printf(" 3 - lcd vertical-RGB\n");
printf("Values for render_mode 0 - monochrome\n");
printf(" 1 - anti-aliased\n");
printf(" 2 - lcd horizontal-RGB\n");
printf(" 3 - lcd vertical-RGB\n");
return 1;
}
return 1;
}
font_file = argv[1];
size = atof(argv[2]);
render_mode = atoi(argv[3]);
font_file = argv[1];
size = atof(argv[2]);
render_mode = atoi(argv[3]);
error = FT_Init_FreeType( &library );
if(error){
printf("Error while initialising library\n");
}
error = FT_Init_FreeType( &library );
if(error){
printf("Error while initialising library\n");
}
error = FT_New_Face( library,
font_file,
0,
&face );
if(error){
printf("Error loading new face\n");
}
error = FT_New_Face( library,
font_file,
0,
&face );
if(error){
printf("Error loading new face\n");
}
error = FT_Set_Char_Size( face,
size * 64,
0,
DPI,
0 );
if(error){
printf("Error setting character size\n");
}
error = FT_Set_Char_Size( face,
size * 64,
0,
DPI,
0 );
if(error){
printf("Error setting character size\n");
}
switch ( render_mode ) {
case 0: render_flag = FT_RENDER_MODE_MONO;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_MONO;
render_type = "mono";
break;
switch ( render_mode ) {
case 0: render_flag = FT_RENDER_MODE_MONO;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_MONO;
render_type = "mono";
break;
case 1: render_flag = FT_RENDER_MODE_NORMAL;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_NORMAL;
render_type = "gray";
break;
case 1: render_flag = FT_RENDER_MODE_NORMAL;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_NORMAL;
render_type = "gray";
break;
case 2: render_flag = FT_RENDER_MODE_LCD;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_LCD;
render_type = "lcd_rgb";
break;
case 2: render_flag = FT_RENDER_MODE_LCD;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_LCD;
render_type = "lcd_rgb";
break;
case 3: render_flag = FT_RENDER_MODE_LCD_V;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_LCD_V;
render_type = "lcd_ver_rgb";
break;
case 3: render_flag = FT_RENDER_MODE_LCD_V;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_LCD_V;
render_type = "lcd_ver_rgb";
break;
default:render_flag = FT_RENDER_MODE_NORMAL;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_NORMAL;
render_type = "gray";
}
default:render_flag = FT_RENDER_MODE_NORMAL;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_NORMAL;
render_type = "gray";
}
slot = face->glyph;
FILE* fp;
sprintf(name,"./hashes/%s_%d_%s.hash",font_file,
size,
render_type);
size,
render_type);
fp = fopen(name,"w");
@ -111,31 +111,31 @@ int main (int argc, char const *argv[])
error = FT_Load_Glyph( face,
i,
load_flag | target_flag);
if(error){
printf("Error loading glyph\n");
}
if(error){
printf("Error loading glyph\n");
}
FT_Render_Glyph( slot,
render_flag);
if(error){
printf("Error rendering the glyph\n");
}
FT_Render_Glyph( slot,
render_flag);
if(error){
printf("Error rendering the glyph\n");
}
bitmap = &slot->bitmap;
bitmap = &slot->bitmap;
HASH_128 * murmur = (HASH_128 *) malloc(sizeof(HASH_128)) ;
murmur = Generate_Hash_x64_128(bitmap,murmur);
HASH_128 * murmur = (HASH_128 *) malloc(sizeof(HASH_128)) ;
murmur = Generate_Hash_x64_128(bitmap,murmur);
fprintf(fp, "%08x %08x %08x %08x\n", murmur->hash[0], // Print hash
murmur->hash[1],
murmur->hash[2],
murmur->hash[3]);
fprintf(fp, "%08x %08x %08x %08x\n", murmur->hash[0], // Print hash
murmur->hash[1],
murmur->hash[2],
murmur->hash[3]);
}
fclose(fp);
FT_Done_Face ( face );
FT_Done_FreeType( library );
FT_Done_FreeType( library );
return 0;
return 0;
}

214
tests/make_png/make_png.c
View File

@ -2,120 +2,129 @@
int main (int argc, char const *argv[])
{
FT_Library library;
FT_Face face;
FT_GlyphSlot slot;
FT_Library library;
FT_Face face;
FT_GlyphSlot slot;
FT_Bitmap* bitmap;
FT_Bitmap* bitmap;
FT_Error error;
FT_Error error;
const char* font_file;
int size;
int render_mode; // argument
const char* font_file;
int size;
int render_mode; // argument
int load_flag; // FT_LOAD_XXX
int render_flag; // FT_RENDER_MODE_XXX
int target_flag; // FT_LOAD_TARGET_XXX
char* render_type; // for file_name
int load_flag; // FT_LOAD_XXX
int render_flag; // FT_RENDER_MODE_XXX
int target_flag; // FT_LOAD_TARGET_XXX
char* render_type; // for file_name
char name[100]; // hashes file name
int i; // for loop
char name[100]; // hashes file name
int i; // for loop
if (argc != 4)
{
printf("\nTo generate 32-bit RGBA PNG(s) of all glyphs in a font\n");
printf("Images will be saved in a file named \n\
$(font)_$(pt_size)_$(render_mode)_$(glyph_index).png \n\n");
if (argc != 4)
{
printf("\nTo generate 32-bit RGBA PNG(s) of all glyphs in a font\n");
printf("Images will be saved in a file named \n\
$(font)_$(pt_size)_$(render_mode)_$(glyph_index).png \n\n");
printf("By default, hashes of 256-level gray bitmaps will be generated\n\n");
printf("By default, hashes of 256-level gray bitmaps will be generated\n\n");
printf("Usage ./<exe> <font_file> <pt_size> <render_mode>\n\n");
printf("Usage ./<exe> <font_file> <pt_size> <render_mode>\n\n");
printf("Values for render_mode 0 - monochrome\n");
printf(" 1 - anti-aliased\n");
printf(" 2 - lcd horizontal-RGB\n");
printf(" 3 - lcd horizontal-BGR\n");
printf(" 4 - lcd vertical-RGB\n");
printf(" 5 - lcd vertical-BGR\n");
printf("Values for render_mode 0 - monochrome\n");
printf(" 1 - anti-aliased\n");
printf(" 2 - lcd horizontal-RGB\n");
printf(" 3 - lcd horizontal-BGR\n");
printf(" 4 - lcd vertical-RGB\n");
printf(" 5 - lcd vertical-BGR\n");
return 1;
}
return 1;
}
font_file = argv[1];
size = atof(argv[2]);
render_mode = atoi(argv[3]);
font_file = argv[1];
size = atof(argv[2]);
render_mode = atoi(argv[3]);
error = FT_Init_FreeType( &library );
error = FT_Init_FreeType( &library );
if(error){
printf("Error while initialising library\n");
}
if (render_mode > 1 )
{
error = FT_Library_SetLcdFilter( library,
FT_LCD_FILTER_DEFAULT );
if(error){
printf("Error while initialising library\n");
printf("Error while setting LCD filter\n");
}
}
error = FT_New_Face( library,
font_file,
0,
&face );
if(error){
printf("Error loading new face\n");
}
error = FT_New_Face( library,
font_file,
0,
&face );
if(error){
printf("Error loading new face\n");
}
error = FT_Set_Char_Size( face,
size * 64,
0,
DPI,
0 );
if(error){
printf("Error setting character size\n");
}
error = FT_Set_Char_Size( face,
size * 64,
0,
DPI,
0 );
if(error){
printf("Error setting character size\n");
}
switch ( render_mode ) {
case 0: render_flag = FT_RENDER_MODE_MONO;
load_flag = FT_LOAD_MONOCHROME;
target_flag = FT_LOAD_TARGET_MONO;
render_type = "mono";
break;
switch ( render_mode ) {
case 0: render_flag = FT_RENDER_MODE_MONO;
load_flag = FT_LOAD_MONOCHROME;
target_flag = FT_LOAD_TARGET_MONO;
render_type = "mono";
break;
case 1: render_flag = FT_RENDER_MODE_NORMAL;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_NORMAL;
render_type = "gray";
break;
case 1: render_flag = FT_RENDER_MODE_NORMAL;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_NORMAL;
render_type = "gray";
break;
case 2: render_flag = FT_RENDER_MODE_LCD;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_LCD;
render_type = "lcd_rgb";
break;
case 2: render_flag = FT_RENDER_MODE_LCD;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_LCD;
render_type = "lcd_rgb";
break;
case 3: render_flag = FT_RENDER_MODE_LCD;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_LCD;
render_type = "lcd_bgr";
break;
case 3: render_flag = FT_RENDER_MODE_LCD;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_LCD;
render_type = "lcd_bgr";
break;
case 4: render_flag = FT_RENDER_MODE_LCD_V;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_LCD_V;
render_type = "lcd_ver_rgb";
break;
case 4: render_flag = FT_RENDER_MODE_LCD_V;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_LCD_V;
render_type = "lcd_ver_rgb";
break;
case 5: render_flag = FT_RENDER_MODE_LCD_V;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_LCD_V;
render_type = "lcd_ver_bgr";
break;
case 5: render_flag = FT_RENDER_MODE_LCD_V;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_LCD_V;
render_type = "lcd_ver_bgr";
break;
default:render_flag = FT_RENDER_MODE_NORMAL;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_NORMAL;
render_type = "gray";
}
default:render_flag = FT_RENDER_MODE_NORMAL;
load_flag = FT_LOAD_DEFAULT;
target_flag = FT_LOAD_TARGET_NORMAL;
render_type = "gray";
}
slot = face->glyph;
sprintf(name,"./images/%s_%d_%s",font_file,
size,
render_type);
sprintf(name,"./images/%s_%d_%s", font_file,
size,
render_type);
for (i = 0; i <50; ++i)
{
@ -123,20 +132,20 @@ int main (int argc, char const *argv[])
i,
load_flag | target_flag);
if(error){
printf("Error loading glyph\n");
printf("Error loading glyph\n");
}
FT_Render_Glyph( slot,
render_flag);
if(error){
printf("Error rendering the glyph\n");
printf("Error rendering the glyph\n");
}
bitmap = &slot->bitmap;
if (bitmap->width == 0 || bitmap->rows == 0)
{
continue;
continue;
}
FT_Bitmap target;
@ -144,15 +153,16 @@ int main (int argc, char const *argv[])
if (bitmap->pixel_mode == 1)
{
int alignment = 4;
error = FT_Bitmap_Convert( library,
bitmap,
&target,
alignment);
if(error){
printf("Error converting the bitmap\n");
}
Make_PNG(&target,name,i,render_mode);
int alignment = 4;
error = FT_Bitmap_Convert( library,
bitmap,
&target,
alignment);
if(error){
printf("Error converting the bitmap\n");
}
Make_PNG(&target,name,i,render_mode);
}else{
Make_PNG(bitmap,name,i,render_mode);
@ -160,8 +170,8 @@ int main (int argc, char const *argv[])
}
FT_Done_Face ( face );
FT_Done_FreeType( library );
FT_Done_FreeType( library );
return 0;
return 0;
}