From d19aed6f1ce7df816080f9b2c1a0279b3257a0f1 Mon Sep 17 00:00:00 2001 From: Kushal K S V S Date: Wed, 28 Jun 2017 11:00:44 +0530 Subject: new code for generating hashes --- tests/make_png/README | 16 +++ tests/make_png/bitmap.c | 29 ++++ tests/make_png/bitmap.h | 27 ++++ tests/make_png/hash_to_file.c | 141 +++++++++++++++++++ tests/make_png/makefile | 22 +++ tests/make_png/murmur3.c | 312 ++++++++++++++++++++++++++++++++++++++++++ tests/make_png/murmur3.h | 24 ++++ 7 files changed, 571 insertions(+) create mode 100644 tests/make_png/README create mode 100644 tests/make_png/bitmap.c create mode 100644 tests/make_png/bitmap.h create mode 100644 tests/make_png/hash_to_file.c create mode 100644 tests/make_png/makefile create mode 100644 tests/make_png/murmur3.c create mode 100644 tests/make_png/murmur3.h diff --git a/tests/make_png/README b/tests/make_png/README new file mode 100644 index 000000000..a01ac2d77 --- /dev/null +++ b/tests/make_png/README @@ -0,0 +1,16 @@ +To generate hashes and store it in the same folder, + + 1) sudo make + (set resoluton in DPI by passing argument + example: sudo make DPI=100, if not specified,default is 72) + + 2) Usage ./hash + + Hashes will be saved in a file named $(font)_$(pt_size)_$(render_mode).hash + + By default, hashes of 256-level gray bitmaps will be generated + + Values for render_mode 0 - monochrome + 1 - anti-aliased + 2 - lcd horizontal-RGB + 3 - lcd vertical-RGB \ No newline at end of file diff --git a/tests/make_png/bitmap.c b/tests/make_png/bitmap.c new file mode 100644 index 000000000..923d072f3 --- /dev/null +++ b/tests/make_png/bitmap.c @@ -0,0 +1,29 @@ +#include "bitmap.h" + +HASH_128 * Generate_Hash_x64_128(FT_Bitmap * bitmap, HASH_128 * murmur) +{ + int seed = 99; // Dont change + + MurmurHash3_x64_128(bitmap->buffer, (bitmap->pitch * bitmap->rows), seed, murmur->hash); + + return murmur; +} + +HASH_128 * Generate_Hash_x86_128(FT_Bitmap * bitmap, HASH_128 * murmur) +{ + int seed = 99; // Dont change + + MurmurHash3_x86_128(bitmap->buffer, (bitmap->pitch * bitmap->rows), seed, murmur->hash); + + return murmur; +} + +HASH_32 * Generate_Hash_x86_32(FT_Bitmap * bitmap, HASH_32 * murmur) +{ + int seed = 99; // Dont change + + MurmurHash3_x86_32(bitmap->buffer, (bitmap->pitch * bitmap->rows), seed, murmur->hash); + + return murmur; +} + diff --git a/tests/make_png/bitmap.h b/tests/make_png/bitmap.h new file mode 100644 index 000000000..fb7ab12e5 --- /dev/null +++ b/tests/make_png/bitmap.h @@ -0,0 +1,27 @@ +#include +#include +#include "murmur3.h" // MurmurHash3_x64_128 header file +#include + +#include FT_FREETYPE_H +#include FT_MODULE_H +#include FT_LCD_FILTER_H +#include FT_BITMAP_H + +#define BITS_PER_PIXEL_RGBA 32 + +typedef struct { // To store 32bit Hash + FT_UInt32 hash[1]; +}HASH_32; + +typedef struct { // To store 128bit Hash + FT_UInt32 hash[4]; +}HASH_128; + +//------------------------------------------------------------------------------- + +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); + +//------------------------------------------------------------------------------- diff --git a/tests/make_png/hash_to_file.c b/tests/make_png/hash_to_file.c new file mode 100644 index 000000000..64000be80 --- /dev/null +++ b/tests/make_png/hash_to_file.c @@ -0,0 +1,141 @@ +#include "bitmap.h" + +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 ./ \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); + + fp = fopen(name,"w"); + + for (i = 0; i < face->num_glyphs; ++i) + { + error = FT_Load_Glyph( face, + i, + load_flag | target_flag); + if(error){ + printf("Error loading glyph\n"); + } + + FT_Render_Glyph( slot, + render_flag); + if(error){ + printf("Error rendering the glyph\n"); + } + + bitmap = &slot->bitmap; + + 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]); + } + fclose(fp); + + FT_Done_Face ( face ); + FT_Done_FreeType( library ); + + return 0; + +} diff --git a/tests/make_png/makefile b/tests/make_png/makefile new file mode 100644 index 000000000..d60a6d685 --- /dev/null +++ b/tests/make_png/makefile @@ -0,0 +1,22 @@ +# Define required macros here + +SHELL = /bin/sh + +SRC = hash_to_file.c bitmap.c murmur3.c +OBJS = $(src:.c=.o) + +CFLAGS = -Wall -g +CC = gcc +INCLUDE = -I /usr/local/include/freetype2/ +LIBS = -lfreetype + +DPI = 72 + +hash:$(SRC) + $(CC) $(CFLAGS) $(INCLUDE) -DDPI=$(DPI) -o $@ $(SRC) $(OBJS) $(LIBS) + +.PHONY: clean +clean: + -rm -f *.o + + diff --git a/tests/make_png/murmur3.c b/tests/make_png/murmur3.c new file mode 100644 index 000000000..484ebfd03 --- /dev/null +++ b/tests/make_png/murmur3.c @@ -0,0 +1,312 @@ +//----------------------------------------------------------------------------- +// 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 + +#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 ) +{ + return (x << r) | (x >> (32 - r)); +} + +static FORCE_INLINE 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 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 + +#define getblock(p, i) (p[i]) + +//----------------------------------------------------------------------------- +// Finalization mix - force all bits of a hash block to avalanche + +static FORCE_INLINE uint32_t fmix32 ( uint32_t h ) +{ + h ^= h >> 16; + h *= 0x85ebca6b; + h ^= h >> 13; + h *= 0xc2b2ae35; + h ^= h >> 16; + + return h; +} + +//---------- + +static FORCE_INLINE uint64_t fmix64 ( uint64_t k ) +{ + k ^= k >> 33; + k *= BIG_CONSTANT(0xff51afd7ed558ccd); + k ^= k >> 33; + k *= BIG_CONSTANT(0xc4ceb9fe1a85ec53); + k ^= k >> 33; + + return k; +} + +//----------------------------------------------------------------------------- + +void MurmurHash3_x86_32 ( const void * key, int len, + uint32_t seed, void * out ) +{ + const uint8_t * data = (const uint8_t*)key; + const int nblocks = len / 4; + int i; + + uint32_t h1 = seed; + + uint32_t c1 = 0xcc9e2d51; + uint32_t c2 = 0x1b873593; + + //---------- + // body + + const uint32_t * blocks = (const uint32_t *)(data + nblocks*4); + + for(i = -nblocks; i; i++) + { + uint32_t k1 = getblock(blocks,i); + + k1 *= c1; + k1 = ROTL32(k1,15); + k1 *= c2; + + h1 ^= k1; + h1 = ROTL32(h1,13); + h1 = h1*5+0xe6546b64; + } + + //---------- + // tail + + const uint8_t * tail = (const uint8_t*)(data + nblocks*4); + + uint32_t k1 = 0; + + switch(len & 3) + { + case 3: k1 ^= tail[2] << 16; + case 2: k1 ^= tail[1] << 8; + case 1: k1 ^= tail[0]; + k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1; + }; + + //---------- + // finalization + + h1 ^= len; + + h1 = fmix32(h1); + + *(uint32_t*)out = h1; +} + +//----------------------------------------------------------------------------- + +void MurmurHash3_x86_128 ( const void * key, const int len, + uint32_t seed, void * out ) +{ + const uint8_t * data = (const uint8_t*)key; + const int nblocks = len / 16; + int i; + + uint32_t h1 = seed; + uint32_t h2 = seed; + uint32_t h3 = seed; + uint32_t h4 = seed; + + uint32_t c1 = 0x239b961b; + uint32_t c2 = 0xab0e9789; + uint32_t c3 = 0x38b34ae5; + uint32_t c4 = 0xa1e38b93; + + //---------- + // body + + const uint32_t * blocks = (const uint32_t *)(data + nblocks*16); + + for(i = -nblocks; i; i++) + { + uint32_t k1 = getblock(blocks,i*4+0); + uint32_t k2 = getblock(blocks,i*4+1); + uint32_t k3 = getblock(blocks,i*4+2); + uint32_t k4 = getblock(blocks,i*4+3); + + k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1; + + h1 = ROTL32(h1,19); h1 += h2; h1 = h1*5+0x561ccd1b; + + k2 *= c2; k2 = ROTL32(k2,16); k2 *= c3; h2 ^= k2; + + h2 = ROTL32(h2,17); h2 += h3; h2 = h2*5+0x0bcaa747; + + k3 *= c3; k3 = ROTL32(k3,17); k3 *= c4; h3 ^= k3; + + h3 = ROTL32(h3,15); h3 += h4; h3 = h3*5+0x96cd1c35; + + k4 *= c4; k4 = ROTL32(k4,18); k4 *= c1; h4 ^= k4; + + h4 = ROTL32(h4,13); h4 += h1; h4 = h4*5+0x32ac3b17; + } + + //---------- + // tail + + const uint8_t * tail = (const uint8_t*)(data + nblocks*16); + + uint32_t k1 = 0; + uint32_t k2 = 0; + uint32_t k3 = 0; + uint32_t k4 = 0; + + switch(len & 15) + { + case 15: k4 ^= tail[14] << 16; + case 14: k4 ^= tail[13] << 8; + case 13: k4 ^= tail[12] << 0; + k4 *= c4; k4 = ROTL32(k4,18); k4 *= c1; h4 ^= k4; + + case 12: k3 ^= tail[11] << 24; + case 11: k3 ^= tail[10] << 16; + case 10: k3 ^= tail[ 9] << 8; + case 9: k3 ^= tail[ 8] << 0; + k3 *= c3; k3 = ROTL32(k3,17); k3 *= c4; h3 ^= k3; + + case 8: k2 ^= tail[ 7] << 24; + case 7: k2 ^= tail[ 6] << 16; + case 6: k2 ^= tail[ 5] << 8; + case 5: k2 ^= tail[ 4] << 0; + k2 *= c2; k2 = ROTL32(k2,16); k2 *= c3; h2 ^= k2; + + case 4: k1 ^= tail[ 3] << 24; + case 3: k1 ^= tail[ 2] << 16; + case 2: k1 ^= tail[ 1] << 8; + case 1: k1 ^= tail[ 0] << 0; + k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1; + }; + + //---------- + // finalization + + h1 ^= len; h2 ^= len; h3 ^= len; h4 ^= len; + + h1 += h2; h1 += h3; h1 += h4; + h2 += h1; h3 += h1; h4 += h1; + + h1 = fmix32(h1); + h2 = fmix32(h2); + h3 = fmix32(h3); + h4 = fmix32(h4); + + h1 += h2; h1 += h3; h1 += h4; + h2 += h1; h3 += h1; h4 += h1; + + ((uint32_t*)out)[0] = h1; + ((uint32_t*)out)[1] = h2; + ((uint32_t*)out)[2] = h3; + ((uint32_t*)out)[3] = h4; +} + +//----------------------------------------------------------------------------- + +void MurmurHash3_x64_128 ( const void * key, const int len, + const uint32_t seed, void * out ) +{ + const uint8_t * data = (const uint8_t*)key; + const int nblocks = len / 16; + int i; + + uint64_t h1 = seed; + uint64_t h2 = seed; + + uint64_t c1 = BIG_CONSTANT(0x87c37b91114253d5); + uint64_t c2 = BIG_CONSTANT(0x4cf5ad432745937f); + + //---------- + // body + + const uint64_t * blocks = (const uint64_t *)(data); + + for(i = 0; i < nblocks; i++) + { + uint64_t k1 = getblock(blocks,i*2+0); + uint64_t k2 = getblock(blocks,i*2+1); + + k1 *= c1; k1 = ROTL64(k1,31); k1 *= c2; h1 ^= k1; + + h1 = ROTL64(h1,27); h1 += h2; h1 = h1*5+0x52dce729; + + k2 *= c2; k2 = ROTL64(k2,33); k2 *= c1; h2 ^= k2; + + h2 = ROTL64(h2,31); h2 += h1; h2 = h2*5+0x38495ab5; + } + + //---------- + // tail + + const uint8_t * tail = (const uint8_t*)(data + nblocks*16); + + uint64_t k1 = 0; + uint64_t k2 = 0; + + switch(len & 15) + { + case 15: k2 ^= (uint64_t)(tail[14]) << 48; + case 14: k2 ^= (uint64_t)(tail[13]) << 40; + case 13: k2 ^= (uint64_t)(tail[12]) << 32; + case 12: k2 ^= (uint64_t)(tail[11]) << 24; + case 11: k2 ^= (uint64_t)(tail[10]) << 16; + case 10: k2 ^= (uint64_t)(tail[ 9]) << 8; + case 9: k2 ^= (uint64_t)(tail[ 8]) << 0; + k2 *= c2; k2 = ROTL64(k2,33); k2 *= c1; h2 ^= k2; + + case 8: k1 ^= (uint64_t)(tail[ 7]) << 56; + case 7: k1 ^= (uint64_t)(tail[ 6]) << 48; + case 6: k1 ^= (uint64_t)(tail[ 5]) << 40; + case 5: k1 ^= (uint64_t)(tail[ 4]) << 32; + case 4: k1 ^= (uint64_t)(tail[ 3]) << 24; + case 3: k1 ^= (uint64_t)(tail[ 2]) << 16; + case 2: k1 ^= (uint64_t)(tail[ 1]) << 8; + case 1: k1 ^= (uint64_t)(tail[ 0]) << 0; + k1 *= c1; k1 = ROTL64(k1,31); k1 *= c2; h1 ^= k1; + }; + + //---------- + // finalization + + h1 ^= len; h2 ^= len; + + h1 += h2; + h2 += h1; + + h1 = fmix64(h1); + h2 = fmix64(h2); + + h1 += h2; + h2 += h1; + + ((uint64_t*)out)[0] = h1; + ((uint64_t*)out)[1] = h2; +} + +//----------------------------------------------------------------------------- + diff --git a/tests/make_png/murmur3.h b/tests/make_png/murmur3.h new file mode 100644 index 000000000..90878b00d --- /dev/null +++ b/tests/make_png/murmur3.h @@ -0,0 +1,24 @@ +#ifndef _MURMURHASH3_H_ +#define _MURMURHASH3_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +//----------------------------------------------------------------------------- + +void MurmurHash3_x86_32 (const void *key, int len, uint32_t seed, void *out); + +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_ -- cgit v1.2.1