Edit
kc3-lang/freetype/src/cff/cffparse.c
Branch :
-
Show log
Commit
-
Author :
Werner Lemberg
Date : 2008-05-14 23:05:38
Hash : e6e6eade
Message : Finish fix of scaling bug of CID-keyed CFF subfonts. * include/freetype/internal/ftcalc.h, src/base/ftcalc.c (FT_Matrix_Multiply_Scaled, FT_Vector_Transform_Scaled): New functions. * src/cff/cffobjs.h (CFF_Internal): New struct. It is used to provide global hinting data for both the top-font and all subfonts (with proper scaling). * src/cff/cffobjs.c (cff_make_private_dict): New function, using code from `cff_size_init'. (cff_size_init, cff_size_done, cff_size_select, cff_size_request): Use CFF_Internal and handle subfonts. (cff_face_init): Handle top-dict and subfont matrices correctly; apply some heuristic in case of unlikely matrix concatenation results. This has been discussed with people from Adobe (thanks goes mainly to David Lemon) who confirm that the CFF specs are fuzzy and not correct. * src/cff/cffgload.h (cff_decoder_prepare): Add `size' argument. * src/cff/cffgload.c (cff_builder_init): Updated. (cff_decoder_prepare): Handle hints globals for subfonts. Update all callers. (cff_slot_load): Handling scaling of subfonts properly. * src/cff/cffparse.c (cff_parse_fixed_dynamic): New function. (cff_parse_font_matrix): Use it. * src/cff/cfftypes.h (CFF_FontDictRec): Make `units_per_em' FT_ULong. * docs/CHANGES: Document it.
- src/cff/cffparse.c
-
/***************************************************************************/ /* */ /* cffparse.c */ /* */ /* CFF token stream parser (body) */ /* */ /* Copyright 1996-2001, 2002, 2003, 2004, 2007, 2008 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 "cffparse.h" #include FT_INTERNAL_STREAM_H #include "cfferrs.h" /*************************************************************************/ /* */ /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ /* messages during execution. */ /* */ #undef FT_COMPONENT #define FT_COMPONENT trace_cffparse enum { cff_kind_none = 0, cff_kind_num, cff_kind_fixed, cff_kind_fixed_thousand, cff_kind_string, cff_kind_bool, cff_kind_delta, cff_kind_callback, cff_kind_max /* do not remove */ }; /* now generate handlers for the most simple fields */ typedef FT_Error (*CFF_Field_Reader)( CFF_Parser parser ); typedef struct CFF_Field_Handler_ { int kind; int code; FT_UInt offset; FT_Byte size; CFF_Field_Reader reader; FT_UInt array_max; FT_UInt count_offset; } CFF_Field_Handler; FT_LOCAL_DEF( void ) cff_parser_init( CFF_Parser parser, FT_UInt code, void* object ) { FT_MEM_ZERO( parser, sizeof ( *parser ) ); parser->top = parser->stack; parser->object_code = code; parser->object = object; } /* read an integer */ static FT_Long cff_parse_integer( FT_Byte* start, FT_Byte* limit ) { FT_Byte* p = start; FT_Int v = *p++; FT_Long val = 0; if ( v == 28 ) { if ( p + 2 > limit ) goto Bad; val = (FT_Short)( ( (FT_Int)p[0] << 8 ) | p[1] ); p += 2; } else if ( v == 29 ) { if ( p + 4 > limit ) goto Bad; val = ( (FT_Long)p[0] << 24 ) | ( (FT_Long)p[1] << 16 ) | ( (FT_Long)p[2] << 8 ) | p[3]; p += 4; } else if ( v < 247 ) { val = v - 139; } else if ( v < 251 ) { if ( p + 1 > limit ) goto Bad; val = ( v - 247 ) * 256 + p[0] + 108; p++; } else { if ( p + 1 > limit ) goto Bad; val = -( v - 251 ) * 256 - p[0] - 108; p++; } Exit: return val; Bad: val = 0; goto Exit; } static const FT_Long power_tens[] = { 1L, 10L, 100L, 1000L, 10000L, 100000L, 1000000L, 10000000L, 100000000L, 1000000000L }; /* read a real */ static FT_Fixed cff_parse_real( FT_Byte* start, FT_Byte* limit, FT_Int power_ten, FT_Int* scaling ) { FT_Byte* p = start; FT_UInt nib; FT_UInt phase; FT_Long result, number, rest, exponent; FT_Int sign = 0, exponent_sign = 0; FT_Int exponent_add, integer_length, fraction_length; if ( scaling ) *scaling = 0; result = 0; number = 0; rest = 0; exponent = 0; exponent_add = 0; integer_length = 0; fraction_length = 0; /* First of all, read the integer part. */ phase = 4; for (;;) { /* If we entered this iteration with phase == 4, we need to */ /* read a new byte. This also skips past the initial 0x1E. */ if ( phase ) { p++; /* Make sure we don't read past the end. */ if ( p >= limit ) goto Exit; } /* Get the nibble. */ nib = ( p[0] >> phase ) & 0xF; phase = 4 - phase; if ( nib == 0xE ) sign = 1; else if ( nib > 9 ) break; else { /* Increase exponent if we can't add the digit. */ if ( number >= 0xCCCCCCCL ) exponent_add++; /* Skip leading zeros. */ else if ( nib || number ) { integer_length++; number = number * 10 + nib; } } } /* Read fraction part, if any. */ if ( nib == 0xa ) for (;;) { /* If we entered this iteration with phase == 4, we need */ /* to read a new byte. */ if ( phase ) { p++; /* Make sure we don't read past the end. */ if ( p >= limit ) goto Exit; } /* Get the nibble. */ nib = ( p[0] >> phase ) & 0xF; phase = 4 - phase; if ( nib >= 10 ) break; /* Skip leading zeros if possible. */ if ( !nib && !number ) exponent_add--; /* Only add digit if we don't overflow. */ else if ( number < 0xCCCCCCCL ) { fraction_length++; number = number * 10 + nib; } } /* Read exponent, if any. */ if ( nib == 12 ) { exponent_sign = 1; nib = 11; } if ( nib == 11 ) { for (;;) { /* If we entered this iteration with phase == 4, */ /* we need to read a new byte. */ if ( phase ) { p++; /* Make sure we don't read past the end. */ if ( p >= limit ) goto Exit; } /* Get the nibble. */ nib = ( p[0] >> phase ) & 0xF; phase = 4 - phase; if ( nib >= 10 ) break; exponent = exponent * 10 + nib; /* Arbitrarily limit exponent. */ if ( exponent > 1000 ) goto Exit; } if ( exponent_sign ) exponent = -exponent; } /* We don't check `power_ten' and `exponent_add'. */ exponent += power_ten + exponent_add; if ( scaling ) { /* Only use `fraction_length'. */ fraction_length += integer_length; exponent += integer_length; if ( fraction_length <= 5 ) { if ( number > 0x7FFFL ) { result = FT_DivFix( number, 10 ); *scaling = exponent - fraction_length + 1; } else { if ( exponent > 0 ) { FT_Int new_fraction_length, shift; /* Make `scaling' as small as possible. */ new_fraction_length = FT_MIN( exponent, 5 ); exponent -= new_fraction_length; shift = new_fraction_length - fraction_length; number *= power_tens[shift]; if ( number > 0x7FFFL ) { number /= 10; exponent += 1; } } else exponent -= fraction_length; result = number << 16; *scaling = exponent; } } else { if ( ( number / power_tens[fraction_length - 5] ) > 0x7FFFL ) { result = FT_DivFix( number, power_tens[fraction_length - 4] ); *scaling = exponent - 4; } else { result = FT_DivFix( number, power_tens[fraction_length - 5] ); *scaling = exponent - 5; } } } else { integer_length += exponent; fraction_length -= exponent; /* Check for overflow and underflow. */ if ( FT_ABS( integer_length ) > 5 ) goto Exit; /* Convert into 16.16 format. */ if ( fraction_length > 0 ) { if ( ( number / power_tens[fraction_length] ) > 0x7FFFL ) goto Exit; result = FT_DivFix( number, power_tens[fraction_length] ); } else { number *= power_tens[-fraction_length]; if ( number > 0x7FFFL ) goto Exit; result = number << 16; } } if ( sign ) result = -result; Exit: return result; } /* read a number, either integer or real */ static FT_Long cff_parse_num( FT_Byte** d ) { return **d == 30 ? ( cff_parse_real( d[0], d[1], 0, NULL ) >> 16 ) : cff_parse_integer( d[0], d[1] ); } /* read a floating point number, either integer or real */ static FT_Fixed cff_parse_fixed( FT_Byte** d ) { return **d == 30 ? cff_parse_real( d[0], d[1], 0, NULL ) : cff_parse_integer( d[0], d[1] ) << 16; } /* read a floating point number, either integer or real, */ /* but return `10^scaling' times the number read in */ static FT_Fixed cff_parse_fixed_scaled( FT_Byte** d, FT_Int scaling ) { return **d == 30 ? cff_parse_real( d[0], d[1], scaling, NULL ) : (FT_Fixed)FT_MulFix( cff_parse_integer( d[0], d[1] ) << 16, power_tens[scaling] ); } /* read a floating point number, either integer or real, */ /* and return it as precise as possible -- `scaling' returns */ /* the scaling factor (as a power of 10) */ static FT_Fixed cff_parse_fixed_dynamic( FT_Byte** d, FT_Int* scaling ) { FT_ASSERT( scaling ); if ( **d == 30 ) return cff_parse_real( d[0], d[1], 0, scaling ); else { FT_Long number; FT_Int integer_length; number = cff_parse_integer( d[0], d[1] ); if ( number > 0x7FFFL ) { for ( integer_length = 5; integer_length < 10; integer_length++ ) if ( number < power_tens[integer_length] ) break; if ( ( number / power_tens[integer_length - 5] ) > 0x7FFFL ) { *scaling = integer_length - 4; return FT_DivFix( number, power_tens[integer_length - 4] ); } else { *scaling = integer_length - 5; return FT_DivFix( number, power_tens[integer_length - 5] ); } } else { *scaling = 0; return number << 16; } } } static FT_Error cff_parse_font_matrix( CFF_Parser parser ) { CFF_FontRecDict dict = (CFF_FontRecDict)parser->object; FT_Matrix* matrix = &dict->font_matrix; FT_Vector* offset = &dict->font_offset; FT_ULong* upm = &dict->units_per_em; FT_Byte** data = parser->stack; FT_Error error = CFF_Err_Stack_Underflow; if ( parser->top >= parser->stack + 6 ) { FT_Int scaling; error = CFF_Err_Ok; /* We expect a well-formed font matrix, this is, the matrix elements */ /* `xx' and `yy' are of approximately the same magnitude. To avoid */ /* loss of precision, we use the magnitude of element `xx' to scale */ /* all other elements. The scaling factor is then contained in the */ /* `units_per_em' value. */ matrix->xx = cff_parse_fixed_dynamic( data++, &scaling ); scaling = -scaling; if ( scaling < 0 || scaling > 9 ) { /* Return default matrix in case of unlikely values. */ matrix->xx = 0x10000L; matrix->yx = 0; matrix->yx = 0; matrix->yy = 0x10000L; offset->x = 0; offset->y = 0; *upm = 1; goto Exit; } matrix->yx = cff_parse_fixed_scaled( data++, scaling ); matrix->xy = cff_parse_fixed_scaled( data++, scaling ); matrix->yy = cff_parse_fixed_scaled( data++, scaling ); offset->x = cff_parse_fixed_scaled( data++, scaling ); offset->y = cff_parse_fixed_scaled( data, scaling ); *upm = power_tens[scaling]; } Exit: return error; } static FT_Error cff_parse_font_bbox( CFF_Parser parser ) { CFF_FontRecDict dict = (CFF_FontRecDict)parser->object; FT_BBox* bbox = &dict->font_bbox; FT_Byte** data = parser->stack; FT_Error error; error = CFF_Err_Stack_Underflow; if ( parser->top >= parser->stack + 4 ) { bbox->xMin = FT_RoundFix( cff_parse_fixed( data++ ) ); bbox->yMin = FT_RoundFix( cff_parse_fixed( data++ ) ); bbox->xMax = FT_RoundFix( cff_parse_fixed( data++ ) ); bbox->yMax = FT_RoundFix( cff_parse_fixed( data ) ); error = CFF_Err_Ok; } return error; } static FT_Error cff_parse_private_dict( CFF_Parser parser ) { CFF_FontRecDict dict = (CFF_FontRecDict)parser->object; FT_Byte** data = parser->stack; FT_Error error; error = CFF_Err_Stack_Underflow; if ( parser->top >= parser->stack + 2 ) { dict->private_size = cff_parse_num( data++ ); dict->private_offset = cff_parse_num( data ); error = CFF_Err_Ok; } return error; } static FT_Error cff_parse_cid_ros( CFF_Parser parser ) { CFF_FontRecDict dict = (CFF_FontRecDict)parser->object; FT_Byte** data = parser->stack; FT_Error error; error = CFF_Err_Stack_Underflow; if ( parser->top >= parser->stack + 3 ) { dict->cid_registry = (FT_UInt)cff_parse_num ( data++ ); dict->cid_ordering = (FT_UInt)cff_parse_num ( data++ ); dict->cid_supplement = (FT_ULong)cff_parse_num( data ); error = CFF_Err_Ok; } return error; } #define CFF_FIELD_NUM( code, name ) \ CFF_FIELD( code, name, cff_kind_num ) #define CFF_FIELD_FIXED( code, name ) \ CFF_FIELD( code, name, cff_kind_fixed ) #define CFF_FIELD_FIXED_1000( code, name ) \ CFF_FIELD( code, name, cff_kind_fixed_thousand ) #define CFF_FIELD_STRING( code, name ) \ CFF_FIELD( code, name, cff_kind_string ) #define CFF_FIELD_BOOL( code, name ) \ CFF_FIELD( code, name, cff_kind_bool ) #define CFF_FIELD_DELTA( code, name, max ) \ CFF_FIELD( code, name, cff_kind_delta ) #define CFF_FIELD_CALLBACK( code, name ) \ { \ cff_kind_callback, \ code | CFFCODE, \ 0, 0, \ cff_parse_ ## name, \ 0, 0 \ }, #undef CFF_FIELD #define CFF_FIELD( code, name, kind ) \ { \ kind, \ code | CFFCODE, \ FT_FIELD_OFFSET( name ), \ FT_FIELD_SIZE( name ), \ 0, 0, 0 \ }, #undef CFF_FIELD_DELTA #define CFF_FIELD_DELTA( code, name, max ) \ { \ cff_kind_delta, \ code | CFFCODE, \ FT_FIELD_OFFSET( name ), \ FT_FIELD_SIZE_DELTA( name ), \ 0, \ max, \ FT_FIELD_OFFSET( num_ ## name ) \ }, #define CFFCODE_TOPDICT 0x1000 #define CFFCODE_PRIVATE 0x2000 static const CFF_Field_Handler cff_field_handlers[] = { #include "cfftoken.h" { 0, 0, 0, 0, 0, 0, 0 } }; FT_LOCAL_DEF( FT_Error ) cff_parser_run( CFF_Parser parser, FT_Byte* start, FT_Byte* limit ) { FT_Byte* p = start; FT_Error error = CFF_Err_Ok; parser->top = parser->stack; parser->start = start; parser->limit = limit; parser->cursor = start; while ( p < limit ) { FT_UInt v = *p; if ( v >= 27 && v != 31 ) { /* it's a number; we will push its position on the stack */ if ( parser->top - parser->stack >= CFF_MAX_STACK_DEPTH ) goto Stack_Overflow; *parser->top ++ = p; /* now, skip it */ if ( v == 30 ) { /* skip real number */ p++; for (;;) { if ( p >= limit ) goto Syntax_Error; v = p[0] >> 4; if ( v == 15 ) break; v = p[0] & 0xF; if ( v == 15 ) break; p++; } } else if ( v == 28 ) p += 2; else if ( v == 29 ) p += 4; else if ( v > 246 ) p += 1; } else { /* This is not a number, hence it's an operator. Compute its code */ /* and look for it in our current list. */ FT_UInt code; FT_UInt num_args = (FT_UInt) ( parser->top - parser->stack ); const CFF_Field_Handler* field; *parser->top = p; code = v; if ( v == 12 ) { /* two byte operator */ p++; if ( p >= limit ) goto Syntax_Error; code = 0x100 | p[0]; } code = code | parser->object_code; for ( field = cff_field_handlers; field->kind; field++ ) { if ( field->code == (FT_Int)code ) { /* we found our field's handler; read it */ FT_Long val; FT_Byte* q = (FT_Byte*)parser->object + field->offset; /* check that we have enough arguments -- except for */ /* delta encoded arrays, which can be empty */ if ( field->kind != cff_kind_delta && num_args < 1 ) goto Stack_Underflow; switch ( field->kind ) { case cff_kind_bool: case cff_kind_string: case cff_kind_num: val = cff_parse_num( parser->stack ); goto Store_Number; case cff_kind_fixed: val = cff_parse_fixed( parser->stack ); goto Store_Number; case cff_kind_fixed_thousand: val = cff_parse_fixed_scaled( parser->stack, 3 ); Store_Number: switch ( field->size ) { case (8 / FT_CHAR_BIT): *(FT_Byte*)q = (FT_Byte)val; break; case (16 / FT_CHAR_BIT): *(FT_Short*)q = (FT_Short)val; break; case (32 / FT_CHAR_BIT): *(FT_Int32*)q = (FT_Int)val; break; default: /* for 64-bit systems */ *(FT_Long*)q = val; } break; case cff_kind_delta: { FT_Byte* qcount = (FT_Byte*)parser->object + field->count_offset; FT_Byte** data = parser->stack; if ( num_args > field->array_max ) num_args = field->array_max; /* store count */ *qcount = (FT_Byte)num_args; val = 0; while ( num_args > 0 ) { val += cff_parse_num( data++ ); switch ( field->size ) { case (8 / FT_CHAR_BIT): *(FT_Byte*)q = (FT_Byte)val; break; case (16 / FT_CHAR_BIT): *(FT_Short*)q = (FT_Short)val; break; case (32 / FT_CHAR_BIT): *(FT_Int32*)q = (FT_Int)val; break; default: /* for 64-bit systems */ *(FT_Long*)q = val; } q += field->size; num_args--; } } break; default: /* callback */ error = field->reader( parser ); if ( error ) goto Exit; } goto Found; } } /* this is an unknown operator, or it is unsupported; */ /* we will ignore it for now. */ Found: /* clear stack */ parser->top = parser->stack; } p++; } Exit: return error; Stack_Overflow: error = CFF_Err_Invalid_Argument; goto Exit; Stack_Underflow: error = CFF_Err_Invalid_Argument; goto Exit; Syntax_Error: error = CFF_Err_Invalid_Argument; goto Exit; } /* END */