minhngoc25a
/
freetype2
mirror of git://git.savannah.gnu.org/freetype/freetype2.git
2
1
Fork 2
Code Issues 4 Releases Wiki Activity

* src/pfr/pfrload.c (pfr_extra_items_farse): Fix debug message. 

(pfr_phy_font_load): s/size/Size/ for local variable to avoid
compiler warning.
* src/pfr/pfrobjs.c (pfr_face_init): Fix debug message.
(pfr_slot_load): Remove redundant local variable.

adding copyrights, formatting
This commit is contained in:
Werner Lemberg 2002-04-20 05:38:33 +00:00
parent 609e28c3be
commit fadb6be7e3
16 changed files with 887 additions and 624 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
ChangeLog
View File

@ -1,23 +1,31 @@
2002-04-19 Werner Lemberg <wl@gnu.org>
* src/pfr/pfrload.c (pfr_extra_items_farse): Fix debug message.
(pfr_phy_font_load): s/size/Size/ for local variable to avoid
compiler warning.
* src/pfr/pfrobjs.c (pfr_face_init): Fix debug message.
(pfr_slot_load): Remove redundant local variable.
2002-04-19 David Turner <david@freetype.org>
* src/type1/t1gload.h, src/type1/t1gload.c: fixed incorrect
parameter sign-ness in callback function
Adding a PFR font driver to the FreeType sources. Note that it
doesn't support embedded bitmaps or kerning tables yet.
* include/freetype/config/ftmodule.h,
include/freetype/internal/fttrace.h,
src/Jamfile, src/pfr/*:
adding a PFR font driver to the FreeType sources. Not that it
doesn't support embedded bitmaps or kerning tables for now..
src/pfr/*: New files.
* include/freetype/config/ftmodule.h,
include/freetype/internal/fttrace.h, src/Jamefile: Updated.
* include/freetype/internal/ftmemory.h: adding the FT_MEM_ZERO
and FT_ZERO macros
* src/type1/t1gload.h (T1_Load_Glyph), src/type1/t1gload.c
(T1_Load_Glyph): Fixed incorrect parameter sign-ness in callback
function.
* include/freetype/internal/ftstream.h: adding the FT_NEXT_OFF3,
FT_NEXT_UOFF3, FT_NEXT_OFF3_LE and FT_NEXT_UOFF3_LE to parse
in-memory 24-bit integers.
* include/freetype/internal/ftmemory.h (FT_MEM_ZERO, FT_ZERO): New
macros.
* include/freetype/internal/ftstream.h (FT_NEXT_OFF3, FT_NEXT_UOFF3,
FT_NEXT_OFF3_LE, FT_NEXT_UOFF3_LE): New macros to parse in-memory
24-bit integers.
2002-04-18 David Turner <david@freetype.org>

6
include/freetype/internal/ftmemory.h
View File

@ -178,9 +178,11 @@ FT_BEGIN_HEADER
#define FT_MEM_MOVE( dest, source, count ) ft_memmove( dest, source, count )
#define FT_MEM_ZERO( dest, count ) FT_MEM_SET( dest, 0, count )
#define FT_ZERO(p) FT_MEM_ZERO( p, sizeof(*(p)) )
#define FT_MEM_ZERO( dest, count ) FT_MEM_SET( dest, 0, count )
#define FT_ZERO( p ) FT_MEM_ZERO( p, sizeof ( *(p) ) )
/*************************************************************************/
/* */

2
src/pfr/descrip.mms
View File

@ -3,7 +3,7 @@
#
# Copyright 1996-2002 by
# Copyright 2002 by
# David Turner, Robert Wilhelm, and Werner Lemberg.
#
# This file is part of the FreeType project, and may only be used, modified,

2
src/pfr/module.mk
View File

@ -3,7 +3,7 @@
#
# Copyright 1996-2002 by
# Copyright 2002 by
# David Turner, Robert Wilhelm, and Werner Lemberg.
#
# This file is part of the FreeType project, and may only be used, modified,

4
src/pfr/pfr.c
View File

@ -2,9 +2,9 @@
/* */
/* pfr.c */
/* */
/* FreeType PFR driver component */
/* FreeType PFR driver component. */
/* */
/* Copyright 1996-2002 by */
/* Copyright 2002 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */

43
src/pfr/pfrcmap.c
View File

@ -1,25 +1,45 @@
/***************************************************************************/
/* */
/* pfrcmap.c */
/* */
/* FreeType PFR cmap handling (body). */
/* */
/* Copyright 2002 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#include "pfrcmap.h"
#include "pfrobjs.h"
#include FT_INTERNAL_DEBUG_H
FT_CALLBACK_DEF( FT_Error )
pfr_cmap_init( PFR_CMap cmap )
{
PFR_Face face = (PFR_Face)FT_CMAP_FACE(cmap);
PFR_Face face = (PFR_Face)FT_CMAP_FACE( cmap );
cmap->num_chars = face->phy_font.num_chars;
cmap->chars = face->phy_font.chars;
/* just for safety, check that the character entries are correctly */
/* sorted in increasing character code order.. */
/* sorted in increasing character code order */
{
FT_UInt n;
for ( n = 1; n < cmap->num_chars; n++ )
{
if ( cmap->chars[n-1].char_code >= cmap->chars[n].char_code )
FT_ASSERT(0);
if ( cmap->chars[n - 1].char_code >= cmap->chars[n].char_code )
FT_ASSERT( 0 );
}
}
@ -63,8 +83,8 @@
FT_CALLBACK_DEF( FT_UInt )
pfr_cmap_char_next( PFR_CMap cmap,
FT_UInt32 *pchar_code )
pfr_cmap_char_next( PFR_CMap cmap,
FT_UInt32 *pchar_code )
{
FT_UInt result = 0;
FT_UInt32 char_code = *pchar_code + 1;
@ -122,8 +142,11 @@
{
sizeof ( PFR_CMapRec ),
(FT_CMap_InitFunc) pfr_cmap_init,
(FT_CMap_DoneFunc) pfr_cmap_done,
(FT_CMap_CharIndexFunc) pfr_cmap_char_index,
(FT_CMap_CharNextFunc) pfr_cmap_char_next
(FT_CMap_InitFunc) pfr_cmap_init,
(FT_CMap_DoneFunc) pfr_cmap_done,
(FT_CMap_CharIndexFunc)pfr_cmap_char_index,
(FT_CMap_CharNextFunc) pfr_cmap_char_next
};
/* END */

33
src/pfr/pfrcmap.h
View File

@ -1,13 +1,32 @@
#ifndef __PFR_CMAP_H__
#define __PFR_CMAP_H__
/***************************************************************************/
/* */
/* pfrcmap.h */
/* */
/* FreeType PFR cmap handling (specification). */
/* */
/* Copyright 2002 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#ifndef __PFRCMAP_H__
#define __PFRCMAP_H__
#include <ft2build.h>
#include FT_INTERNAL_OBJECTS_H
#include "pfrtypes.h"
FT_BEGIN_HEADER
typedef struct PFR_CMapRec_
typedef struct PFR_CMapRec_
{
FT_CMapRec cmap;
FT_UInt num_chars;
@ -16,8 +35,12 @@ FT_BEGIN_HEADER
} PFR_CMapRec, *PFR_CMap;
FT_CALLBACK_TABLE const FT_CMap_ClassRec pfr_cmap_class_rec;
FT_CALLBACK_TABLE const FT_CMap_ClassRec pfr_cmap_class_rec;
FT_END_HEADER
#endif /* __PFR_CMAP_H__ */
#endif /* __PFRCMAP_H__ */
/* END */

54
src/pfr/pfrdrivr.c
View File

@ -1,3 +1,21 @@
/***************************************************************************/
/* */
/* pfrdrivr.c */
/* */
/* FreeType PFR driver interface (body). */
/* */
/* Copyright 2002 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#include <ft2build.h>
#include FT_INTERNAL_DEBUG_H
#include FT_INTERNAL_STREAM_H
@ -20,33 +38,33 @@
0, /* format interface */
(FT_Module_Constructor) NULL,
(FT_Module_Destructor) NULL,
(FT_Module_Requester) NULL
(FT_Module_Constructor)NULL,
(FT_Module_Destructor) NULL,
(FT_Module_Requester) NULL
},
sizeof( PFR_FaceRec ),
sizeof( PFR_SizeRec ),
sizeof( PFR_SlotRec ),
(FT_Face_InitFunc) pfr_face_init,
(FT_Face_DoneFunc) pfr_face_done,
(FT_Size_InitFunc) NULL,
(FT_Size_DoneFunc) NULL,
(FT_Slot_InitFunc) pfr_slot_init,
(FT_Slot_DoneFunc) pfr_slot_done,
(FT_Face_InitFunc) pfr_face_init,
(FT_Face_DoneFunc) pfr_face_done,
(FT_Size_InitFunc) NULL,
(FT_Size_DoneFunc) NULL,
(FT_Slot_InitFunc) pfr_slot_init,
(FT_Slot_DoneFunc) pfr_slot_done,
(FT_Size_ResetPointsFunc) NULL,
(FT_Size_ResetPixelsFunc) NULL,
(FT_Slot_LoadFunc) pfr_slot_load,
(FT_CharMap_CharIndexFunc) NULL,
(FT_Size_ResetPointsFunc) NULL,
(FT_Size_ResetPixelsFunc) NULL,
(FT_Slot_LoadFunc) pfr_slot_load,
(FT_CharMap_CharIndexFunc)NULL,
(FT_Face_GetKerningFunc) 0,
(FT_Face_AttachFunc) 0,
(FT_Face_GetAdvancesFunc) 0,
(FT_Face_GetKerningFunc) 0,
(FT_Face_AttachFunc) 0,
(FT_Face_GetAdvancesFunc) 0,
(FT_CharMap_CharNextFunc) NULL
(FT_CharMap_CharNextFunc) NULL
};
/* END */

11
src/pfr/pfrdrivr.h
View File

