Indentation change

4 files changed, 412 insertions, 399 deletions

diff --git a/new/bitmap.c b/new/bitmap.c
index 2813ff1b4..54b9c13f4 100644
--- a/new/bitmap.c
+++ b/new/bitmap.c
@@ -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;
-
-    int status = -1;
-
-    int pixel_size = 4;
-    int depth = 8;
-    
-    fp = fopen (path, "wb");
-    if (! fp) {
-        goto fopen_failed;
-    }
-
-    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;
-    }
-
-    if (setjmp (png_jmpbuf (png_ptr))) {
-        goto png_failure;
-    }
-
-    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);
-
-    row_pointers = png_malloc (png_ptr, bitmap->height * sizeof (png_byte *));
-
-    for (y = 0; y < bitmap->height; y++) {
-
-        png_byte *row = png_malloc (png_ptr, sizeof (uint8_t) * bitmap->width * pixel_size);
-        row_pointers[y] = row;
-
-        for (x = 0; x < bitmap->width; x++) {
-
-            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;
-            }
-            *row++ = pixel->red;
-            *row++ = pixel->green;
-            *row++ = pixel->blue;
-            *row++ = pixel->alpha;
+  FILE * fp;
+  png_structp png_ptr       = NULL;
+  png_infop info_ptr        = NULL;
+
+  size_t x, y;
+  png_byte ** row_pointers = NULL;
+
+  int status = -1;
+
+  int pixel_size = 4;
+  int depth = 8;
+  
+  fp = fopen (path, "wb");
+  if (! fp) {
+    goto fopen_failed;
+  }
+
+  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;
+  }
+
+  if (setjmp (png_jmpbuf (png_ptr))) {
+    goto png_failure;
+  }
+
+  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);
+
+  row_pointers = png_malloc (png_ptr, bitmap->height * sizeof (png_byte *));
+
+  for (y = 0; y < bitmap->height; y++) {
+
+    png_byte *row = png_malloc (png_ptr, sizeof (uint8_t) * bitmap->width * pixel_size);
+    row_pointers[y] = row;
+
+    for (x = 0; x < bitmap->width; x++) {
+
+      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);
 }
\ No newline at end of file
diff --git a/new/bitmap.h b/new/bitmap.h
index 8a3a4f58e..48eb04214 100644
--- a/new/bitmap.h
+++ b/new/bitmap.h
@@ -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 
 
diff --git a/new/hash_to_file.c b/new/hash_to_file.c
index 64000be80..3bd748a25 100644
--- a/new/hash_to_file.c
+++ b/new/hash_to_file.c
@@ -2,107 +2,107 @@
 
 int main (int argc, char const *argv[])
 {
-	FT_Library      library;
-    FT_Face         face;
-    FT_GlyphSlot    slot;
-
-    FT_Bitmap*      bitmap;
-
-    FT_Error        error;
-
-    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 	
-
-	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");
-
-        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("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;
-    }
-
-    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_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");
-    }
-
-    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 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;
-
-		default:render_flag 	= FT_RENDER_MODE_NORMAL;
-				load_flag 		= FT_LOAD_DEFAULT;
-				target_flag 	= FT_LOAD_TARGET_NORMAL;
-				render_type     = "gray";
-	}
+	FT_Library       library;
+  FT_Face          face;
+  FT_GlyphSlot     slot;
+
+  FT_Bitmap*       bitmap;
+
+  FT_Error         error;
+
+  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 	
+
+	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");
+
+    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("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;
+  }
+
+  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_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");
+  }
+
+  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 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;
+
+  	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;
     
 }
diff --git a/new/make_png.c b/new/make_png.c
index 4d3312561..27e81c50d 100644
--- a/new/make_png.c
+++ b/new/make_png.c
@@ -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 );
-    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 (render_mode > 1 )
+  {
+    error = FT_Library_SetLcdFilter( library,
+                                      FT_LCD_FILTER_DEFAULT );
     if(error){
-        printf("Error loading new face\n");
+      printf("Error while setting LCD filter\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;
-
-		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 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 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";
-	}
+  }
+
+  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");
+  }
+
+  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 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 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;
+
+  	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;
     
 }