Chiebot-Mirror
/
freetype
mirror of https://github.com/freetype/freetype.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

MAking code compatible with C89

Browse Source
GSoC-2017-kushal
Kushal K S V S 8 years ago
parent a5755f0842
commit 6277cc4600
5 changed files with 121 additions and 114 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 77
      tests/make_png/bitmap.c
  2. 49
      tests/make_png/bitmap.h
  3. 14
      tests/make_png/make_sprite.c
  4. 89
      tests/make_png/murmur3.c
  5. 6
      tests/make_png/murmur3.h

77
tests/make_png/bitmap.c
Unescape View File

@ -3,7 +3,7 @@
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),
@ -16,7 +16,7 @@ HASH_128 * Generate_Hash_x64_128( FT_Bitmap * bitmap,
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),
@ -29,7 +29,7 @@ HASH_128 * Generate_Hash_x86_128( FT_Bitmap * bitmap,
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),
@ -161,7 +161,7 @@ void Make_PNG(FT_Bitmap* bitmap,IMAGE* fruit,int i,int render_mode){
switch(render_mode){
case 0 : fruit->width = bitmap->width; // MONO and GRAY
case 0 : fruit->width = bitmap->width; /* MONO and GRAY */
fruit->height = bitmap->rows;
fruit->pixels = calloc ( fruit->width * fruit->height,
@ -188,7 +188,7 @@ void Make_PNG(FT_Bitmap* bitmap,IMAGE* fruit,int i,int render_mode){
}
}
break;
case 1 : fruit->width = bitmap->width; // MONO and GRAY
case 1 : fruit->width = bitmap->width; /* MONO and GRAY */
fruit->height = bitmap->rows;
fruit->pixels = calloc ( fruit->width * fruit->height,
@ -211,7 +211,7 @@ void Make_PNG(FT_Bitmap* bitmap,IMAGE* fruit,int i,int render_mode){
break;
case 2 :
case 3 : fruit->width = bitmap->width / 3; // LCD
case 3 : fruit->width = bitmap->width / 3; /* LCD */
fruit->height = bitmap->rows;
fruit->pixels = calloc ( fruit->width * fruit->height,
@ -240,7 +240,7 @@ void Make_PNG(FT_Bitmap* bitmap,IMAGE* fruit,int i,int render_mode){
break;
case 4 :
case 5 : fruit->width = bitmap->width; // LCD_V
case 5 : fruit->width = bitmap->width; /* LCD_V */
fruit->height = bitmap->rows / 3;
fruit->pixels = calloc ( fruit->width * fruit->height,
@ -276,7 +276,7 @@ void Make_PNG(FT_Bitmap* bitmap,IMAGE* fruit,int i,int render_mode){
void Read_PNG(char *filename, IMAGE * after_effect) {
int width, height;
int width, height, x, y;
png_bytep *row_pointers;
FILE *fp = fopen(filename, "rb");
@ -305,7 +305,7 @@ void Read_PNG(char *filename, IMAGE * after_effect) {
after_effect->height = height;
row_pointers = (png_bytep*)malloc(sizeof(png_bytep) * height);
for(int y = 0; y < height; y++) {
for( y = 0; y < height; y++) {
row_pointers[y] = (png_byte*)malloc(png_get_rowbytes(png,info));
}
@ -314,11 +314,11 @@ void Read_PNG(char *filename, IMAGE * after_effect) {
after_effect->pixels =
(PIXEL*) malloc( width * height * sizeof(PIXEL));
for(int y = 0; y < height; y++) {
for( y = 0; y < height; y++) {
png_bytep row = row_pointers[y];
for(int x = 0; x < width; x++ ) {
for( x = 0; x < width; x++ ) {
png_bytep px = &(row[x * 4]);
@ -337,14 +337,15 @@ void Read_PNG(char *filename, IMAGE * after_effect) {
int Add_effect(IMAGE* base, IMAGE* test, IMAGE* out, int Effect_ID)
{
int pixel_diff = 0;
int x,y;
out->width = base->width;
out->height = base->height;
out->pixels =
(PIXEL*)malloc(base->width * base->height * sizeof(PIXEL));
for(int y = 0; y < base->height; y++) {
for(int x = 0; x < base->width; x++ ) {
for( y = 0; y < base->height; y++) {
for( x = 0; x < base->width; x++ ) {
PIXEL * pixel_base = Pixel_At ( base, x, y);
PIXEL * pixel_test = Pixel_At ( test, x, y);
@ -397,15 +398,17 @@ int Add_effect(IMAGE* base, IMAGE* test, IMAGE* out, int Effect_ID)
void Stitch(IMAGE* left, IMAGE* right, IMAGE* result){
int x, y;
result->width = left->width + right->width;
result->height = MAX(left->height, right->height);
result->pixels =
(PIXEL*)calloc(result->width * result->height, sizeof(PIXEL));
for (int y = 0; y < left->height; ++y)
for ( y = 0; y < left->height; ++y)
{
for (int x = 0; x < left->width; ++x)
for ( x = 0; x < left->width; ++x)
{
PIXEL * pixel_left = Pixel_At ( left, x, y);
PIXEL * pixel_result = Pixel_At ( result, x, y);
@ -417,9 +420,9 @@ void Stitch(IMAGE* left, IMAGE* right, IMAGE* result){
}
}
for (int y = 0; y < right->height; ++y)
for ( y = 0; y < right->height; ++y)
{
for (int x = left->width; x < result->width; ++x)
for ( x = left->width; x < result->width; ++x)
{
PIXEL * pixel_right = Pixel_At ( right, x - left->width, y);
PIXEL * pixel_result = Pixel_At ( result, x, y);
@ -464,9 +467,11 @@ void Print_Row( FILE* fp, int index, char* name, int diff,
int First_Column(IMAGE* input){
for (int x = 0; x < input->width; ++x)
int x, y;
for ( x = 0; x < input->width; ++x)
{
for (int y = 0; y < input->height; ++y)
for ( y = 0; y < input->height; ++y)
{
PIXEL * pixel_result = Pixel_At ( input, x, y);
@ -486,9 +491,11 @@ int First_Column(IMAGE* input){
int First_Row(IMAGE* input){
for (int y = 0; y < input->height; ++y)
int x, y;
for ( y = 0; y < input->height; ++y)
{
for (int x = 0; x < input->width; ++x)
for ( x = 0; x < input->width; ++x)
{
PIXEL * pixel_result = Pixel_At ( input, x, y);
@ -508,6 +515,8 @@ int First_Row(IMAGE* input){
IMAGE* Append_Columns(IMAGE* small, IMAGE* big){
int x, y;
IMAGE* result = (IMAGE*)malloc(sizeof(IMAGE));
result->height = small->height;
@ -517,9 +526,9 @@ IMAGE* Append_Columns(IMAGE* small, IMAGE* big){
int first_col = First_Column(big);
for (int x = 0; x < first_col; ++x)
for ( x = 0; x < first_col; ++x)
{
for (int y = 0; y < result->height; ++y)
for ( y = 0; y < result->height; ++y)
{
PIXEL * pixel_result = Pixel_At ( result, x, y);
@ -530,9 +539,9 @@ IMAGE* Append_Columns(IMAGE* small, IMAGE* big){
}
}
for (int y = 0; y < result->height; ++y)
for ( y = 0; y < result->height; ++y)
{
for (int x = first_col; x < first_col + small->width; ++x)
for ( x = first_col; x < first_col + small->width; ++x)
{
PIXEL * pixel_small = Pixel_At ( small, (x - first_col), y);
PIXEL * pixel_result = Pixel_At ( result, x, y);
@ -544,9 +553,9 @@ IMAGE* Append_Columns(IMAGE* small, IMAGE* big){
}
}
for (int x = first_col + small->width; x < result->width; ++x)
for ( x = first_col + small->width; x < result->width; ++x)
{
for (int y = 0; y < result->height; ++y)
for ( y = 0; y < result->height; ++y)
{
PIXEL * pixel_result = Pixel_At ( result, x, y);
@ -562,6 +571,8 @@ IMAGE* Append_Columns(IMAGE* small, IMAGE* big){
IMAGE* Append_Rows(IMAGE* small, IMAGE* big){
int x, y;
IMAGE* result = (IMAGE*)malloc(sizeof(IMAGE));
result->height = big->height;
@ -571,9 +582,9 @@ IMAGE* Append_Rows(IMAGE* small, IMAGE* big){
int first_row = First_Row(big);
for (int y = 0; y < first_row; ++y)
for ( y = 0; y < first_row; ++y)
{
for (int x = 0; x < result->width; ++x)
for ( x = 0; x < result->width; ++x)
{
PIXEL * pixel_result = Pixel_At ( result, x, y);
@ -584,9 +595,9 @@ IMAGE* Append_Rows(IMAGE* small, IMAGE* big){
}
}
for (int y = first_row; y < first_row + small->height; ++y)
for ( y = first_row; y < first_row + small->height; ++y)
{
for (int x = 0; x < result->width; ++x)
for ( x = 0; x < result->width; ++x)
{
PIXEL * pixel_small = Pixel_At ( small, x, y - first_row);
PIXEL * pixel_result = Pixel_At ( result, x, y);
@ -598,9 +609,9 @@ IMAGE* Append_Rows(IMAGE* small, IMAGE* big){
}
}
for (int y = first_row + small->height; y < result->height; ++y)
for ( y = first_row + small->height; y < result->height; ++y)
{
for (int x = 0; x < result->width; ++x)
for ( x = 0; x < result->width; ++x)
{
PIXEL * pixel_result = Pixel_At ( result, x, y);

49
tests/make_png/bitmap.h
Unescape View File

@ -8,7 +8,7 @@
#include <ft2build.h>
#include "murmur3.h" // MurmurHash3_x64_128 header file
#include "murmur3.h" /* MurmurHash3_x64_128 header file */
#include <png.h>
#include <dlfcn.h>
@ -22,11 +22,11 @@
#define BITS_PER_PIXEL_RGBA 32
#define MAX(a, b) ((a) > (b) ? (a) : (b))
typedef struct { // To store 32bit Hash
typedef struct { /* To store 32bit Hash */
FT_UInt32 hash;
}HASH_32;
typedef struct { // To store 128bit Hash
typedef struct { /* To store 128bit Hash */
FT_UInt32 hash[4];
}HASH_128;
@ -47,44 +47,45 @@ typedef struct {
/* A picture. */
typedef struct {
PIXEL *pixels;
PIXEL* pixels;
size_t width;
size_t height;
} IMAGE;
//------------------------------------------------------------------------------
/*-----------------------------------------------------------------*/
HASH_32 * Generate_Hash_x86_32(FT_Bitmap * bitmap, HASH_32 * murmur);
HASH_128 * Generate_Hash_x86_128(FT_Bitmap * bitmap, HASH_128 * murmur);
HASH_128 * Generate_Hash_x64_128(FT_Bitmap * bitmap, HASH_128 * murmur);
HASH_32* Generate_Hash_x86_32(FT_Bitmap* bitmap, HASH_32* murmur);
HASH_128* Generate_Hash_x86_128(FT_Bitmap* bitmap, HASH_128* murmur);
HASH_128* Generate_Hash_x64_128(FT_Bitmap* bitmap, HASH_128* murmur);
int Compare_Hash(HASH_128* hash_b, HASH_128* hash_t);
//------------------------------------------------------------------------------
/*-----------------------------------------------------------------*/
PIXEL * Pixel_At (IMAGE * bitmap, int x, int y); // Returns a pointer to pixel
// at (x,y) co-ordinate
// buffer to image
/* Returns a pointer to pixel */
/* at (x,y) co-ordinate */
PIXEL* Pixel_At (IMAGE * bitmap, int x, int y);
/* buffer to image */
void Make_PNG (FT_Bitmap* bitmap,IMAGE* fruit, int i,int render_mode);
// Image to file
/* Image to file */
int Generate_PNG (IMAGE *bitmap, const char *path,int render_mode);
// Read PNG
/* Read PNG */
void Read_PNG(char *filename, IMAGE * after_effect);
// Add an effect using two PNG images
// Base Glyph = Gray {127,0,0,255} OR as it is
// Differences = Red {255,0,0,255}
// Effect_ID = {1 or 2}
/* Add an effect using two PNG images */
/* Base Glyph = Gray {127,0,0,255} OR as it is */
/* Differences = Red {255,0,0,255} */
/* Effect_ID = {1 or 2} */
int Add_effect(IMAGE* base, IMAGE* test, IMAGE* out, int Effect_ID);
// Stitch 2 PNG files
/* Stitch 2 PNG files */
void Stitch(IMAGE* left, IMAGE* right, IMAGE* result);
// Make the Height of both the PNG(s) same by filling with white pixels
/* Print the row in list-view webpage */
void Print_Row( FILE* fp, int index, char* name, int diff,
HASH_128* hash_b, HASH_128* hash_t);
// Finding the first non-empty (non-white) column
/* Finding the first non-empty (non-white) column */
int First_Column(IMAGE* input);
// Finding the first non-empty (non-white) row
/* Finding the first non-empty (non-white) row */
int First_Row(IMAGE* input);
// Appening white columns with image alignment
/* Appening white columns with image alignment */
IMAGE* Append_Columns(IMAGE* small, IMAGE* big);
// Appening white columns with image alignment
/* Appening white columns with image alignment */
IMAGE* Append_Rows(IMAGE* small, IMAGE* big);

14
tests/make_png/make_sprite.c
Unescape View File

@ -8,9 +8,9 @@ int main(int argc, char const *argv[])
int size;
int render_mode;
int load_flag; // FT_LOAD_XXX
int render_flag; // FT_RENDER_MODE_XXX
int target_flag; // FT_LOAD_TARGET_XXX
int load_flag; /* FT_LOAD_XXX */
int render_flag; /* FT_RENDER_MODE_XXX */
int target_flag; /* FT_LOAD_TARGET_XXX */
if(argc != 6)
{
@ -63,7 +63,7 @@ int main(int argc, char const *argv[])
HASH_128 * test_murmur = (HASH_128 *) malloc(sizeof(HASH_128)) ;
int Is_Different;
int pixel_diff;
int pixel_diff, i;
char glyph_name[50] = ".not-def";
/*******************************************************************/
@ -351,8 +351,8 @@ int main(int argc, char const *argv[])
size,
DPI);
// Need to write code to check the values in FT_Face and compare
for (int i = 0; i < base_face->num_glyphs; ++i)
/* Need to write code to check the values in FT_Face and compare */
for ( i = 0; i < base_face->num_glyphs; ++i)
{
error = Base_Load_Glyph( base_face,
i,
@ -384,7 +384,7 @@ int main(int argc, char const *argv[])
base_bitmap = &base_slot->bitmap;
test_bitmap = &test_slot->bitmap;
// Need to write code to check the values in FT_Bitmap and compare
/* Need to write code to check the values in FT_Bitmap and compare */
if (base_bitmap->width == 0 || base_bitmap->rows == 0)
{
printf("Empty Glyph in glyph-index %d\n", i);

89
tests/make_png/murmur3.c
Unescape View File

@ -1,45 +1,40 @@
//-----------------------------------------------------------------------------
// Note - The x86 and x64 versions do _not_ produce the same results, as the
// algorithms are optimized for their respective platforms. You can still
// compile and run any of them on any platform, but your performance with the
// non-native version will be less than optimal.
/*------------------------------------------------------------------*/
/* Note - The x86 and x64 versions do _not_ produce the same */
/* results, as the algorithms are optimized for their respective */
/* platforms. You can still compile and run any of them on any */
/* platform, but your performance with the non-native version */
/* will be less than optimal. */
#include "murmur3.h"
//-----------------------------------------------------------------------------
// Platform-specific functions and macros
/*------------------------------------------------------------------*/
/* Platform-specific functions and macros */
#ifdef __GNUC__
#define FORCE_INLINE __attribute__((always_inline)) inline
#else
#define FORCE_INLINE inline
#endif
static FORCE_INLINE uint32_t rotl32 ( uint32_t x, int8_t r )
static uint32_t rotl32 ( uint32_t x, int8_t r )
{
return (x << r) | (x >> (32 - r));
}
static FORCE_INLINE uint64_t rotl64 ( uint64_t x, int8_t r )
static uint64_t rotl64 ( uint64_t x, int8_t r )
{
return (x << r) | (x >> (64 - r));
}
#define ROTL32(x,y) rotl32(x,y)
#define ROTL64(x,y) rotl64(x,y)
#define ROTL32(x,y) rotl32(x,y)
#define ROTL64(x,y) rotl64(x,y)
#define BIG_CONSTANT(x) (x##LLU)
//-----------------------------------------------------------------------------
// Block read - if your platform needs to do endian-swapping or can only
// handle aligned reads, do the conversion here
/*------------------------------------------------------------------*/
/* Block read - if your platform needs to do endian-swapping or can */
/* only handle aligned reads, do the conversion here */
#define getblock(p, i) (p[i])
//-----------------------------------------------------------------------------
// Finalization mix - force all bits of a hash block to avalanche
/*------------------------------------------------------------------*/
/* Finalization mix - force all bits of a hash block to avalanche */
static FORCE_INLINE uint32_t fmix32 ( uint32_t h )
static uint32_t fmix32 ( uint32_t h )
{
h ^= h >> 16;
h *= 0x85ebca6b;
@ -50,9 +45,9 @@ static FORCE_INLINE uint32_t fmix32 ( uint32_t h )
return h;
}
//----------
/*----------*/
static FORCE_INLINE uint64_t fmix64 ( uint64_t k )
static uint64_t fmix64 ( uint64_t k )
{
k ^= k >> 33;
k *= BIG_CONSTANT(0xff51afd7ed558ccd);
@ -63,7 +58,7 @@ static FORCE_INLINE uint64_t fmix64 ( uint64_t k )
return k;
}
//-----------------------------------------------------------------------------
/*------------------------------------------------------------------*/
void MurmurHash3_x86_32 ( const void * key, int len,
uint32_t seed, void * out )
@ -77,8 +72,8 @@ void MurmurHash3_x86_32 ( const void * key, int len,
uint32_t c1 = 0xcc9e2d51;
uint32_t c2 = 0x1b873593;
//----------
// body
/*----------*/
/* body */
const uint32_t * blocks = (const uint32_t *)(data + nblocks*4);
@ -95,8 +90,8 @@ void MurmurHash3_x86_32 ( const void * key, int len,
h1 = h1*5+0xe6546b64;
}
//----------
// tail
/*----------*/
/* tail */
const uint8_t * tail = (const uint8_t*)(data + nblocks*4);
@ -110,8 +105,8 @@ void MurmurHash3_x86_32 ( const void * key, int len,
k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
};
//----------
// finalization
/*----------*/
/* finalization */
h1 ^= len;
@ -120,7 +115,7 @@ void MurmurHash3_x86_32 ( const void * key, int len,
*(uint32_t*)out = h1;
}
//-----------------------------------------------------------------------------
/*------------------------------------------------------------------*/
void MurmurHash3_x86_128 ( const void * key, const int len,
uint32_t seed, void * out )
@ -139,8 +134,8 @@ void MurmurHash3_x86_128 ( const void * key, const int len,
uint32_t c3 = 0x38b34ae5;
uint32_t c4 = 0xa1e38b93;
//----------
// body
/*----------*/
/* body */
const uint32_t * blocks = (const uint32_t *)(data + nblocks*16);
@ -168,8 +163,8 @@ void MurmurHash3_x86_128 ( const void * key, const int len,
h4 = ROTL32(h4,13); h4 += h1; h4 = h4*5+0x32ac3b17;
}
//----------
// tail
/*----------*/
/* tail */
const uint8_t * tail = (const uint8_t*)(data + nblocks*16);
@ -204,8 +199,8 @@ void MurmurHash3_x86_128 ( const void * key, const int len,
k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
};
//----------
// finalization
/*----------*/
/* finalization */
h1 ^= len; h2 ^= len; h3 ^= len; h4 ^= len;
@ -226,7 +221,7 @@ void MurmurHash3_x86_128 ( const void * key, const int len,
((uint32_t*)out)[3] = h4;
}
//-----------------------------------------------------------------------------
/*------------------------------------------------------------------*/
void MurmurHash3_x64_128 ( const void * key, const int len,
const uint32_t seed, void * out )
@ -241,8 +236,8 @@ void MurmurHash3_x64_128 ( const void * key, const int len,
uint64_t c1 = BIG_CONSTANT(0x87c37b91114253d5);
uint64_t c2 = BIG_CONSTANT(0x4cf5ad432745937f);
//----------
// body
/*----------*/
/* body */
const uint64_t * blocks = (const uint64_t *)(data);
@ -260,8 +255,8 @@ void MurmurHash3_x64_128 ( const void * key, const int len,
h2 = ROTL64(h2,31); h2 += h1; h2 = h2*5+0x38495ab5;
}
//----------
// tail
/*----------*/
/* tail */
const uint8_t * tail = (const uint8_t*)(data + nblocks*16);
@ -290,8 +285,8 @@ void MurmurHash3_x64_128 ( const void * key, const int len,
k1 *= c1; k1 = ROTL64(k1,31); k1 *= c2; h1 ^= k1;
};
//----------
// finalization
/*----------*/
/* finalization*/
h1 ^= len; h2 ^= len;
@ -308,5 +303,5 @@ void MurmurHash3_x64_128 ( const void * key, const int len,
((uint64_t*)out)[1] = h2;
}
//-----------------------------------------------------------------------------
/*------------------------------------------------------------------*/

6
tests/make_png/murmur3.h
Unescape View File

@ -7,7 +7,7 @@
extern "C" {
#endif
//-----------------------------------------------------------------------------
/*-----------------------------------------------------------------*/
void MurmurHash3_x86_32 (const void *key, int len, uint32_t seed, void *out);
@ -15,10 +15,10 @@ void MurmurHash3_x86_128(const void *key, int len, uint32_t seed, void *out);
void MurmurHash3_x64_128(const void *key, int len, uint32_t seed, void *out);
//-----------------------------------------------------------------------------
/*-----------------------------------------------------------------*/
#ifdef __cplusplus
}
#endif
#endif // _MURMURHASH3_H_
#endif /* _MURMURHASH3_H_ */

Write Preview
Loading…
Cancel
Save