@ -2,9 +2,9 @@
/* */
/* pfrdrivr.h */
/* */
/* High-level Type PFR driver interface */
/* High-level Type PFR driver interface (specification). */
/* */
/* Copyright 1996-2002 by */
/* Copyright 2002 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -16,8 +16,8 @@
/***************************************************************************/
#ifndef __PFR_DRIVER_H__
#define __PFR_DRIVER_H__
#ifndef __PFRDRIVR_H__
#define __PFRDRIVR_H__
#include <ft2build.h>
@ -32,7 +32,8 @@ FT_BEGIN_HEADER
FT_END_HEADER
#endif /* __PFR_DRIVER_H__ */
#endif /* __PFRDRIVR_H__ */
/* END */

494
src/pfr/pfrgload.c
View File

@ -1,17 +1,36 @@
/***************************************************************************/
/* */
/* pfrgload.c */
/* */
/* FreeType PFR glyph loader (body). */
/* */
/* Copyright 2002 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#include "pfrgload.h"
#include "pfrload.h" /* for macro definitions */
#include "pfrload.h" /* for macro definitions */
#include FT_INTERNAL_DEBUG_H
#undef FT_COMPONENT
#define FT_COMPONENT trace_pfr
/**************************************************************************/
/**************************************************************************/
/***** *****/
/***** PFR GLYPH BUILDER *****/
/***** *****/
/**************************************************************************/
/**************************************************************************/
/*************************************************************************/
/*************************************************************************/
/***** *****/
/***** PFR GLYPH BUILDER *****/
/***** *****/
/*************************************************************************/
/*************************************************************************/
FT_LOCAL_DEF( void )
@ -32,6 +51,7 @@
{
FT_Memory memory = glyph->loader->memory;
FT_FREE( glyph->x_control );
glyph->y_control = NULL;
@ -49,7 +69,7 @@
}
/* close current contour, if any */
/* close current contour, if any */
static void
pfr_glyph_close_contour( PFR_Glyph glyph )
{
@ -57,6 +77,7 @@
FT_Outline* outline = &loader->current.outline;
FT_Int last, first;
if ( !glyph->path_begun )
return;
@ -64,7 +85,7 @@
last = outline->n_points - 1;
first = 0;
if ( outline->n_contours > 0 )
first = outline->contours[ outline->n_contours-1 ];
first = outline->contours[outline->n_contours - 1];
/* if the last point falls on the same location than the first one */
/* we need to delete it */
@ -73,6 +94,7 @@
FT_Vector* p1 = outline->points + first;
FT_Vector* p2 = outline->points + last;
if ( p1->x == p2->x && p1->y == p2->y )
{
outline->n_points--;
@ -82,14 +104,13 @@
/* don't add empty contours */
if ( last >= first )
outline->contours[ outline->n_contours++ ] = (short) last;
outline->contours[outline->n_contours++] = (short)last;
glyph->path_begun = 0;
}
/* reset glyph to start the loading of a new glyph */
/* reset glyph to start the loading of a new glyph */
static void
pfr_glyph_start( PFR_Glyph glyph )
{
@ -105,7 +126,8 @@
FT_Outline* outline = &loader->current.outline;
FT_Error error;
/* check that we've begun a new path */
/* check that we have begun a new path */
FT_ASSERT( glyph->path_begun != 0 );
error = FT_GlyphLoader_CheckPoints( loader, 1, 0 );
@ -113,6 +135,7 @@
{
FT_UInt n = outline->n_points;
outline->points[n] = *to;
outline->tags [n] = FT_Curve_Tag_On;
@ -133,14 +156,16 @@
FT_Outline* outline = &loader->current.outline;
FT_Error error;
/* check that we've begun a new path */
/* check that we have begun a new path */
FT_ASSERT( glyph->path_begun != 0 );
error = FT_GlyphLoader_CheckPoints( loader, 3, 0 );
if ( !error )
{
FT_Vector* vec = outline->points + outline->n_points;
FT_Byte* tag = (FT_Byte*)outline->tags + outline->n_points;
FT_Vector* vec = outline->points + outline->n_points;
FT_Byte* tag = (FT_Byte*)outline->tags + outline->n_points;
vec[0] = *control1;
vec[1] = *control2;
@ -163,6 +188,7 @@
FT_GlyphLoader loader = glyph->loader;
FT_Error error;
/* close current contour if any */
pfr_glyph_close_contour( glyph );
@ -179,7 +205,6 @@
}
static void
pfr_glyph_end( PFR_Glyph glyph )
{
@ -191,54 +216,55 @@
}
/**************************************************************************/
/**************************************************************************/
/***** *****/
/***** PFR GLYPH LOADER *****/
/***** *****/
/**************************************************************************/
/**************************************************************************/
/*************************************************************************/
/*************************************************************************/
/***** *****/
/***** PFR GLYPH LOADER *****/
/***** *****/
/*************************************************************************/
/*************************************************************************/
/* Load a simple glyph */
/* load a simple glyph */
static FT_Error
pfr_glyph_load_simple( PFR_Glyph glyph,
FT_Byte* p,
FT_Byte* limit )
{
FT_Error error = 0;
FT_Error error = 0;
FT_Memory memory = glyph->loader->memory;
FT_UInt flags, x_count, y_count, i, count, mask;
FT_Int x;
PFR_CHECK(1);
flags = PFR_NEXT_BYTE(p);
PFR_CHECK( 1 );
flags = PFR_NEXT_BYTE( p );
/* test for composite glyphs */
FT_ASSERT( (flags & PFR_GLYPH_IS_COMPOUND) == 0 );
FT_ASSERT( ( flags & PFR_GLYPH_IS_COMPOUND ) == 0 );
x_count = 0;
y_count = 0;
if ( flags & PFR_GLYPH_1BYTE_XYCOUNT )
{
PFR_CHECK(1);
count = PFR_NEXT_BYTE(p);
x_count = (count & 15);
y_count = (count >> 4);
PFR_CHECK( 1 );
count = PFR_NEXT_BYTE( p );
x_count = ( count & 15 );
y_count = ( count >> 4 );
}
else
{
if ( flags & PFR_GLYPH_XCOUNT )
{
PFR_CHECK(1);
x_count = PFR_NEXT_BYTE(p);
PFR_CHECK( 1 );
x_count = PFR_NEXT_BYTE( p );
}
if ( flags & PFR_GLYPH_YCOUNT )
{
PFR_CHECK(1);
y_count = PFR_NEXT_BYTE(p);
PFR_CHECK( 1 );
y_count = PFR_NEXT_BYTE( p );
}
}
@ -247,9 +273,12 @@
/* re-allocate array when necessary */
if ( count > glyph->max_xy_control )
{
FT_UInt new_max = (count+7) & -8;
FT_UInt new_max = ( count + 7 ) & -8;
if ( FT_RENEW_ARRAY( glyph->x_control, glyph->max_xy_control, new_max ) )
if ( FT_RENEW_ARRAY( glyph->x_control,
glyph->max_xy_control,
new_max ) )
goto Exit;
glyph->max_xy_control = new_max;
@ -259,23 +288,24 @@
mask = 0;
x = 0;
for ( i = 0; i < count; i++ )
{
if ( (i & 7) == 0 )
if ( ( i & 7 ) == 0 )
{
PFR_CHECK(1);
mask = PFR_NEXT_BYTE(p);
PFR_CHECK( 1 );
mask = PFR_NEXT_BYTE( p );
}
if ( mask & 1 )
{
PFR_CHECK(2);
x = PFR_NEXT_SHORT(p);
PFR_CHECK( 2 );
x = PFR_NEXT_SHORT( p );
}
else
{
PFR_CHECK(1);
x += PFR_NEXT_BYTE(p);
PFR_CHECK( 1 );
x += PFR_NEXT_BYTE( p );
}
glyph->x_control[i] = x;
@ -283,16 +313,16 @@
mask >>= 1;
}
/* XXXX: for now we ignore the secondary stroke and edge definitions */
/* since we don't want to support native PFR hinting.. */
/* */
/* XXX: for now we ignore the secondary stroke and edge definitions */
/* since we don't want to support native PFR hinting */
/* */
if ( flags & PFR_GLYPH_EXTRA_ITEMS )
{
error = pfr_extra_items_skip( &p, limit );
if (error) goto Exit;
if ( error )
goto Exit;
}
pfr_glyph_start( glyph );
/* now load a simple glyph */
@ -300,6 +330,7 @@
FT_Vector pos[4];
FT_Vector* cur;
pos[0].x = pos[0].y = 0;
pos[3] = pos[0];
@ -307,65 +338,67 @@
{
FT_Int format, args_format = 0, args_count, n;
/***************************************************************/
/* read instruction */
/* */
PFR_CHECK(1);
format = PFR_NEXT_BYTE(p);
switch (format >> 4)
PFR_CHECK( 1 );
format = PFR_NEXT_BYTE( p );
switch ( format >> 4 )
{
case 0: /* end glyph */
FT_TRACE6(( "- end glyph" ));
args_count = 0;
break;
case 0: /* end glyph */
FT_TRACE6(( "- end glyph" ));
args_count = 0;
break;
case 1: /* general line operation */
FT_TRACE6(( "- general line" ));
goto Line1;
case 1: /* general line operation */
FT_TRACE6(( "- general line" ));
goto Line1;
case 4: /* move to inside contour */
FT_TRACE6(( "- move to inside" ));
goto Line1;
case 4: /* move to inside contour */
FT_TRACE6(( "- move to inside" ));
goto Line1;
case 5: /* move to outside contour */
FT_TRACE6(( "- move to outside" ));
Line1:
args_format = format & 15;
args_count = 1;
break;
case 5: /* move to outside contour */
FT_TRACE6(( "- move to outside" ));
Line1:
args_format = format & 15;
args_count = 1;
break;
case 2: /* horizontal line to */
FT_TRACE6(( "- horizontal line to cx.%d", format & 15 ));
pos[0].y = pos[3].y;
pos[0].x = glyph->x_control[ format & 15 ];
pos[3] = pos[0];
args_count = 0;
break;
case 2: /* horizontal line to */
FT_TRACE6(( "- horizontal line to cx.%d", format & 15 ));
pos[0].y = pos[3].y;
pos[0].x = glyph->x_control[format & 15];
pos[3] = pos[0];
args_count = 0;
break;
case 3: /* vertical line to */
FT_TRACE6(( "- vertical line to cy.%d", format & 15 ));
pos[0].x = pos[3].x;
pos[0].y = glyph->y_control[ format & 15 ];
pos[3] = pos[0];
args_count = 0;
break;
case 3: /* vertical line to */
FT_TRACE6(( "- vertical line to cy.%d", format & 15 ));
pos[0].x = pos[3].x;
pos[0].y = glyph->y_control[format & 15];
pos[3] = pos[0];
args_count = 0;
break;
case 6: /* horizontal to vertical curve */
FT_TRACE6(( "- hv curve " ));
args_format = 0xB8E;
args_count = 3;
break;
case 6: /* horizontal to vertical curve */
FT_TRACE6(( "- hv curve " ));
args_format = 0xB8E;
args_count = 3;
break;
case 7: /* vertical to horizontal curve */
FT_TRACE6(( "- vh curve" ));
args_format = 0xE2B;
args_count = 3;
break;
case 7: /* vertical to horizontal curve */
FT_TRACE6(( "- vh curve" ));
args_format = 0xE2B;
args_count = 3;
break;
default: /* general curve to */
FT_TRACE6(( "- general curve" ));
args_count = 4;
args_format = (format & 15);
default: /* general curve to */
FT_TRACE6(( "- general curve" ));
args_count = 4;
args_format = format & 15;
}
/***********************************************************/
@ -376,67 +409,68 @@
{
FT_Int index, delta;
/* read the X argument */
switch ( args_format & 3 )
{
case 0: /* 8-bit index */
PFR_CHECK(1);
index = PFR_NEXT_BYTE(p);
cur->x = glyph->x_control[index];
FT_TRACE7(( " cx#%d", index ));
break;
case 0: /* 8-bit index */
PFR_CHECK( 1 );
index = PFR_NEXT_BYTE( p );
cur->x = glyph->x_control[index];
FT_TRACE7(( " cx#%d", index ));
break;
case 1: /* 16-bit value */
PFR_CHECK(2);
cur->x = PFR_NEXT_SHORT(p);
FT_TRACE7(( " x.%d", cur->x ));
break;
case 1: /* 16-bit value */
PFR_CHECK( 2 );
cur->x = PFR_NEXT_SHORT( p );
FT_TRACE7(( " x.%d", cur->x ));
break;
case 2: /* 8-bit delta */
PFR_CHECK(1);
delta = PFR_NEXT_INT8(p);
cur->x = pos[3].x + delta;
FT_TRACE7(( " dx.%d", delta ));
break;
case 2: /* 8-bit delta */
PFR_CHECK( 1 );
delta = PFR_NEXT_INT8( p );
cur->x = pos[3].x + delta;
FT_TRACE7(( " dx.%d", delta ));
break;
default:
FT_TRACE7(( " |" ));
cur->x = pos[3].x;
default:
FT_TRACE7(( " |" ));
cur->x = pos[3].x;
}
/* read the Y argument */
switch ( (args_format >> 2) & 3 )
switch ( ( args_format >> 2 ) & 3 )
{
case 0: /* 8-bit index */
PFR_CHECK(1);
index = PFR_NEXT_BYTE(p);
cur->y = glyph->y_control[index];
FT_TRACE7(( " cy#%d", index ));
break;
case 0: /* 8-bit index */
PFR_CHECK( 1 );
index = PFR_NEXT_BYTE( p );
cur->y = glyph->y_control[index];
FT_TRACE7(( " cy#%d", index ));
break;
case 1: /* 16-bit absolute value */
PFR_CHECK(2);
cur->y = PFR_NEXT_SHORT(p);
FT_TRACE7(( " y.%d", cur->y ));
break;
case 1: /* 16-bit absolute value */
PFR_CHECK( 2 );
cur->y = PFR_NEXT_SHORT( p );
FT_TRACE7(( " y.%d", cur->y ));
break;
case 2: /* 8-bit delta */
PFR_CHECK(1);
delta = PFR_NEXT_INT8(p);
cur->y = pos[3].y + delta;
FT_TRACE7(( " dy.%d", delta ));
break;
case 2: /* 8-bit delta */
PFR_CHECK( 1 );
delta = PFR_NEXT_INT8( p );
cur->y = pos[3].y + delta;
FT_TRACE7(( " dy.%d", delta ));
break;
default:
FT_TRACE7(( " -" ));
cur->y = pos[3].y;
default:
FT_TRACE7(( " -" ));
cur->y = pos[3].y;
}
/* read the additional format flag for the general curve */
if ( n == 0 && args_count == 4 )
{
PFR_CHECK(1);
args_format = PFR_NEXT_BYTE(p);
PFR_CHECK( 1 );
args_format = PFR_NEXT_BYTE( p );
args_count--;
}
else
@ -452,29 +486,29 @@
/***********************************************************/
/* finally, execute instruction */
/* */
switch (format >> 4)
switch ( format >> 4 )
{
case 0: /* end glyph => EXIT */
pfr_glyph_end( glyph );
case 0: /* end glyph => EXIT */
pfr_glyph_end( glyph );
goto Exit;
case 1: /* line operations */
case 2:
case 3:
error = pfr_glyph_line_to( glyph, pos );
goto Test_Error;
case 4: /* move to inside contour */
case 5: /* move to outside contour */
error = pfr_glyph_move_to( glyph, pos );
goto Test_Error;
default: /* curve operations */
error = pfr_glyph_curve_to( glyph, pos, pos + 1, pos + 2 );
Test_Error: /* test error condition */
if ( error )
goto Exit;
case 1: /* line operations */
case 2:
case 3:
error = pfr_glyph_line_to( glyph, pos );
goto Test_Error;
case 4: /* move to inside contour */
case 5: /* move to outside contour */
error = pfr_glyph_move_to( glyph, pos );
goto Test_Error;
default: /* curve operations */
error = pfr_glyph_curve_to( glyph, pos, pos+1, pos+2 );
Test_Error: /* test error condition */
if (error)
goto Exit;
}
} /* for (;;) */
}
@ -489,9 +523,7 @@
}
/* load a composite/compound glyph */
/* load a composite/compound glyph */
static FT_Error
pfr_glyph_load_compound( PFR_Glyph glyph,
FT_Byte* p,
@ -504,11 +536,12 @@
FT_UInt flags, i, count, org_count;
FT_Int x_pos, y_pos;
PFR_CHECK(1);
flags = PFR_NEXT_BYTE(p);
PFR_CHECK( 1 );
flags = PFR_NEXT_BYTE( p );
/* test for composite glyphs */
FT_ASSERT( (flags & PFR_GLYPH_IS_COMPOUND) != 0 );
FT_ASSERT( ( flags & PFR_GLYPH_IS_COMPOUND ) != 0 );
count = flags & 0x3F;
@ -521,12 +554,12 @@
}
/* we can't rely on the FT_GlyphLoader to load sub-glyphs, because */
/* the PFR format is so damn stupid that it uses direct file offsets */
/* to point to the sub-glyphs (instead of glyph indices).. */
/* the PFR format is dumb, using direct file offsets to point to the */
/* sub-glyphs (instead of glyph indices). Sigh. */
/* */
/* for now, we'll load the list of sub-glyphs in a different array */
/* For now, we load the list of sub-glyphs into a different array */
/* but this will prevent us from using the auto-hinter at its best */
/* quality.. */
/* quality. */
/* */
org_count = glyph->num_subs;
@ -534,6 +567,7 @@
{
FT_UInt new_max = ( org_count + count + 3 ) & -4;
if ( FT_RENEW_ARRAY( glyph->subs, glyph->max_subs, new_max ) )
goto Exit;
@ -548,55 +582,56 @@
{
FT_UInt format;
PFR_CHECK(1);
format = PFR_NEXT_BYTE(p);
PFR_CHECK( 1 );
format = PFR_NEXT_BYTE( p );
/* read scale when available */
subglyph->x_scale = 0x10000L;
if ( format & PFR_SUBGLYPH_XSCALE )
{
PFR_CHECK(2);
subglyph->x_scale = PFR_NEXT_SHORT(p) << 4;
PFR_CHECK( 2 );
subglyph->x_scale = PFR_NEXT_SHORT( p ) << 4;
}
subglyph->y_scale = 0x10000L;
if ( format & PFR_SUBGLYPH_YSCALE )
{
PFR_CHECK(2);
subglyph->y_scale = PFR_NEXT_SHORT(p) << 4;
PFR_CHECK( 2 );
subglyph->y_scale = PFR_NEXT_SHORT( p ) << 4;
}
/* read offset */
switch ( format & 3 )
{
case 1:
PFR_CHECK(2);
x_pos = PFR_NEXT_SHORT(p);
break;
case 1:
PFR_CHECK( 2 );
x_pos = PFR_NEXT_SHORT( p );
break;
case 2:
PFR_CHECK(1);
x_pos += PFR_NEXT_INT8(p);
break;
case 2:
PFR_CHECK( 1 );
x_pos += PFR_NEXT_INT8( p );
break;
default:
;
default:
;
}
switch ( (format >> 2) & 3 )
switch ( ( format >> 2 ) & 3 )
{
case 1:
PFR_CHECK(2);
y_pos = PFR_NEXT_SHORT(p);
break;
case 1:
PFR_CHECK( 2 );
y_pos = PFR_NEXT_SHORT( p );
break;
case 2:
PFR_CHECK(1);
y_pos += PFR_NEXT_INT8(p);
break;
case 2:
PFR_CHECK( 1 );
y_pos += PFR_NEXT_INT8( p );
break;
default:
;
default:
;
}
subglyph->x_delta = x_pos;
@ -605,30 +640,29 @@
/* read glyph position and size now */
if ( format & PFR_SUBGLYPH_2BYTE_SIZE )
{
PFR_CHECK(2);
subglyph->gps_size = PFR_NEXT_USHORT(p);
PFR_CHECK( 2 );
subglyph->gps_size = PFR_NEXT_USHORT( p );
}
else
{
PFR_CHECK(1);
subglyph->gps_size = PFR_NEXT_BYTE(p);
PFR_CHECK( 1 );
subglyph->gps_size = PFR_NEXT_BYTE( p );
}
if ( format & PFR_SUBGLYPH_3BYTE_OFFSET )
{
PFR_CHECK(3);
subglyph->gps_offset = PFR_NEXT_LONG(p);
PFR_CHECK( 3 );
subglyph->gps_offset = PFR_NEXT_LONG( p );
}
else
{
PFR_CHECK(2);
subglyph->gps_offset = PFR_NEXT_USHORT(p);
PFR_CHECK( 2 );
subglyph->gps_offset = PFR_NEXT_USHORT( p );
}
glyph->num_subs++;
}
Exit:
return error;
@ -639,23 +673,23 @@
}
static FT_Error
pfr_glyph_load_rec( PFR_Glyph glyph,
FT_Stream stream,
FT_ULong gps_offset,
FT_ULong offset,
FT_ULong size )
pfr_glyph_load_rec( PFR_Glyph glyph,
FT_Stream stream,
FT_ULong gps_offset,
FT_ULong offset,
FT_ULong size )
{
FT_Error error;
FT_Byte* p;
FT_Byte* limit;
if ( FT_STREAM_SEEK( gps_offset + offset ) ||
FT_FRAME_ENTER( size ) )
goto Exit;
goto Exit;
p = (FT_Byte*) stream->cursor;
p = (FT_Byte*)stream->cursor;
limit = p + size;
if ( size > 0 && *p & PFR_GLYPH_IS_COMPOUND )
@ -672,7 +706,8 @@
FT_FRAME_EXIT();
if ( error ) goto Exit;
if ( error )
goto Exit;
count = glyph->num_subs - old_count;
@ -687,11 +722,12 @@
old_points = base->n_points;
error = pfr_glyph_load_rec( glyph, stream, gps_offset,
subglyph->gps_offset, subglyph->gps_size );
subglyph->gps_offset,
subglyph->gps_size );
if ( error )
goto Exit;
/* note that the 'glyph->subs' might have been re-allocated */
/* note that `glyph->subs' might have been re-allocated */
subglyph = glyph->subs + old_count + n;
num_points = base->n_points - old_points;
@ -703,8 +739,10 @@
for ( i = 0; i < num_points; i++, vec++ )
{
vec->x = FT_MulFix( vec->x, subglyph->x_scale ) + subglyph->x_delta;
vec->y = FT_MulFix( vec->y, subglyph->y_scale ) + subglyph->y_delta;
vec->x = FT_MulFix( vec->x, subglyph->x_scale ) +
subglyph->x_delta;
vec->y = FT_MulFix( vec->y, subglyph->y_scale ) +
subglyph->y_delta;
}
}
else
@ -736,11 +774,11 @@
FT_LOCAL_DEF( FT_Error )
pfr_glyph_load( PFR_Glyph glyph,
FT_Stream stream,
FT_ULong gps_offset,
FT_ULong offset,
FT_ULong size )
pfr_glyph_load( PFR_Glyph glyph,
FT_Stream stream,
FT_ULong gps_offset,
FT_ULong offset,
FT_ULong size )
{
/* initialize glyph loader */
FT_GlyphLoader_Rewind( glyph->loader );
@ -749,3 +787,5 @@
return pfr_glyph_load_rec( glyph, stream, gps_offset, offset, size );
}
/* END */

25
src/pfr/pfrgload.h
View File

@ -1,10 +1,29 @@
#ifndef __PFR_GLYPH_LOAD_H__
#define __PFR_GLYPH_LOAD_H__
/***************************************************************************/
/* */
/* pfrgload.h */
/* */
/* FreeType PFR glyph loader (specification). */
/* */
/* Copyright 2002 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#ifndef __PFRGLOAD_H__
#define __PFRGLOAD_H__
#include "pfrtypes.h"
FT_BEGIN_HEADER
FT_LOCAL( void )
pfr_glyph_init( PFR_Glyph glyph,
FT_GlyphLoader loader );
@ -24,4 +43,4 @@ FT_BEGIN_HEADER
FT_END_HEADER
#endif /* __PFR_GLYPH_LOAD_H__ */
#endif /* __PFRGLOAD_H__ */

370
src/pfr/pfrload.c
View File

@ -1,3 +1,21 @@
/***************************************************************************/
/* */
/* pfrload.c */
/* */
/* FreeType PFR loader (body). */
/* */
/* Copyright 2002 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#include "pfrload.h"
#include FT_INTERNAL_DEBUG_H
#include FT_INTERNAL_STREAM_H
@ -5,17 +23,19 @@
#undef FT_COMPONENT
#define FT_COMPONENT trace_pfr
/***********************************************************************/
/***********************************************************************/
/***** *****/
/***** EXTRA ITEMS *****/
/***** *****/
/***********************************************************************/
/***********************************************************************/
/*************************************************************************/
/*************************************************************************/
/***** *****/
/***** EXTRA ITEMS *****/
/***** *****/
/*************************************************************************/
/*************************************************************************/
FT_LOCAL_DEF( FT_Error )
pfr_extra_items_skip( FT_Byte* *pp, FT_Byte* limit )
pfr_extra_items_skip( FT_Byte* *pp,
FT_Byte* limit )
{
return pfr_extra_items_parse( pp, limit, NULL, NULL );
}
@ -31,20 +51,23 @@
FT_Byte* p = *pp;
FT_UInt num_items, item_type, item_size;
PFR_CHECK(1);
num_items = PFR_NEXT_BYTE(p);
PFR_CHECK( 1 );
num_items = PFR_NEXT_BYTE( p );
for ( ; num_items > 0; num_items-- )
{
PFR_CHECK(2);
item_size = PFR_NEXT_BYTE(p);
item_type = PFR_NEXT_BYTE(p);
PFR_CHECK( 2 );
item_size = PFR_NEXT_BYTE( p );
item_type = PFR_NEXT_BYTE( p );
PFR_CHECK(item_size);
PFR_CHECK( item_size );
if ( item_list )
{
PFR_ExtraItem extra = item_list;
for ( extra = item_list; extra->parser != NULL; extra++ )
{
if ( extra->type == item_type )
@ -65,62 +88,61 @@
return error;
Too_Short:
FT_ERROR(( "pfr.extra_items.skip: invalid extra items table\n" ));
FT_ERROR(( "pfr_extra_items_parse: invalid extra items table\n" ));
error = FT_Err_Invalid_Table;
goto Exit;
}
/*************************************************************************/
/*************************************************************************/
/***** *****/
/***** PFR HEADER *****/
/***** *****/
/*************************************************************************/
/*************************************************************************/
/***********************************************************************/
/***********************************************************************/
/***** *****/
/***** PFR HEADER *****/
/***** *****/
/***********************************************************************/
/***********************************************************************/
static const FT_Frame_Field pfr_header_fields[] =
static const FT_Frame_Field pfr_header_fields[] =
{
#undef FT_STRUCTURE
#define FT_STRUCTURE PFR_HeaderRec
FT_FRAME_START(58),
FT_FRAME_ULONG (signature),
FT_FRAME_USHORT(version),
FT_FRAME_USHORT(signature2),
FT_FRAME_USHORT(header_size),
FT_FRAME_START( 58 ),
FT_FRAME_ULONG ( signature ),
FT_FRAME_USHORT( version ),
FT_FRAME_USHORT( signature2 ),
FT_FRAME_USHORT( header_size ),
FT_FRAME_USHORT(log_dir_size),
FT_FRAME_USHORT(log_dir_offset),
FT_FRAME_USHORT( log_dir_size ),
FT_FRAME_USHORT( log_dir_offset ),
FT_FRAME_USHORT(log_font_max_size),
FT_FRAME_UOFF3 (log_font_section_size),
FT_FRAME_UOFF3 (log_font_section_offset),
FT_FRAME_USHORT( log_font_max_size ),
FT_FRAME_UOFF3 ( log_font_section_size ),
FT_FRAME_UOFF3 ( log_font_section_offset ),
FT_FRAME_USHORT(phy_font_max_size),
FT_FRAME_UOFF3 (phy_font_section_size),
FT_FRAME_UOFF3 (phy_font_section_offset),
FT_FRAME_USHORT( phy_font_max_size ),
FT_FRAME_UOFF3 ( phy_font_section_size ),
FT_FRAME_UOFF3 ( phy_font_section_offset ),
FT_FRAME_USHORT(gps_max_size),
FT_FRAME_UOFF3 (gps_section_size),
FT_FRAME_UOFF3 (gps_section_offset),
FT_FRAME_USHORT( gps_max_size ),
FT_FRAME_UOFF3 ( gps_section_size ),
FT_FRAME_UOFF3 ( gps_section_offset ),
FT_FRAME_BYTE (max_blue_values),
FT_FRAME_BYTE (max_x_orus),
FT_FRAME_BYTE (max_y_orus),
FT_FRAME_BYTE ( max_blue_values ),
FT_FRAME_BYTE ( max_x_orus ),
FT_FRAME_BYTE ( max_y_orus ),
FT_FRAME_BYTE (phy_font_max_size_high),
FT_FRAME_BYTE (color_flags),
FT_FRAME_BYTE ( phy_font_max_size_high ),
FT_FRAME_BYTE ( color_flags ),
FT_FRAME_UOFF3 (bct_max_size),
FT_FRAME_UOFF3 (bct_set_max_size),
FT_FRAME_UOFF3 (phy_bct_set_max_size),
FT_FRAME_UOFF3 ( bct_max_size ),
FT_FRAME_UOFF3 ( bct_set_max_size ),
FT_FRAME_UOFF3 ( phy_bct_set_max_size ),
FT_FRAME_USHORT(num_phy_fonts),
FT_FRAME_BYTE (max_vert_stem_snap),
FT_FRAME_BYTE (max_horz_stem_snap),
FT_FRAME_USHORT(max_chars),
FT_FRAME_USHORT( num_phy_fonts ),
FT_FRAME_BYTE ( max_vert_stem_snap ),
FT_FRAME_BYTE ( max_horz_stem_snap ),
FT_FRAME_USHORT( max_chars ),
FT_FRAME_END
};
@ -131,6 +153,7 @@
{
FT_Error error;
/* read header directly */
if ( !FT_STREAM_SEEK( 0 ) &&
!FT_STREAM_READ_FIELDS( pfr_header_fields, header ) )
@ -149,11 +172,12 @@
{
FT_Bool result = 1;
/* check signature and header size */
if ( header->signature != 0x50465230 || /* "PFR0" */
header->version > 4 ||
header->header_size < 58 ||
header->signature2 != 0x0d0a ) /* CR/LF */
if ( header->signature != 0x50465230L || /* "PFR0" */
header->version > 4 ||
header->header_size < 58 ||
header->signature2 != 0x0d0a ) /* CR/LF */
{
result = 0;
}
@ -179,7 +203,8 @@
FT_UInt count;
FT_UInt result = 0;
if ( FT_STREAM_SEEK( section_offset ) || FT_READ_USHORT(count) )
if ( FT_STREAM_SEEK( section_offset ) || FT_READ_USHORT( count ) )
goto Exit;
result = count;
@ -191,11 +216,11 @@
FT_LOCAL_DEF( FT_Error )
pfr_log_font_load( PFR_LogFont log_font,
FT_Stream stream,
FT_UInt index,
FT_UInt32 section_offset,
FT_Bool size_increment )
pfr_log_font_load( PFR_LogFont log_font,
FT_Stream stream,
FT_UInt index,
FT_UInt32 section_offset,
FT_Bool size_increment )
{
FT_UInt num_log_fonts;
FT_UInt flags;
@ -203,15 +228,17 @@
FT_UInt32 size;
FT_Error error;
if ( FT_STREAM_SEEK( section_offset ) || FT_READ_USHORT(num_log_fonts) )
if ( FT_STREAM_SEEK( section_offset ) ||
FT_READ_USHORT( num_log_fonts ) )
goto Exit;
if ( index >= num_log_fonts )
return FT_Err_Invalid_Argument;
if ( FT_STREAM_SKIP( index*5 ) ||
FT_READ_USHORT(size) ||
FT_READ_UOFF3 (offset) )
if ( FT_STREAM_SKIP( index * 5 ) ||
FT_READ_USHORT( size ) ||
FT_READ_UOFF3 ( offset ) )
goto Exit;
/* save logical font size and offset */
@ -224,6 +251,7 @@
FT_Byte* limit;
FT_UInt local;
if ( FT_STREAM_SEEK( offset ) || FT_FRAME_ENTER( size ) )
goto Exit;
@ -232,12 +260,12 @@
PFR_CHECK(13);
log_font->matrix[0] = PFR_NEXT_LONG(p);
log_font->matrix[1] = PFR_NEXT_LONG(p);
log_font->matrix[2] = PFR_NEXT_LONG(p);
log_font->matrix[3] = PFR_NEXT_LONG(p);
log_font->matrix[0] = PFR_NEXT_LONG( p );
log_font->matrix[1] = PFR_NEXT_LONG( p );
log_font->matrix[2] = PFR_NEXT_LONG( p );
log_font->matrix[3] = PFR_NEXT_LONG( p );
flags = PFR_NEXT_BYTE(p);
flags = PFR_NEXT_BYTE( p );
local = 0;
if ( flags & PFR_LOG_STROKE )
@ -256,23 +284,23 @@
local++;
}
PFR_CHECK(local);
PFR_CHECK( local );
if ( flags & PFR_LOG_STROKE )
{
log_font->stroke_thickness = ( flags & PFR_LOG_2BYTE_STROKE )
? PFR_NEXT_SHORT(p)
: PFR_NEXT_BYTE(p);
? PFR_NEXT_SHORT( p )
: PFR_NEXT_BYTE( p );
if ( (flags & PFR_LINE_JOIN_MASK) == PFR_LINE_JOIN_MITER )
log_font->miter_limit = PFR_NEXT_LONG(p);
if ( ( flags & PFR_LINE_JOIN_MASK ) == PFR_LINE_JOIN_MITER )
log_font->miter_limit = PFR_NEXT_LONG( p );
}
if ( flags & PFR_LOG_BOLD )
{
log_font->bold_thickness = ( flags & PFR_LOG_2BYTE_BOLD )
? PFR_NEXT_SHORT(p)
: PFR_NEXT_BYTE(p);
? PFR_NEXT_SHORT( p )
: PFR_NEXT_BYTE( p );
}
if ( flags & PFR_LOG_EXTRA_ITEMS )
@ -282,12 +310,12 @@
}
PFR_CHECK(5);
log_font->phys_size = PFR_NEXT_USHORT(p);
log_font->phys_offset = PFR_NEXT_ULONG(p);
log_font->phys_size = PFR_NEXT_USHORT( p );
log_font->phys_offset = PFR_NEXT_ULONG( p );
if ( size_increment )
{
PFR_CHECK(1);
log_font->phys_size += (FT_UInt32)PFR_NEXT_BYTE(p) << 16;
PFR_CHECK( 1 );
log_font->phys_size += (FT_UInt32)PFR_NEXT_BYTE( p ) << 16;
}
}
@ -313,7 +341,7 @@
/***********************************************************************/
/* load bitmap strikes lists */
/* load bitmap strikes lists */
FT_CALLBACK_DEF( FT_Error )
pfr_extra_item_load_bitmap_info( FT_Byte* p,
FT_Byte* limit,
@ -325,18 +353,21 @@
FT_UInt n, count, size1;
FT_Error error = 0;
PFR_CHECK(5);
PFR_CHECK( 5 );
p += 3; /* skip bctSize */
flags0 = PFR_NEXT_BYTE(p);
count = PFR_NEXT_BYTE(p);
flags0 = PFR_NEXT_BYTE( p );
count = PFR_NEXT_BYTE( p );
/* re-allocate when needed */
if ( phy_font->num_strikes + count > phy_font->max_strikes )
{
FT_UInt new_max = (phy_font->num_strikes + count + 3) & -4;
if ( FT_RENEW_ARRAY( phy_font->strikes, phy_font->num_strikes, new_max ) )
if ( FT_RENEW_ARRAY( phy_font->strikes,
phy_font->num_strikes,
new_max ) )
goto Exit;
phy_font->max_strikes = new_max;
@ -360,31 +391,31 @@
strike = phy_font->strikes + phy_font->num_strikes;
PFR_CHECK( count*size1 );
PFR_CHECK( count * size1 );
for ( n = 0; n < count; n++, strike++ )
{
strike->x_ppm = ( flags0 & PFR_STRIKE_2BYTE_XPPM )
? PFR_NEXT_USHORT(p)
: PFR_NEXT_BYTE(p);
? PFR_NEXT_USHORT( p )
: PFR_NEXT_BYTE( p );
strike->y_ppm = ( flags0 & PFR_STRIKE_2BYTE_YPPM )
? PFR_NEXT_USHORT(p)
: PFR_NEXT_BYTE(p);
? PFR_NEXT_USHORT( p )
: PFR_NEXT_BYTE( p );
strike->flags = PFR_NEXT_BYTE(p);
strike->flags = PFR_NEXT_BYTE( p );
strike->bct_size = ( flags0 & PFR_STRIKE_3BYTE_SIZE )
? PFR_NEXT_ULONG(p)
: PFR_NEXT_USHORT(p);
? PFR_NEXT_ULONG( p )
: PFR_NEXT_USHORT( p );
strike->bct_offset = ( flags0 & PFR_STRIKE_3BYTE_OFFSET )
? PFR_NEXT_ULONG(p)
: PFR_NEXT_USHORT(p);
? PFR_NEXT_ULONG( p )
: PFR_NEXT_USHORT( p );
strike->num_bitmaps = ( flags0 & PFR_STRIKE_2BYTE_COUNT )
? PFR_NEXT_USHORT(p)
: PFR_NEXT_BYTE(p);
? PFR_NEXT_USHORT( p )
: PFR_NEXT_BYTE( p );
}
phy_font->num_strikes += count;
@ -399,7 +430,7 @@
}
/* load font ID, i.e. name */
/* load font ID, i.e. name */
FT_CALLBACK_DEF( FT_Error )
pfr_extra_item_load_font_id( FT_Byte* p,
FT_Byte* limit,
@ -409,6 +440,7 @@
FT_Memory memory = phy_font->memory;
FT_UInt len = (FT_UInt)( limit - p );
if ( phy_font->font_id != NULL )
goto Exit;
@ -424,28 +456,29 @@
}
/* load stem snap tables */
/* load stem snap tables */
FT_CALLBACK_DEF( FT_Error )
pfr_extra_item_load_stem_snaps( FT_Byte* p,
FT_Byte* limit,
PFR_PhyFont phy_font )
{
FT_UInt count, num_vert, num_horz;
FT_Int* snaps;
FT_Error error = 0;
FT_Memory memory = phy_font->memory;
FT_UInt count, num_vert, num_horz;
FT_Int* snaps;
FT_Error error = 0;
FT_Memory memory = phy_font->memory;
if ( phy_font->vertical.stem_snaps != NULL )
goto Exit;
PFR_CHECK(1);
count = PFR_NEXT_BYTE(p);
PFR_CHECK( 1 );
count = PFR_NEXT_BYTE( p );
num_vert = count & 15;
num_horz = count >> 4;
count = num_vert + num_horz;
PFR_CHECK( count*2 );
PFR_CHECK( count * 2 );
if ( FT_NEW_ARRAY( snaps, count ) )
goto Exit;
@ -454,7 +487,7 @@
phy_font->horizontal.stem_snaps = snaps + num_vert;
for ( ; count > 0; count--, snaps++ )
*snaps = FT_NEXT_SHORT(p);
*snaps = FT_NEXT_SHORT( p );
Exit:
return error;
@ -466,7 +499,7 @@
}
static const PFR_ExtraItemRec pfr_phy_font_extra_items[] =
static const PFR_ExtraItemRec pfr_phy_font_extra_items[] =
{
{ 1, (PFR_ExtraItem_ParseFunc) pfr_extra_item_load_bitmap_info },
{ 2, (PFR_ExtraItem_ParseFunc) pfr_extra_item_load_font_id },
@ -475,9 +508,6 @@
};
FT_LOCAL_DEF( void )
pfr_phy_font_done( PFR_PhyFont phy_font,
FT_Memory memory )
@ -500,16 +530,12 @@
phy_font->chars_offset = 0;
}
FT_LOCAL_DEF( FT_Error )
pfr_phy_font_load( PFR_PhyFont phy_font,
FT_Stream stream,
FT_UInt32 offset,
FT_UInt32 size )
pfr_phy_font_load( PFR_PhyFont phy_font,
FT_Stream stream,
FT_UInt32 offset,
FT_UInt32 size )
{
FT_Error error;
FT_Memory memory = stream->memory;
@ -517,6 +543,7 @@
FT_Byte* p;
FT_Byte* limit;
phy_font->memory = memory;
phy_font->offset = offset;
@ -527,37 +554,37 @@
limit = p + size;
PFR_CHECK( 15 );
phy_font->font_ref_number = PFR_NEXT_USHORT(p);
phy_font->outline_resolution = PFR_NEXT_USHORT(p);
phy_font->metrics_resolution = PFR_NEXT_USHORT(p);
phy_font->bbox.xMin = PFR_NEXT_SHORT(p);
phy_font->bbox.yMin = PFR_NEXT_SHORT(p);
phy_font->bbox.xMax = PFR_NEXT_SHORT(p);
phy_font->bbox.yMax = PFR_NEXT_SHORT(p);
phy_font->flags = flags = PFR_NEXT_BYTE(p);
phy_font->font_ref_number = PFR_NEXT_USHORT( p );
phy_font->outline_resolution = PFR_NEXT_USHORT( p );
phy_font->metrics_resolution = PFR_NEXT_USHORT( p );
phy_font->bbox.xMin = PFR_NEXT_SHORT( p );
phy_font->bbox.yMin = PFR_NEXT_SHORT( p );
phy_font->bbox.xMax = PFR_NEXT_SHORT( p );
phy_font->bbox.yMax = PFR_NEXT_SHORT( p );
phy_font->flags = flags = PFR_NEXT_BYTE( p );
/* get the standard advance for non-proprotional fonts */
if ( !(flags & PFR_PHY_PROPORTIONAL) )
{
PFR_CHECK(2);
phy_font->standard_advance = PFR_NEXT_SHORT(p);
PFR_CHECK( 2 );
phy_font->standard_advance = PFR_NEXT_SHORT( p );
}
/* load the extra items when present */
if ( flags & PFR_PHY_EXTRA_ITEMS )
{
error =
pfr_extra_items_parse( &p, limit, pfr_phy_font_extra_items, phy_font );
error = pfr_extra_items_parse( &p, limit,
pfr_phy_font_extra_items, phy_font );
if ( error )
goto Fail;
}
/* skip the aux bytes */
PFR_CHECK(3);
num_aux = PFR_NEXT_ULONG(p);
PFR_CHECK( 3 );
num_aux = PFR_NEXT_ULONG( p );
PFR_CHECK(num_aux);
PFR_CHECK( num_aux );
p += num_aux;
/* read the blue values */
@ -565,79 +592,81 @@
FT_UInt n, count;
PFR_CHECK( 1 );
phy_font->num_blue_values = count = PFR_NEXT_BYTE(p);
phy_font->num_blue_values = count = PFR_NEXT_BYTE( p );
PFR_CHECK( count*2 );
PFR_CHECK( count * 2 );
if ( FT_NEW_ARRAY( phy_font->blue_values, count ) )
goto Fail;
for ( n = 0; n < count; n++ )
phy_font->blue_values[n] = PFR_NEXT_SHORT(p);
phy_font->blue_values[n] = PFR_NEXT_SHORT( p );
}
PFR_CHECK(8);
phy_font->blue_fuzz = PFR_NEXT_BYTE(p);
phy_font->blue_scale = PFR_NEXT_BYTE(p);
PFR_CHECK( 8 );
phy_font->blue_fuzz = PFR_NEXT_BYTE( p );
phy_font->blue_scale = PFR_NEXT_BYTE( p );
phy_font->vertical.standard = PFR_NEXT_USHORT(p);
phy_font->horizontal.standard = PFR_NEXT_USHORT(p);
phy_font->vertical.standard = PFR_NEXT_USHORT( p );
phy_font->horizontal.standard = PFR_NEXT_USHORT( p );
/* read the character descriptors */
{
FT_UInt n, count, size;
FT_UInt n, count, Size;
phy_font->num_chars = count = PFR_NEXT_USHORT(p);
phy_font->chars_offset = offset + (p - stream->cursor);
phy_font->num_chars = count = PFR_NEXT_USHORT( p );
phy_font->chars_offset = offset + ( p - stream->cursor );
if ( FT_NEW_ARRAY( phy_font->chars, count ) )
goto Fail;
size = 1 + 1 + 2;
Size = 1 + 1 + 2;
if ( flags & PFR_PHY_2BYTE_CHARCODE )
size += 1;
Size += 1;
if ( flags & PFR_PHY_PROPORTIONAL )
size += 2;
Size += 2;
if ( flags & PFR_PHY_ASCII_CODE )
size += 1;
Size += 1;
if ( flags & PFR_PHY_2BYTE_GPS_SIZE )
size += 1;
Size += 1;
if ( flags & PFR_PHY_3BYTE_GPS_OFFSET )
size += 1;
Size += 1;
PFR_CHECK( count*size );
PFR_CHECK( count * Size );
for ( n = 0; n < count; n++ )
{
PFR_Char cur = &phy_font->chars[n];
PFR_Char cur = &phy_font->chars[n];
cur->char_code = ( flags & PFR_PHY_2BYTE_CHARCODE )
? PFR_NEXT_USHORT(p)
: PFR_NEXT_BYTE(p);
cur->advance = ( flags & PFR_PHY_PROPORTIONAL )
? PFR_NEXT_SHORT(p)
cur->char_code = ( flags & PFR_PHY_2BYTE_CHARCODE )
? PFR_NEXT_USHORT( p )
: PFR_NEXT_BYTE( p );
cur->advance = ( flags & PFR_PHY_PROPORTIONAL )
? PFR_NEXT_SHORT( p )
: phy_font->standard_advance;
#if 0
cur->ascii = ( flags & PFR_PHY_ASCII_CODE )
? PFR_NEXT_BYTE(p)
cur->ascii = ( flags & PFR_PHY_ASCII_CODE )
? PFR_NEXT_BYTE( p )
: 0;
#else
if ( flags & PFR_PHY_ASCII_CODE )
p += 1;
if ( flags & PFR_PHY_ASCII_CODE )
p += 1;
#endif
cur->gps_size = ( flags & PFR_PHY_2BYTE_GPS_SIZE )
? PFR_NEXT_USHORT(p)
: PFR_NEXT_BYTE(p);
cur->gps_size = ( flags & PFR_PHY_2BYTE_GPS_SIZE )
? PFR_NEXT_USHORT( p )
: PFR_NEXT_BYTE( p );
cur->gps_offset = ( flags & PFR_PHY_3BYTE_GPS_OFFSET )
? PFR_NEXT_ULONG(p)
: PFR_NEXT_USHORT(p);
cur->gps_offset = ( flags & PFR_PHY_3BYTE_GPS_OFFSET )
? PFR_NEXT_ULONG( p )
: PFR_NEXT_USHORT( p );
}
}
@ -655,3 +684,4 @@
}
/* END */

103
src/pfr/pfrload.h
View File

@ -1,30 +1,56 @@
#ifndef __PFR_LOAD_H__
#define __PFR_LOAD_H__
/***************************************************************************/
/* */
/* pfrload.h */
/* */
/* FreeType PFR loader (specification). */
/* */
/* Copyright 2002 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#ifndef __PFRLOAD_H__
#define __PFRLOAD_H__
#include "pfrobjs.h"
#include FT_INTERNAL_STREAM_H
FT_BEGIN_HEADER
#ifdef PFR_CONFIG_NO_CHECKS
# define PFR_CHECK(x) do { } while (0)
#define PFR_CHECK( x ) do { } while ( 0 )
#else
# define PFR_CHECK(x) do { if ( p + (x) > limit ) goto Too_Short; } while (0)
#define PFR_CHECK( x ) do \
{ \
if ( p + (x) > limit ) \
goto Too_Short; \
} while ( 0 )
#endif
#define PFR_NEXT_BYTE(p) FT_NEXT_BYTE(p)
#define PFR_NEXT_INT8(p) FT_NEXT_CHAR(p)
#define PFR_NEXT_SHORT(p) FT_NEXT_SHORT(p)
#define PFR_NEXT_USHORT(p) FT_NEXT_USHORT(p)
#define PFR_NEXT_LONG(p) FT_NEXT_OFF3(p)
#define PFR_NEXT_ULONG(p) FT_NEXT_UOFF3(p)
#define PFR_NEXT_BYTE( p ) FT_NEXT_BYTE( p )
#define PFR_NEXT_INT8( p ) FT_NEXT_CHAR( p )
#define PFR_NEXT_SHORT( p ) FT_NEXT_SHORT( p )
#define PFR_NEXT_USHORT( p ) FT_NEXT_USHORT( p )
#define PFR_NEXT_LONG( p ) FT_NEXT_OFF3( p )
#define PFR_NEXT_ULONG( p ) FT_NEXT_UOFF3( p )
/* handling extra items */
typedef FT_Error (*PFR_ExtraItem_ParseFunc)( FT_Byte* p,
FT_Byte* limit,
FT_Pointer data );
typedef struct PFR_ExtraItemRec_
typedef FT_Error
(*PFR_ExtraItem_ParseFunc)( FT_Byte* p,
FT_Byte* limit,
FT_Pointer data );
typedef struct PFR_ExtraItemRec_
{
FT_UInt type;
PFR_ExtraItem_ParseFunc parser;
@ -33,8 +59,10 @@ FT_BEGIN_HEADER
typedef const struct PFR_ExtraItemRec_* PFR_ExtraItem;
FT_LOCAL( FT_Error )
pfr_extra_items_skip( FT_Byte* *pp, FT_Byte* limit );
pfr_extra_items_skip( FT_Byte* *pp,
FT_Byte* limit );
FT_LOCAL( FT_Error )
pfr_extra_items_parse( FT_Byte* *pp,
@ -43,47 +71,48 @@ FT_BEGIN_HEADER
FT_Pointer item_data );
/* load a PFR header */
/* load a PFR header */
FT_LOCAL( FT_Error )
pfr_header_load( PFR_Header header,
FT_Stream stream );
/* check a PFR header */
/* check a PFR header */
FT_LOCAL( FT_Bool )
pfr_header_check( PFR_Header header );
/* return number of logical fonts in this file */
/* return number of logical fonts in this file */
FT_LOCAL( FT_Error )
pfr_log_font_count( FT_Stream stream,
FT_UInt32 log_section_offset,
FT_UInt *acount );
pfr_log_font_count( FT_Stream stream,
FT_UInt32 log_section_offset,
FT_UInt *acount );
/* load a pfr logical font entry */
/* load a pfr logical font entry */
FT_LOCAL( FT_Error )
pfr_log_font_load( PFR_LogFont log_font,
FT_Stream stream,
FT_UInt face_index,
FT_UInt32 section_offset,
FT_Bool size_increment );
pfr_log_font_load( PFR_LogFont log_font,
FT_Stream stream,
FT_UInt face_index,
FT_UInt32 section_offset,
FT_Bool size_increment );
/* load a physical font entry */
/* load a physical font entry */
FT_LOCAL( FT_Error )
pfr_phy_font_load( PFR_PhyFont phy_font,
FT_Stream stream,
FT_UInt32 offset,
FT_UInt32 size );
pfr_phy_font_load( PFR_PhyFont phy_font,
FT_Stream stream,
FT_UInt32 offset,
FT_UInt32 size );
/* finalize a physical font */
/* finalize a physical font */
FT_LOCAL( void )
pfr_phy_font_done( PFR_PhyFont phy_font,
FT_Memory memory );
/* */
/* */
FT_END_HEADER
#endif /* __PFR_LOAD_H__ */
#endif /* __PFRLOAD_H__ */
/* END */

114
src/pfr/pfrobjs.c
View File

@ -1,3 +1,21 @@
/***************************************************************************/
/* */
/* pfrobjs.c */
/* */
/* FreeType PFR object methods (body). */
/* */
/* Copyright 2002 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#include "pfrobjs.h"
#include "pfrload.h"
#include "pfrgload.h"
@ -8,19 +26,20 @@
#undef FT_COMPONENT
#define FT_COMPONENT trace_pfr
/*************************************************************************/
/*************************************************************************/
/***** *****/
/***** FACE OBJECT METHODS *****/
/***** *****/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/***** *****/
/***** FACE OBJECT METHODS *****/
/***** *****/
/*************************************************************************/
/*************************************************************************/
FT_LOCAL_DEF( void )
pfr_face_done( PFR_Face face )
pfr_face_done( PFR_Face face )
{
/* finalize the physical font record */
pfr_phy_font_done( &face->phy_font, FT_FACE_MEMORY(face) );
pfr_phy_font_done( &face->phy_font, FT_FACE_MEMORY( face ) );
/* no need to finalize the logical font or the header */
}
@ -33,13 +52,15 @@
{
FT_Error error;
/* load the header and check it */
error = pfr_header_load( &face->header, stream );
if ( error ) goto Exit;
if ( error )
goto Exit;
if ( !pfr_header_check( &face->header ) )
{
FT_TRACE4(( "PFR.Face.Init: not a valid PFR font\n" ));
FT_TRACE4(( "pfr_face_init: not a valid PFR font\n" ));
error = FT_Err_Invalid_Argument;
goto Exit;
}
@ -48,10 +69,12 @@
{
FT_UInt num_faces;
error = pfr_log_font_count( stream,
face->header.log_dir_offset,
&num_faces );
if ( error ) goto Exit;
if ( error )
goto Exit;
face->root.num_faces = num_faces;
}
@ -61,7 +84,7 @@
if ( face_index >= face->root.num_faces )
{
FT_ERROR(( "PFR.Face.Init: invalid face index\n" ));
FT_ERROR(( "pfr_face_init: invalid face index\n" ));
error = FT_Err_Invalid_Argument;
goto Exit;
}
@ -83,9 +106,10 @@
/* now, set-up all root face fields */
{
FT_Face root = FT_FACE(face);
FT_Face root = FT_FACE( face );
PFR_PhyFont phy_font = &face->phy_font;
root->face_index = face_index;
root->num_glyphs = phy_font->num_chars;
root->face_flags = FT_FACE_FLAG_SCALABLE;
@ -98,7 +122,7 @@
else
root->face_flags |= FT_FACE_FLAG_VERTICAL;
/* XXXX: kerning and embedded bitmap support isn't there yet */
/* XXX: kerning and embedded bitmap support isn't there yet */
root->family_name = phy_font->font_id;
root->style_name = NULL; /* no style name in font file */
@ -107,38 +131,42 @@
root->available_sizes = 0;
root->bbox = phy_font->bbox;
root->units_per_EM = (FT_UShort) phy_font->outline_resolution;
root->ascender = (FT_Short) phy_font->bbox.yMax;
root->descender = (FT_Short) phy_font->bbox.yMin;
root->height = (FT_Short)( ((root->ascender - root->descender)*12) / 10 );
root->units_per_EM = (FT_UShort)phy_font->outline_resolution;
root->ascender = (FT_Short) phy_font->bbox.yMax;
root->descender = (FT_Short) phy_font->bbox.yMin;
root->height = (FT_Short)
( ( ( root->ascender - root->descender ) * 12 )
/ 10 );
/* now compute maximum advance width */
if ( (phy_font->flags & PFR_PHY_PROPORTIONAL) == 0 )
root->max_advance_width = (FT_Short) phy_font->standard_advance;
if ( ( phy_font->flags & PFR_PHY_PROPORTIONAL ) == 0 )
root->max_advance_width = (FT_Short)phy_font->standard_advance;
else
{
FT_Int max = 0;
FT_UInt count = phy_font->num_chars;
PFR_Char gchar = phy_font->chars;
for ( ; count > 0; count--, gchar++ )
{
if ( max < gchar->advance )
max = gchar->advance;
}
root->max_advance_width = (FT_Short) max;
root->max_advance_width = (FT_Short)max;
}
root->max_advance_height = root->height;
root->underline_position = (FT_Short)( - root->units_per_EM/10 );
root->underline_thickness = (FT_Short)( root->units_per_EM/30 );
root->underline_position = (FT_Short)( - root->units_per_EM / 10 );
root->underline_thickness = (FT_Short)( root->units_per_EM / 30 );
/* create charmap */
{
FT_CharMapRec charmap;
FT_CharMapRec charmap;
charmap.face = root;
charmap.platform_id = 3;
charmap.encoding_id = 1;
@ -153,18 +181,18 @@
}
/*************************************************************************/
/*************************************************************************/
/***** *****/
/***** SLOT OBJECT METHOD *****/
/***** *****/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/***** *****/
/***** SLOT OBJECT METHOD *****/
/***** *****/
/*************************************************************************/
/*************************************************************************/
FT_LOCAL_DEF( FT_Error )
pfr_slot_init( PFR_Slot slot )
{
FT_GlyphLoader loader = slot->root.internal->loader;
FT_GlyphLoader loader = slot->root.internal->loader;
pfr_glyph_init( &slot->glyph, loader );
@ -186,12 +214,13 @@
FT_Int load_flags )
{
FT_Error error;
PFR_Face face = (PFR_Face) slot->root.face;
PFR_Face face = (PFR_Face)slot->root.face;
PFR_Char gchar = face->phy_font.chars + gindex;
FT_Outline* outline = &slot->root.outline;
FT_ULong gps_offset;
/* check that the glyph index is correct */
/* check that the glyph index is correct */
FT_ASSERT( gindex < face->phy_font.num_chars );
slot->root.format = ft_glyph_format_outline;
@ -199,21 +228,20 @@
outline->n_contours = 0;
gps_offset = face->header.gps_section_offset;
/* load the glyph outline ( FT_LOAD_NO_RECURSE isn't supported ) */
/* load the glyph outline (FT_LOAD_NO_RECURSE isn't supported) */
error = pfr_glyph_load( &slot->glyph, face->root.stream,
gps_offset, gchar->gps_offset, gchar->gps_size );
if (!error)
if ( !error )
{
FT_BBox cbox;
FT_Outline* outline = &slot->root.outline;
FT_Glyph_Metrics* metrics = &slot->root.metrics;
FT_Pos advance;
FT_Int em_metrics, em_outline;
FT_Bool scaling;
scaling = FT_BOOL( (load_flags & FT_LOAD_NO_SCALE) == 0 );
scaling = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE ) == 0 );
/* copy outline data */
*outline = slot->glyph.loader->base.outline;
@ -243,7 +271,7 @@
slot->root.linearHoriAdvance = metrics->horiAdvance;
slot->root.linearVertAdvance = metrics->vertAdvance;
/* make-up vertical metrics (?) */
/* make-up vertical metrics(?) */
metrics->vertBearingX = 0;
metrics->vertBearingY = 0;
@ -255,6 +283,7 @@
FT_Fixed y_scale = size->root.metrics.y_scale;
FT_Vector* vec = outline->points;
/* scale outline points */
for ( n = 0; n < outline->n_points; n++, vec++ )
{
@ -278,3 +307,6 @@
return error;
}
/* END */

42
src/pfr/pfrobjs.h
View File

@ -1,19 +1,37 @@
#ifndef __PFR_OBJS_H__
#define __PFR_OBJS_H__
/***************************************************************************/
/* */
/* pfrobjs.h */
/* */
/* FreeType PFR object methods (specification). */
/* */
/* Copyright 2002 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#ifndef __PFROBJS_H__
#define __PFROBJS_H__
#include "pfrtypes.h"
FT_BEGIN_HEADER
typedef struct PFR_FaceRec_* PFR_Face;
typedef struct PFR_FaceRec_* PFR_Face;
typedef struct PFR_SizeRec_* PFR_Size;
typedef struct PFR_SizeRec_* PFR_Size;
typedef struct PFR_SlotRec_* PFR_Slot;
typedef struct PFR_SlotRec_* PFR_Slot;
typedef struct PFR_FaceRec_
typedef struct PFR_FaceRec_
{
FT_FaceRec root;
PFR_HeaderRec header;
@ -23,14 +41,14 @@ FT_BEGIN_HEADER
} PFR_FaceRec;
typedef struct PFR_SizeRec_
typedef struct PFR_SizeRec_
{
FT_SizeRec root;
FT_SizeRec root;
} PFR_SizeRec;
typedef struct PFR_SlotRec_
typedef struct PFR_SlotRec_
{
FT_GlyphSlotRec root;
PFR_GlyphRec glyph;
@ -43,7 +61,6 @@ FT_BEGIN_HEADER
PFR_Face face,
FT_Int face_index );
FT_LOCAL( void )
pfr_face_done( PFR_Face face );
@ -51,7 +68,6 @@ FT_BEGIN_HEADER
FT_LOCAL( FT_Error )
pfr_slot_init( PFR_Slot slot );
FT_LOCAL( void )
pfr_slot_done( PFR_Slot slot );
@ -65,4 +81,4 @@ FT_BEGIN_HEADER
FT_END_HEADER
#endif /* __PFR_OBJS_H__ */
#endif /* __PFROBJS_H__ */

174
src/pfr/pfrtypes.h
View File

@ -1,57 +1,75 @@
#ifndef __PFR_TYPES_H__
#define __PFR_TYPES_H__
/***************************************************************************/
/* */
/* pfrtypes.h */
/* */
/* FreeType PFR data structures (specification only). */
/* */
/* Copyright 2002 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#ifndef __PFRTYPES_H__
#define __PFRTYPES_H__
#include <ft2build.h>
#include FT_INTERNAL_OBJECTS_H
FT_BEGIN_HEADER
/************************************************************************/
/************************************************************************/
/* the PFR Header structure */
typedef struct PFR_HeaderRec_
/* the PFR Header structure */
typedef struct PFR_HeaderRec_
{
FT_UInt32 signature;
FT_UInt version;
FT_UInt signature2;
FT_UInt header_size;
FT_UInt32 signature;
FT_UInt version;
FT_UInt signature2;
FT_UInt header_size;
FT_UInt log_dir_size;
FT_UInt log_dir_offset;
FT_UInt log_dir_size;
FT_UInt log_dir_offset;
FT_UInt log_font_max_size;
FT_UInt32 log_font_section_size;
FT_UInt32 log_font_section_offset;
FT_UInt log_font_max_size;
FT_UInt32 log_font_section_size;
FT_UInt32 log_font_section_offset;
FT_UInt32 phy_font_max_size;
FT_UInt32 phy_font_section_size;
FT_UInt32 phy_font_section_offset;
FT_UInt32 phy_font_max_size;
FT_UInt32 phy_font_section_size;
FT_UInt32 phy_font_section_offset;
FT_UInt gps_max_size;
FT_UInt32 gps_section_size;
FT_UInt32 gps_section_offset;
FT_UInt gps_max_size;
FT_UInt32 gps_section_size;
FT_UInt32 gps_section_offset;
FT_UInt max_blue_values;
FT_UInt max_x_orus;
FT_UInt max_y_orus;
FT_UInt max_blue_values;
FT_UInt max_x_orus;
FT_UInt max_y_orus;
FT_UInt phy_font_max_size_high;
FT_UInt color_flags;
FT_UInt phy_font_max_size_high;
FT_UInt color_flags;
FT_UInt32 bct_max_size;
FT_UInt32 bct_set_max_size;
FT_UInt32 phy_bct_set_max_size;
FT_UInt32 bct_max_size;
FT_UInt32 bct_set_max_size;
FT_UInt32 phy_bct_set_max_size;
FT_UInt num_phy_fonts;
FT_UInt max_vert_stem_snap;
FT_UInt max_horz_stem_snap;
FT_UInt max_chars;
FT_UInt num_phy_fonts;
FT_UInt max_vert_stem_snap;
FT_UInt max_horz_stem_snap;
FT_UInt max_chars;
} PFR_HeaderRec, *PFR_Header;
/* used in 'color_flags' field of the PFR_Header */
typedef enum PFR_HeaderFlags_
/* used in `color_flags' field of the PFR_Header */
typedef enum PFR_HeaderFlags_
{
PFR_FLAG_BLACK_PIXEL = 1,
PFR_FLAG_INVERT_BITMAP = 2
@ -59,9 +77,9 @@ FT_BEGIN_HEADER
} PFR_HeaderFlags;
/************************************************************************/
/************************************************************************/
typedef struct PFR_LogFontRec_
typedef struct PFR_LogFontRec_
{
FT_UInt32 size;
FT_UInt32 offset;
@ -78,19 +96,19 @@ FT_BEGIN_HEADER
} PFR_LogFontRec, *PFR_LogFont;
typedef enum PFR_LogFlags_
typedef enum PFR_LogFlags_
{
PFR_LOG_EXTRA_ITEMS = 0x40,
PFR_LOG_2BYTE_BOLD = 0x20,
PFR_LOG_BOLD = 0x10,
PFR_LOG_2BYTE_STROKE = 8,
PFR_LOG_STROKE = 4,
PFR_LINE_JOIN_MASK = 3
PFR_LOG_EXTRA_ITEMS = 0x40,
PFR_LOG_2BYTE_BOLD = 0x20,
PFR_LOG_BOLD = 0x10,
PFR_LOG_2BYTE_STROKE = 8,
PFR_LOG_STROKE = 4,
PFR_LINE_JOIN_MASK = 3
} PFR_LogFlags;
typedef enum PFR_LineJoinFlags_
typedef enum PFR_LineJoinFlags_
{
PFR_LINE_JOIN_MITER = 0,
PFR_LINE_JOIN_ROUND = 1,
@ -99,18 +117,18 @@ FT_BEGIN_HEADER
} PFR_LineJoinFlags;
/************************************************************************/
/************************************************************************/
typedef enum PFR_BitmapFlags_
typedef enum PFR_BitmapFlags_
{
PFR_BITMAP_3BYTE_OFFSET = 4,
PFR_BITMAP_2BYTE_SIZE = 2,
PFR_BITMAP_2BYTE_CHARCODE = 1
PFR_BITMAP_3BYTE_OFFSET = 4,
PFR_BITMAP_2BYTE_SIZE = 2,
PFR_BITMAP_2BYTE_CHARCODE = 1
} PFR_BitmapFlags;
typedef struct PFR_BitmapCharRec_
typedef struct PFR_BitmapCharRec_
{
FT_UInt char_code;
FT_UInt gps_size;
@ -119,7 +137,7 @@ FT_BEGIN_HEADER
} PFR_BitmapCharRec, *PFR_BitmapChar;
typedef enum PFR_StrikeFlags_
typedef enum PFR_StrikeFlags_
{
PFR_STRIKE_2BYTE_COUNT = 0x10,
PFR_STRIKE_3BYTE_OFFSET = 0x08,
@ -130,7 +148,7 @@ FT_BEGIN_HEADER
} PFR_StrikeFlags;
typedef struct PFR_StrikeRec_
typedef struct PFR_StrikeRec_
{
FT_UInt x_ppm;
FT_UInt y_ppm;
@ -149,33 +167,32 @@ FT_BEGIN_HEADER
} PFR_StrikeRec, *PFR_Strike;
/************************************************************************/
/************************************************************************/
typedef struct PFR_CharRec_
typedef struct PFR_CharRec_
{
FT_UInt char_code;
FT_Int advance;
FT_UInt gps_size;
FT_UInt32 gps_offset;
FT_UInt char_code;
FT_Int advance;
FT_UInt gps_size;
FT_UInt32 gps_offset;
} PFR_CharRec, *PFR_Char;
/************************************************************************/
/************************************************************************/
typedef struct PFR_DimensionRec_
typedef struct PFR_DimensionRec_
{
FT_UInt standard;
FT_UInt num_stem_snaps;
FT_Int* stem_snaps;
FT_UInt standard;
FT_UInt num_stem_snaps;
FT_Int* stem_snaps;
} PFR_DimensionRec, *PFR_Dimension;
/************************************************************************/
/************************************************************************/
typedef struct PFR_PhyFontRec_
typedef struct PFR_PhyFontRec_
{
FT_Memory memory;
FT_UInt32 offset;
@ -207,7 +224,8 @@ FT_BEGIN_HEADER
} PFR_PhyFontRec, *PFR_PhyFont;
typedef enum PFR_PhyFlags_
typedef enum PFR_PhyFlags_
{
PFR_PHY_EXTRA_ITEMS = 0x80,
PFR_PHY_3BYTE_GPS_OFFSET = 0x20,
@ -219,9 +237,10 @@ FT_BEGIN_HEADER
} PFR_PhyFlags;
/************************************************************************/
typedef enum PFR_GlyphFlags_
/************************************************************************/
typedef enum PFR_GlyphFlags_
{
PFR_GLYPH_IS_COMPOUND = 0x80,
PFR_GLYPH_EXTRA_ITEMS = 0x08,
@ -231,8 +250,9 @@ FT_BEGIN_HEADER
} PFR_GlyphFlags;
/* controlled coordinate */
typedef struct PFR_CoordRec_
/* controlled coordinate */
typedef struct PFR_CoordRec_
{
FT_UInt org;
FT_UInt cur;
@ -240,7 +260,7 @@ FT_BEGIN_HEADER
} PFR_CoordRec, *PFR_Coord;
typedef struct PFR_SubGlyphRec_
typedef struct PFR_SubGlyphRec_
{
FT_Fixed x_scale;
FT_Fixed y_scale;
@ -252,7 +272,7 @@ FT_BEGIN_HEADER
} PFR_SubGlyphRec, *PFR_SubGlyph;
typedef enum PFR_SubgGlyphFlags_
typedef enum PFR_SubgGlyphFlags_
{
PFR_SUBGLYPH_3BYTE_OFFSET = 0x80,
PFR_SUBGLYPH_2BYTE_SIZE = 0x40,
@ -262,8 +282,7 @@ FT_BEGIN_HEADER
} PFR_SubGlyphFlags;
typedef struct PFR_GlyphRec_
typedef struct PFR_GlyphRec_
{
FT_Byte format;
@ -286,4 +305,7 @@ FT_BEGIN_HEADER
FT_END_HEADER
#endif /* __PFR_TYPES_H__ */
#endif /* __PFRTYPES_H__ */
/* END */