| /**************************************************************************** |
| * |
| * pfrload.c |
| * |
| * FreeType PFR loader (body). |
| * |
| * Copyright (C) 2002-2021 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 <freetype/internal/ftdebug.h> |
| #include <freetype/internal/ftstream.h> |
| |
| #include "pfrerror.h" |
| |
| #undef FT_COMPONENT |
| #define FT_COMPONENT pfr |
| |
| |
| /* |
| * The overall structure of a PFR file is as follows. |
| * |
| * PFR header |
| * 58 bytes (contains nPhysFonts) |
| * |
| * Logical font directory (size at most 2^16 bytes) |
| * 2 bytes (nLogFonts) |
| * + nLogFonts * 5 bytes |
| * |
| * ==> nLogFonts <= 13106 |
| * |
| * Logical font section (size at most 2^24 bytes) |
| * nLogFonts * logFontRecord |
| * |
| * logFontRecord (size at most 2^16 bytes) |
| * 12 bytes (fontMatrix) |
| * + 1 byte (flags) |
| * + 0-5 bytes (depending on `flags') |
| * + 0-(1+255*(2+255)) = 0-65536 (depending on `flags') |
| * + 5 bytes (physical font info) |
| * + 0-1 bytes (depending on PFR header) |
| * |
| * ==> minimum size 18 bytes |
| * |
| * Physical font section (size at most 2^24 bytes) |
| * nPhysFonts * (physFontRecord |
| * + nBitmapSizes * nBmapChars * bmapCharRecord) |
| * |
| * physFontRecord (size at most 2^24 bytes) |
| * 14 bytes (font info) |
| * + 1 byte (flags) |
| * + 0-2 (depending on `flags') |
| * + 0-? (structure too complicated to be shown here; depending on |
| * `flags'; contains `nBitmapSizes' and `nBmapChars') |
| * + 3 bytes (nAuxBytes) |
| * + nAuxBytes |
| * + 1 byte (nBlueValues) |
| * + 2 * nBlueValues |
| * + 6 bytes (hinting data) |
| * + 2 bytes (nCharacters) |
| * + nCharacters * (4-10 bytes) (depending on `flags') |
| * |
| * ==> minimum size 27 bytes |
| * |
| * bmapCharRecord |
| * 4-7 bytes |
| * |
| * Glyph program strings (three possible types: simpleGps, compoundGps, |
| * and bitmapGps; size at most 2^24 bytes) |
| * simpleGps (size at most 2^16 bytes) |
| * 1 byte (flags) |
| * 1-2 bytes (n[XY]orus, depending on `flags') |
| * 0-(64+512*2) = 0-1088 bytes (depending on `n[XY]orus') |
| * 0-? (structure too complicated to be shown here; depending on |
| * `flags') |
| * 1-? glyph data (faintly resembling PS Type 1 charstrings) |
| * |
| * ==> minimum size 3 bytes |
| * |
| * compoundGps (size at most 2^16 bytes) |
| * 1 byte (nElements <= 63, flags) |
| * + 0-(1+255*(2+255)) = 0-65536 (depending on `flags') |
| * + nElements * (6-14 bytes) |
| * |
| * bitmapGps (size at most 2^16 bytes) |
| * 1 byte (flags) |
| * 3-13 bytes (position info, depending on `flags') |
| * 0-? bitmap data |
| * |
| * ==> minimum size 4 bytes |
| * |
| * PFR trailer |
| * 8 bytes |
| * |
| * |
| * ==> minimum size of a valid PFR: |
| * 58 (header) |
| * + 2 (nLogFonts) |
| * + 27 (1 physFontRecord) |
| * + 8 (trailer) |
| * ----- |
| * 95 bytes |
| * |
| */ |
| |
| |
| /*************************************************************************/ |
| /*************************************************************************/ |
| /***** *****/ |
| /***** EXTRA ITEMS *****/ |
| /***** *****/ |
| /*************************************************************************/ |
| /*************************************************************************/ |
| |
| |
| FT_LOCAL_DEF( FT_Error ) |
| pfr_extra_items_skip( FT_Byte* *pp, |
| FT_Byte* limit ) |
| { |
| return pfr_extra_items_parse( pp, limit, NULL, NULL ); |
| } |
| |
| |
| FT_LOCAL_DEF( FT_Error ) |
| pfr_extra_items_parse( FT_Byte* *pp, |
| FT_Byte* limit, |
| PFR_ExtraItem item_list, |
| FT_Pointer item_data ) |
| { |
| FT_Error error = FT_Err_Ok; |
| FT_Byte* p = *pp; |
| FT_UInt num_items, item_type, item_size; |
| |
| |
| 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( item_size ); |
| |
| if ( item_list ) |
| { |
| PFR_ExtraItem extra = item_list; |
| |
| |
| for ( extra = item_list; extra->parser != NULL; extra++ ) |
| { |
| if ( extra->type == item_type ) |
| { |
| error = extra->parser( p, p + item_size, item_data ); |
| if ( error ) |
| goto Exit; |
| |
| break; |
| } |
| } |
| } |
| |
| p += item_size; |
| } |
| |
| Exit: |
| *pp = p; |
| return error; |
| |
| Too_Short: |
| FT_ERROR(( "pfr_extra_items_parse: invalid extra items table\n" )); |
| error = FT_THROW( Invalid_Table ); |
| goto Exit; |
| } |
| |
| |
| /*************************************************************************/ |
| /*************************************************************************/ |
| /***** *****/ |
| /***** PFR HEADER *****/ |
| /***** *****/ |
| /*************************************************************************/ |
| /*************************************************************************/ |
| |
| 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_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( 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_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_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_END |
| }; |
| |
| |
| FT_LOCAL_DEF( FT_Error ) |
| pfr_header_load( PFR_Header header, |
| FT_Stream stream ) |
| { |
| FT_Error error; |
| |
| |
| /* read header directly */ |
| if ( !FT_STREAM_SEEK( 0 ) && |
| !FT_STREAM_READ_FIELDS( pfr_header_fields, header ) ) |
| { |
| /* make a few adjustments to the header */ |
| header->phy_font_max_size += |
| (FT_UInt32)header->phy_font_max_size_high << 16; |
| } |
| |
| return error; |
| } |
| |
| |
| FT_LOCAL_DEF( FT_Bool ) |
| pfr_header_check( PFR_Header header ) |
| { |
| FT_Bool result = 1; |
| |
| |
| /* check signature and header size */ |
| if ( header->signature != 0x50465230L || /* "PFR0" */ |
| header->version > 4 || |
| header->header_size < 58 || |
| header->signature2 != 0x0D0A ) /* CR/LF */ |
| { |
| result = 0; |
| } |
| |
| return result; |
| } |
| |
| |
| /***********************************************************************/ |
| /***********************************************************************/ |
| /***** *****/ |
| /***** PFR LOGICAL FONTS *****/ |
| /***** *****/ |
| /***********************************************************************/ |
| /***********************************************************************/ |
| |
| |
| FT_LOCAL_DEF( FT_Error ) |
| pfr_log_font_count( FT_Stream stream, |
| FT_UInt32 section_offset, |
| FT_Long *acount ) |
| { |
| FT_Error error; |
| FT_UInt count; |
| FT_UInt result = 0; |
| |
| |
| if ( FT_STREAM_SEEK( section_offset ) || |
| FT_READ_USHORT( count ) ) |
| goto Exit; |
| |
| /* check maximum value and a rough minimum size: */ |
| /* - no more than 13106 log fonts */ |
| /* - we need 5 bytes for a log header record */ |
| /* - we need at least 18 bytes for a log font record */ |
| /* - the overall size is at least 95 bytes plus the */ |
| /* log header and log font records */ |
| if ( count > ( ( 1 << 16 ) - 2 ) / 5 || |
| 2 + count * 5 >= stream->size - section_offset || |
| 95 + count * ( 5 + 18 ) >= stream->size ) |
| { |
| FT_ERROR(( "pfr_log_font_count:" |
| " invalid number of logical fonts\n" )); |
| error = FT_THROW( Invalid_Table ); |
| goto Exit; |
| } |
| |
| result = count; |
| |
| Exit: |
| *acount = (FT_Long)result; |
| return error; |
| } |
| |
| |
| FT_LOCAL_DEF( FT_Error ) |
| pfr_log_font_load( PFR_LogFont log_font, |
| FT_Stream stream, |
| FT_UInt idx, |
| FT_UInt32 section_offset, |
| FT_Bool size_increment ) |
| { |
| FT_UInt num_log_fonts; |
| FT_UInt flags; |
| FT_UInt32 offset; |
| FT_UInt32 size; |
| FT_Error error; |
| |
| |
| if ( FT_STREAM_SEEK( section_offset ) || |
| FT_READ_USHORT( num_log_fonts ) ) |
| goto Exit; |
| |
| if ( idx >= num_log_fonts ) |
| return FT_THROW( Invalid_Argument ); |
| |
| if ( FT_STREAM_SKIP( idx * 5 ) || |
| FT_READ_USHORT( size ) || |
| FT_READ_UOFF3 ( offset ) ) |
| goto Exit; |
| |
| /* save logical font size and offset */ |
| log_font->size = size; |
| log_font->offset = offset; |
| |
| /* now, check the rest of the table before loading it */ |
| { |
| FT_Byte* p; |
| FT_Byte* limit; |
| FT_UInt local; |
| |
| |
| if ( FT_STREAM_SEEK( offset ) || |
| FT_FRAME_ENTER( size ) ) |
| goto Exit; |
| |
| p = stream->cursor; |
| limit = p + size; |
| |
| 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 ); |
| |
| flags = PFR_NEXT_BYTE( p ); |
| |
| local = 0; |
| if ( flags & PFR_LOG_STROKE ) |
| { |
| local++; |
| if ( flags & PFR_LOG_2BYTE_STROKE ) |
| local++; |
| |
| if ( ( flags & PFR_LINE_JOIN_MASK ) == PFR_LINE_JOIN_MITER ) |
| local += 3; |
| } |
| if ( flags & PFR_LOG_BOLD ) |
| { |
| local++; |
| if ( flags & PFR_LOG_2BYTE_BOLD ) |
| 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 ); |
| |
| 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 ); |
| } |
| |
| if ( flags & PFR_LOG_EXTRA_ITEMS ) |
| { |
| error = pfr_extra_items_skip( &p, limit ); |
| if ( error ) |
| goto Fail; |
| } |
| |
| PFR_CHECK( 5 ); |
| 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; |
| } |
| } |
| |
| Fail: |
| FT_FRAME_EXIT(); |
| |
| Exit: |
| return error; |
| |
| Too_Short: |
| FT_ERROR(( "pfr_log_font_load: invalid logical font table\n" )); |
| error = FT_THROW( Invalid_Table ); |
| goto Fail; |
| } |
| |
| |
| /***********************************************************************/ |
| /***********************************************************************/ |
| /***** *****/ |
| /***** PFR PHYSICAL FONTS *****/ |
| /***** *****/ |
| /***********************************************************************/ |
| /***********************************************************************/ |
| |
| |
| /* load bitmap strikes lists */ |
| FT_CALLBACK_DEF( FT_Error ) |
| pfr_extra_item_load_bitmap_info( FT_Byte* p, |
| FT_Byte* limit, |
| PFR_PhyFont phy_font ) |
| { |
| FT_Memory memory = phy_font->memory; |
| PFR_Strike strike; |
| FT_UInt flags0; |
| FT_UInt n, count, size1; |
| FT_Error error = FT_Err_Ok; |
| |
| |
| PFR_CHECK( 5 ); |
| |
| p += 3; /* skip bctSize */ |
| 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 = FT_PAD_CEIL( phy_font->num_strikes + count, 4 ); |
| |
| |
| if ( FT_RENEW_ARRAY( phy_font->strikes, |
| phy_font->num_strikes, |
| new_max ) ) |
| goto Exit; |
| |
| phy_font->max_strikes = new_max; |
| } |
| |
| size1 = 1 + 1 + 1 + 2 + 2 + 1; |
| if ( flags0 & PFR_STRIKE_2BYTE_XPPM ) |
| size1++; |
| |
| if ( flags0 & PFR_STRIKE_2BYTE_YPPM ) |
| size1++; |
| |
| if ( flags0 & PFR_STRIKE_3BYTE_SIZE ) |
| size1++; |
| |
| if ( flags0 & PFR_STRIKE_3BYTE_OFFSET ) |
| size1++; |
| |
| if ( flags0 & PFR_STRIKE_2BYTE_COUNT ) |
| size1++; |
| |
| strike = phy_font->strikes + phy_font->num_strikes; |
| |
| 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 ); |
| |
| strike->y_ppm = ( flags0 & PFR_STRIKE_2BYTE_YPPM ) |
| ? PFR_NEXT_USHORT( p ) |
| : 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 ); |
| |
| strike->bct_offset = ( flags0 & PFR_STRIKE_3BYTE_OFFSET ) |
| ? PFR_NEXT_ULONG( p ) |
| : PFR_NEXT_USHORT( p ); |
| |
| strike->num_bitmaps = ( flags0 & PFR_STRIKE_2BYTE_COUNT ) |
| ? PFR_NEXT_USHORT( p ) |
| : PFR_NEXT_BYTE( p ); |
| } |
| |
| phy_font->num_strikes += count; |
| |
| Exit: |
| return error; |
| |
| Too_Short: |
| error = FT_THROW( Invalid_Table ); |
| FT_ERROR(( "pfr_extra_item_load_bitmap_info:" |
| " invalid bitmap info table\n" )); |
| goto Exit; |
| } |
| |
| |
| /* Load font ID. This is a so-called `unique' name that is rather |
| * long and descriptive (like `Tiresias ScreenFont v7.51'). |
| * |
| * Note that a PFR font's family name is contained in an *undocumented* |
| * string of the `auxiliary data' portion of a physical font record. This |
| * may also contain the `real' style name! |
| * |
| * If no family name is present, the font ID is used instead for the |
| * family. |
| */ |
| FT_CALLBACK_DEF( FT_Error ) |
| pfr_extra_item_load_font_id( FT_Byte* p, |
| FT_Byte* limit, |
| PFR_PhyFont phy_font ) |
| { |
| FT_Error error = FT_Err_Ok; |
| FT_Memory memory = phy_font->memory; |
| FT_UInt len = (FT_UInt)( limit - p ); |
| |
| |
| if ( phy_font->font_id ) |
| goto Exit; |
| |
| if ( FT_QALLOC( phy_font->font_id, len + 1 ) ) |
| goto Exit; |
| |
| /* copy font ID name, and terminate it for safety */ |
| FT_MEM_COPY( phy_font->font_id, p, len ); |
| phy_font->font_id[len] = 0; |
| |
| Exit: |
| return error; |
| } |
| |
| |
| /* 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 = NULL; |
| FT_Error error = FT_Err_Ok; |
| FT_Memory memory = phy_font->memory; |
| |
| |
| if ( phy_font->vertical.stem_snaps ) |
| goto Exit; |
| |
| 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 ); |
| |
| if ( FT_QNEW_ARRAY( snaps, count ) ) |
| goto Exit; |
| |
| phy_font->vertical.stem_snaps = snaps; |
| phy_font->horizontal.stem_snaps = snaps + num_vert; |
| |
| for ( ; count > 0; count--, snaps++ ) |
| *snaps = FT_NEXT_SHORT( p ); |
| |
| Exit: |
| return error; |
| |
| Too_Short: |
| error = FT_THROW( Invalid_Table ); |
| FT_ERROR(( "pfr_extra_item_load_stem_snaps:" |
| " invalid stem snaps table\n" )); |
| goto Exit; |
| } |
| |
| |
| |
| /* load kerning pair data */ |
| FT_CALLBACK_DEF( FT_Error ) |
| pfr_extra_item_load_kerning_pairs( FT_Byte* p, |
| FT_Byte* limit, |
| PFR_PhyFont phy_font ) |
| { |
| PFR_KernItem item = NULL; |
| FT_Error error = FT_Err_Ok; |
| FT_Memory memory = phy_font->memory; |
| |
| |
| if ( FT_NEW( item ) ) |
| goto Exit; |
| |
| PFR_CHECK( 4 ); |
| |
| item->pair_count = PFR_NEXT_BYTE( p ); |
| item->base_adj = PFR_NEXT_SHORT( p ); |
| item->flags = PFR_NEXT_BYTE( p ); |
| item->offset = phy_font->offset + |
| (FT_Offset)( p - phy_font->cursor ); |
| |
| #ifndef PFR_CONFIG_NO_CHECKS |
| item->pair_size = 3; |
| |
| if ( item->flags & PFR_KERN_2BYTE_CHAR ) |
| item->pair_size += 2; |
| |
| if ( item->flags & PFR_KERN_2BYTE_ADJ ) |
| item->pair_size += 1; |
| |
| PFR_CHECK( item->pair_count * item->pair_size ); |
| #endif |
| |
| /* load first and last pairs into the item to speed up */ |
| /* lookup later... */ |
| if ( item->pair_count > 0 ) |
| { |
| FT_UInt char1, char2; |
| FT_Byte* q; |
| |
| |
| if ( item->flags & PFR_KERN_2BYTE_CHAR ) |
| { |
| q = p; |
| char1 = PFR_NEXT_USHORT( q ); |
| char2 = PFR_NEXT_USHORT( q ); |
| |
| item->pair1 = PFR_KERN_INDEX( char1, char2 ); |
| |
| q = p + item->pair_size * ( item->pair_count - 1 ); |
| char1 = PFR_NEXT_USHORT( q ); |
| char2 = PFR_NEXT_USHORT( q ); |
| |
| item->pair2 = PFR_KERN_INDEX( char1, char2 ); |
| } |
| else |
| { |
| q = p; |
| char1 = PFR_NEXT_BYTE( q ); |
| char2 = PFR_NEXT_BYTE( q ); |
| |
| item->pair1 = PFR_KERN_INDEX( char1, char2 ); |
| |
| q = p + item->pair_size * ( item->pair_count - 1 ); |
| char1 = PFR_NEXT_BYTE( q ); |
| char2 = PFR_NEXT_BYTE( q ); |
| |
| item->pair2 = PFR_KERN_INDEX( char1, char2 ); |
| } |
| |
| /* add new item to the current list */ |
| item->next = NULL; |
| *phy_font->kern_items_tail = item; |
| phy_font->kern_items_tail = &item->next; |
| phy_font->num_kern_pairs += item->pair_count; |
| } |
| else |
| { |
| /* empty item! */ |
| FT_FREE( item ); |
| } |
| |
| Exit: |
| return error; |
| |
| Too_Short: |
| FT_FREE( item ); |
| |
| error = FT_THROW( Invalid_Table ); |
| FT_ERROR(( "pfr_extra_item_load_kerning_pairs:" |
| " invalid kerning pairs table\n" )); |
| goto Exit; |
| } |
| |
| |
| 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 }, |
| { 3, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_stem_snaps }, |
| { 4, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_kerning_pairs }, |
| { 0, NULL } |
| }; |
| |
| |
| /* |
| * Load a name from the auxiliary data. Since this extracts undocumented |
| * strings from the font file, we need to be careful here. |
| */ |
| static FT_Error |
| pfr_aux_name_load( FT_Byte* p, |
| FT_UInt len, |
| FT_Memory memory, |
| FT_String* *astring ) |
| { |
| FT_Error error = FT_Err_Ok; |
| FT_String* result = NULL; |
| FT_UInt n, ok; |
| |
| |
| if ( *astring ) |
| FT_FREE( *astring ); |
| |
| if ( len > 0 && p[len - 1] == 0 ) |
| len--; |
| |
| /* check that each character is ASCII */ |
| /* for making sure not to load garbage */ |
| ok = ( len > 0 ); |
| for ( n = 0; n < len; n++ ) |
| if ( p[n] < 32 || p[n] > 127 ) |
| { |
| ok = 0; |
| break; |
| } |
| |
| if ( ok ) |
| { |
| if ( FT_QALLOC( result, len + 1 ) ) |
| goto Exit; |
| |
| FT_MEM_COPY( result, p, len ); |
| result[len] = 0; |
| } |
| |
| Exit: |
| *astring = result; |
| return error; |
| } |
| |
| |
| FT_LOCAL_DEF( void ) |
| pfr_phy_font_done( PFR_PhyFont phy_font, |
| FT_Memory memory ) |
| { |
| FT_FREE( phy_font->font_id ); |
| FT_FREE( phy_font->family_name ); |
| FT_FREE( phy_font->style_name ); |
| |
| FT_FREE( phy_font->vertical.stem_snaps ); |
| phy_font->vertical.num_stem_snaps = 0; |
| |
| phy_font->horizontal.stem_snaps = NULL; |
| phy_font->horizontal.num_stem_snaps = 0; |
| |
| FT_FREE( phy_font->strikes ); |
| phy_font->num_strikes = 0; |
| phy_font->max_strikes = 0; |
| |
| FT_FREE( phy_font->chars ); |
| phy_font->num_chars = 0; |
| phy_font->chars_offset = 0; |
| |
| FT_FREE( phy_font->blue_values ); |
| phy_font->num_blue_values = 0; |
| |
| { |
| PFR_KernItem item, next; |
| |
| |
| item = phy_font->kern_items; |
| while ( item ) |
| { |
| next = item->next; |
| FT_FREE( item ); |
| item = next; |
| } |
| phy_font->kern_items = NULL; |
| phy_font->kern_items_tail = NULL; |
| } |
| |
| phy_font->num_kern_pairs = 0; |
| } |
| |
| |
| FT_LOCAL_DEF( FT_Error ) |
| 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; |
| FT_UInt flags; |
| FT_ULong num_aux; |
| FT_Byte* p; |
| FT_Byte* limit; |
| |
| |
| phy_font->memory = memory; |
| phy_font->offset = offset; |
| |
| phy_font->kern_items = NULL; |
| phy_font->kern_items_tail = &phy_font->kern_items; |
| |
| if ( FT_STREAM_SEEK( offset ) || |
| FT_FRAME_ENTER( size ) ) |
| goto Exit; |
| |
| phy_font->cursor = stream->cursor; |
| |
| p = stream->cursor; |
| 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 ); |
| |
| /* get the standard advance for non-proportional fonts */ |
| if ( !(flags & PFR_PHY_PROPORTIONAL) ) |
| { |
| 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 ); |
| |
| if ( error ) |
| goto Fail; |
| } |
| |
| /* In certain fonts, the auxiliary bytes contain interesting */ |
| /* information. These are not in the specification but can be */ |
| /* guessed by looking at the content of a few PFR0 fonts. */ |
| PFR_CHECK( 3 ); |
| num_aux = PFR_NEXT_ULONG( p ); |
| |
| if ( num_aux > 0 ) |
| { |
| FT_Byte* q = p; |
| FT_Byte* q2; |
| |
| |
| PFR_CHECK_SIZE( num_aux ); |
| p += num_aux; |
| |
| while ( num_aux > 0 ) |
| { |
| FT_UInt length, type; |
| |
| |
| if ( q + 4 > p ) |
| break; |
| |
| length = PFR_NEXT_USHORT( q ); |
| if ( length < 4 || length > num_aux ) |
| break; |
| |
| q2 = q + length - 2; |
| type = PFR_NEXT_USHORT( q ); |
| |
| switch ( type ) |
| { |
| case 1: |
| /* this seems to correspond to the font's family name, padded to */ |
| /* an even number of bytes with a zero byte appended if needed */ |
| error = pfr_aux_name_load( q, length - 4U, memory, |
| &phy_font->family_name ); |
| if ( error ) |
| goto Exit; |
| break; |
| |
| case 2: |
| if ( q + 32 > q2 ) |
| break; |
| |
| q += 10; |
| phy_font->ascent = PFR_NEXT_SHORT( q ); |
| phy_font->descent = PFR_NEXT_SHORT( q ); |
| phy_font->leading = PFR_NEXT_SHORT( q ); |
| break; |
| |
| case 3: |
| /* this seems to correspond to the font's style name, padded to */ |
| /* an even number of bytes with a zero byte appended if needed */ |
| error = pfr_aux_name_load( q, length - 4U, memory, |
| &phy_font->style_name ); |
| if ( error ) |
| goto Exit; |
| break; |
| |
| default: |
| ; |
| } |
| |
| q = q2; |
| num_aux -= length; |
| } |
| } |
| |
| /* read the blue values */ |
| { |
| FT_UInt n, count; |
| |
| |
| PFR_CHECK( 1 ); |
| phy_font->num_blue_values = count = PFR_NEXT_BYTE( p ); |
| |
| PFR_CHECK( count * 2 ); |
| |
| if ( FT_QNEW_ARRAY( phy_font->blue_values, count ) ) |
| goto Fail; |
| |
| for ( n = 0; n < count; n++ ) |
| 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 ); |
| |
| 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; |
| |
| |
| phy_font->num_chars = count = PFR_NEXT_USHORT( p ); |
| phy_font->chars_offset = offset + (FT_Offset)( p - stream->cursor ); |
| |
| Size = 1 + 1 + 2; |
| if ( flags & PFR_PHY_2BYTE_CHARCODE ) |
| Size += 1; |
| |
| if ( flags & PFR_PHY_PROPORTIONAL ) |
| Size += 2; |
| |
| if ( flags & PFR_PHY_ASCII_CODE ) |
| Size += 1; |
| |
| if ( flags & PFR_PHY_2BYTE_GPS_SIZE ) |
| Size += 1; |
| |
| if ( flags & PFR_PHY_3BYTE_GPS_OFFSET ) |
| Size += 1; |
| |
| PFR_CHECK_SIZE( count * Size ); |
| |
| if ( FT_NEW_ARRAY( phy_font->chars, count ) ) |
| goto Fail; |
| |
| for ( n = 0; n < count; 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 ) |
| : phy_font->standard_advance; |
| |
| #if 0 |
| cur->ascii = ( flags & PFR_PHY_ASCII_CODE ) |
| ? PFR_NEXT_BYTE( p ) |
| : 0; |
| #else |
| 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_offset = ( flags & PFR_PHY_3BYTE_GPS_OFFSET ) |
| ? PFR_NEXT_ULONG( p ) |
| : PFR_NEXT_USHORT( p ); |
| } |
| } |
| |
| /* that's it! */ |
| |
| Fail: |
| FT_FRAME_EXIT(); |
| |
| /* save position of bitmap info */ |
| phy_font->bct_offset = FT_STREAM_POS(); |
| phy_font->cursor = NULL; |
| |
| Exit: |
| return error; |
| |
| Too_Short: |
| error = FT_THROW( Invalid_Table ); |
| FT_ERROR(( "pfr_phy_font_load: invalid physical font table\n" )); |
| goto Fail; |
| } |
| |
| |
| /* END */ |
