| /****************************************************************************/ |
| /* */ |
| /* The FreeType project - a Free and Portable Quality TrueType Renderer. */ |
| /* */ |
| /* Copyright 1996-1998 by */ |
| /* D. Turner, R.Wilhelm, and W. Lemberg */ |
| /* */ |
| /* fttimer: A simple performance benchmark. Now with graylevel rendering */ |
| /* with the '-g' option. */ |
| /* */ |
| /* Be aware that the timer program benchmarks different things */ |
| /* in each release of the FreeType library. Thus, performance */ |
| /* should only be compared between similar release numbers. */ |
| /* */ |
| /* */ |
| /* NOTE: This is just a test program that is used to show off and */ |
| /* debug the current engine. In no way does it shows the final */ |
| /* high-level interface that client applications will use. */ |
| /* */ |
| /****************************************************************************/ |
| |
| #include <freetype/freetype.h> |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <time.h> /* for clock() */ |
| |
| #include "graph.h" |
| #include <freetype/ftgrays.h> |
| |
| /* SunOS 4.1.* does not define CLOCKS_PER_SEC, so include <sys/param.h> */ |
| /* to get the HZ macro which is the equivalent. */ |
| #if defined(__sun__) && !defined(SVR4) && !defined(__SVR4) |
| #include <sys/param.h> |
| #define CLOCKS_PER_SEC HZ |
| #endif |
| |
| #define CHARSIZE 400 /* character point size */ |
| #define MAX_GLYPHS 512 /* Maximum number of glyphs rendered at one time */ |
| |
| char Header[128]; |
| |
| FT_Error error; |
| FT_Library library; |
| |
| FT_Face face; |
| FT_Size size; |
| FT_GlyphSlot glyph; |
| |
| FT_Outline outline; |
| |
| FT_Pos* cur_x; |
| FT_Pos* cur_y; |
| |
| unsigned short* cur_endContour; |
| unsigned char* cur_touch; |
| |
| FT_Outline outlines[MAX_GLYPHS]; |
| |
| int num_glyphs; |
| int tab_glyphs; |
| int cur_glyph; |
| int cur_point; |
| unsigned short cur_contour; |
| |
| int pixel_size = CHARSIZE; |
| int repeat_count = 1; |
| int use_grays = 0; |
| |
| FT_Bitmap Bit; |
| grBitmap bit; |
| |
| int Fail; |
| int Num; |
| |
| int vio_Height, vio_Width; |
| |
| short visual; /* display glyphs while rendering */ |
| short antialias; /* smooth fonts with gray levels */ |
| short force_low; |
| |
| |
| #define RASTER_BUFF_SIZE 128000 |
| char raster_buff[ RASTER_BUFF_SIZE ]; |
| |
| |
| static void Clear_Buffer(); |
| |
| static void Panic( const char* message ) |
| { |
| fprintf( stderr, "%s\n error code = 0x%04x\n", message, error ); |
| } |
| |
| /*******************************************************************/ |
| /* */ |
| /* Get_Time: */ |
| /* */ |
| /* Returns the current time in milliseconds. */ |
| /* */ |
| /*******************************************************************/ |
| |
| long Get_Time( void ) |
| { |
| return clock() * 10000 / CLOCKS_PER_SEC; |
| } |
| |
| |
| /*******************************************************************/ |
| /* */ |
| /* Init_Engine: */ |
| /* */ |
| /* Allocates bitmap, render pool and other structs... */ |
| /* */ |
| /*******************************************************************/ |
| |
| void Init_Engine( void ) |
| { |
| Bit.rows = bit.rows; |
| Bit.width = bit.width; |
| Bit.pitch = bit.pitch; |
| Bit.buffer = bit.buffer; |
| Bit.pixel_mode = antialias ? ft_pixel_mode_grays : ft_pixel_mode_mono; |
| Bit.num_grays = bit.grays; |
| Clear_Buffer(); |
| } |
| |
| |
| /*******************************************************************/ |
| /* */ |
| /* Clear_Buffer: */ |
| /* */ |
| /* Clears current bitmap. */ |
| /* */ |
| /*******************************************************************/ |
| |
| static void Clear_Buffer( void ) |
| { |
| long size = Bit.rows * Bit.pitch; |
| |
| memset( Bit.buffer, 0, size ); |
| } |
| |
| |
| /*******************************************************************/ |
| /* */ |
| /* LoadTrueTypeChar: */ |
| /* */ |
| /* Loads a glyph into memory. */ |
| /* */ |
| /*******************************************************************/ |
| |
| FT_Error LoadChar( int idx ) |
| { |
| error = FT_Load_Glyph( face, idx, FT_LOAD_DEFAULT ); |
| if ( error ) |
| return error; |
| |
| glyph->outline.flags |= ft_outline_single_pass | |
| ft_outline_ignore_dropouts; |
| |
| if (force_low) |
| glyph->outline.flags &= ~ft_outline_high_precision; |
| |
| /* debugging */ |
| #if 0 |
| if ( idx == 0 && !visual ) |
| { |
| printf( "points = %d\n", outline.points ); |
| for ( j = 0; j < outline.points; j++ ) |
| printf( "%02x (%01hx,%01hx)\n", |
| j, outline.xCoord[j], outline.yCoord[j] ); |
| printf( "\n" ); |
| } |
| #endif |
| |
| /* create a new outline */ |
| FT_Outline_New( library, |
| glyph->outline.n_points, |
| glyph->outline.n_contours, |
| &outlines[cur_glyph] ); |
| |
| /* copy the glyph outline into it */ |
| glyph->outline.flags |= ft_outline_single_pass; |
| if (force_low) |
| glyph->outline.flags &= ~ft_outline_high_precision; |
| |
| FT_Outline_Copy( &glyph->outline, &outlines[cur_glyph] ); |
| |
| /* center outline around 0 */ |
| { |
| FT_BBox bbox; |
| |
| FT_Outline_Get_CBox( &glyph->outline, &bbox ); |
| FT_Outline_Translate( &outlines[cur_glyph], |
| - ( bbox.xMax - bbox.xMin )/2, |
| - ( bbox.yMax - bbox.yMin )/2 ); |
| } |
| /* translate it */ |
| FT_Outline_Translate( &outlines[cur_glyph], |
| Bit.width * 32 , |
| Bit.rows * 32 ); |
| cur_glyph++; |
| |
| return FT_Err_Ok; |
| } |
| |
| |
| /*******************************************************************/ |
| /* */ |
| /* ConvertRaster: */ |
| /* */ |
| /* Performs scan conversion. */ |
| /* */ |
| /*******************************************************************/ |
| |
| FT_Error ConvertRaster( int index ) |
| { |
| outlines[index].flags |= ~ft_outline_single_pass; |
| return FT_Outline_Get_Bitmap( library, &outlines[index], &Bit ); |
| } |
| |
| |
| static void Usage() |
| { |
| fprintf( stderr, "fttimer: simple performance timer -- part of the FreeType project\n" ); |
| fprintf( stderr, "-----------------------------------------------------------------\n\n" ); |
| fprintf( stderr, "Usage: fttimer [options] fontname[.ttf|.ttc]\n\n" ); |
| fprintf( stderr, "options:\n"); |
| fprintf( stderr, " -r : repeat count to be used (default is 1)\n" ); |
| fprintf( stderr, " -s : character pixel size (default is 600)\n" ); |
| fprintf( stderr, " -v : display results..\n" ); |
| fprintf( stderr, " -g : render anti-aliased glyphs\n" ); |
| fprintf( stderr, " -a : use smooth anti-aliaser\n" ); |
| fprintf( stderr, " -l : force low quality even at small sizes\n" ); |
| exit(1); |
| } |
| |
| |
| int main( int argc, char** argv ) |
| { |
| int i, total, base, rendered_glyphs; |
| char filename[128 + 4]; |
| char alt_filename[128 + 4]; |
| char* execname; |
| grSurface* surface = 0; |
| |
| long t, t0, tz0; |
| |
| |
| execname = argv[0]; |
| |
| antialias = 0; |
| visual = 0; |
| force_low = 0; |
| |
| while ( argc > 1 && argv[1][0] == '-' ) |
| { |
| switch ( argv[1][1] ) |
| { |
| case 'g': |
| antialias = 1; |
| break; |
| |
| case 'a': |
| use_grays = 1; |
| break; |
| |
| case 'l': |
| force_low = 1; |
| break; |
| |
| case 'v': |
| visual = 1; |
| break; |
| |
| case 's': |
| argc--; |
| argv++; |
| if ( argc < 2 || |
| sscanf( argv[1], "%d", &pixel_size ) != 1 ) |
| Usage(); |
| break; |
| |
| case 'r': |
| argc--; |
| argv++; |
| if ( argc < 2 || |
| sscanf( argv[1], "%d", &repeat_count ) != 1 ) |
| Usage(); |
| if (repeat_count < 1) |
| repeat_count = 1; |
| break; |
| |
| default: |
| fprintf( stderr, "Unknown argument '%s'!\n", argv[1] ); |
| Usage(); |
| } |
| argc--; |
| argv++; |
| } |
| |
| if ( argc != 2 ) |
| Usage(); |
| |
| i = strlen( argv[1] ); |
| while ( i > 0 && argv[1][i] != '\\' ) |
| { |
| if ( argv[1][i] == '.' ) |
| i = 0; |
| i--; |
| } |
| |
| filename[128] = '\0'; |
| alt_filename[128] = '\0'; |
| |
| strncpy( filename, argv[1], 128 ); |
| strncpy( alt_filename, argv[1], 128 ); |
| |
| if ( i >= 0 ) |
| { |
| strncpy( filename + strlen( filename ), ".ttf", 4 ); |
| strncpy( alt_filename + strlen( alt_filename ), ".ttc", 4 ); |
| } |
| |
| /* Initialize engine */ |
| |
| if ( (error = FT_Init_FreeType( &library )) ) |
| Panic( "Error while initializing engine" ); |
| |
| /* set-up smooth anti-aliaser */ |
| if (use_grays) |
| { |
| error = FT_Set_Raster( library, &ft_grays_raster ); |
| if (error) Panic( "Could not initialize smooth anti-aliasing renderer" ); |
| } |
| |
| /* Load face */ |
| |
| error = FT_New_Face( library, filename, 0, &face ); |
| if ( error == FT_Err_Cannot_Open_Stream ) |
| Panic( "Could not find/open font resource" ); |
| else if ( error ) |
| Panic( "Error while opening font resource" ); |
| |
| /* get face properties and allocate preload arrays */ |
| |
| num_glyphs = face->num_glyphs; |
| glyph = face->glyph; |
| |
| tab_glyphs = MAX_GLYPHS; |
| if ( tab_glyphs > num_glyphs ) |
| tab_glyphs = num_glyphs; |
| |
| /* create size */ |
| |
| error = FT_Set_Pixel_Sizes( face, pixel_size, pixel_size ); |
| if ( error ) Panic( "Could not reset instance" ); |
| |
| bit.mode = antialias ? gr_pixel_mode_gray : gr_pixel_mode_mono; |
| bit.width = 640; |
| bit.rows = 480; |
| bit.grays = 128; |
| |
| if ( visual ) |
| { |
| if ( !grInitDevices() ) |
| Panic( "Could not initialize graphics.\n" ); |
| |
| surface = grNewSurface( 0, &bit ); |
| if (!surface) |
| Panic( "Could not open graphics window/screen.\n" ); |
| } |
| else |
| { |
| if ( grNewBitmap( bit.mode, |
| bit.grays, |
| bit.width, |
| bit.rows, |
| &bit ) ) |
| Panic( "Could not create rendering buffer.\n" ); |
| } |
| |
| Init_Engine(); |
| |
| Num = 0; |
| Fail = 0; |
| |
| total = num_glyphs; |
| base = 0; |
| |
| rendered_glyphs = 0; |
| |
| t0 = 0; /* Initial time */ |
| |
| tz0 = Get_Time(); |
| |
| while ( total > 0 ) |
| { |
| int repeat; |
| |
| /* First, preload 'tab_glyphs' in memory */ |
| cur_glyph = 0; |
| cur_point = 0; |
| cur_contour = 0; |
| |
| printf( "loading %d glyphs", tab_glyphs ); |
| |
| for ( Num = 0; Num < tab_glyphs; Num++ ) |
| { |
| error = LoadChar( base + Num ); |
| if ( error ) |
| Fail++; |
| |
| total--; |
| } |
| |
| base += tab_glyphs; |
| |
| if ( tab_glyphs > total ) |
| tab_glyphs = total; |
| |
| printf( ", rendering... " ); |
| |
| /* Now, render the loaded glyphs */ |
| |
| t = Get_Time(); |
| |
| for ( repeat = 0; repeat < repeat_count; repeat++ ) |
| { |
| for ( Num = 0; Num < cur_glyph; Num++ ) |
| { |
| if ( (error = ConvertRaster( Num )) ) |
| Fail++; |
| |
| else |
| { |
| rendered_glyphs ++; |
| |
| if ( Num == 0 && visual ) |
| { |
| sprintf( Header, "Glyph: %5d", Num ); |
| grSetTitle( surface, Header ); |
| grRefreshSurface( surface ); |
| Clear_Buffer(); |
| } |
| } |
| } |
| } |
| |
| t = Get_Time() - t; |
| if ( t < 0 ) |
| t += 1000 * 60 * 60; |
| |
| printf( " = %f s\n", (double)t / 10000 ); |
| t0 += t; |
| |
| /* Now free all loaded outlines */ |
| for ( Num = 0; Num < cur_glyph; Num++ ) |
| FT_Outline_Done( library, &outlines[Num] ); |
| } |
| |
| tz0 = Get_Time() - tz0; |
| |
| FT_Done_Face( face ); |
| |
| printf( "\n" ); |
| printf( "rendered glyphs = %d\n", rendered_glyphs ); |
| printf( "render time = %f s\n", (double)t0 / 10000 ); |
| printf( "fails = %d\n", Fail ); |
| printf( "average glyphs/s = %f\n", |
| (double)rendered_glyphs / t0 * 10000 ); |
| |
| printf( "total timing = %f s\n", (double)tz0 / 10000 ); |
| printf( "Fails = %d\n", Fail ); |
| |
| FT_Done_FreeType( library ); |
| |
| exit( 0 ); /* for safety reasons */ |
| |
| return 0; /* never reached */ |
| } |
| |
| |
| /* End */ |
