1100 lines
39 KiB
C
1100 lines
39 KiB
C
/***************************************************************************/
|
|
/* */
|
|
/* ttcmap.c */
|
|
/* */
|
|
/* TrueType character mapping table (cmap) support (body). */
|
|
/* */
|
|
/* Copyright 1996-2001 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 "ttload.h"
|
|
#include "ttcmap.h"
|
|
|
|
#include "sferrors.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_ttcmap
|
|
|
|
|
|
FT_CALLBACK_DEF( FT_UInt )
|
|
code_to_index0( TT_CMapTable* charmap,
|
|
FT_ULong char_code );
|
|
|
|
FT_CALLBACK_DEF( FT_ULong )
|
|
code_to_next0( TT_CMapTable* charmap,
|
|
FT_ULong char_code );
|
|
|
|
FT_CALLBACK_DEF( FT_UInt )
|
|
code_to_index2( TT_CMapTable* charmap,
|
|
FT_ULong char_code );
|
|
|
|
FT_CALLBACK_DEF( FT_ULong )
|
|
code_to_next2( TT_CMapTable* charmap,
|
|
FT_ULong char_code );
|
|
|
|
FT_CALLBACK_DEF( FT_UInt )
|
|
code_to_index4( TT_CMapTable* charmap,
|
|
FT_ULong char_code );
|
|
|
|
FT_CALLBACK_DEF( FT_ULong )
|
|
code_to_next4( TT_CMapTable* charmap,
|
|
FT_ULong char_code );
|
|
|
|
FT_CALLBACK_DEF( FT_UInt )
|
|
code_to_index6( TT_CMapTable* charmap,
|
|
FT_ULong char_code );
|
|
|
|
FT_CALLBACK_DEF( FT_ULong )
|
|
code_to_next6( TT_CMapTable* charmap,
|
|
FT_ULong char_code );
|
|
|
|
FT_CALLBACK_DEF( FT_UInt )
|
|
code_to_index8_12( TT_CMapTable* charmap,
|
|
FT_ULong char_code );
|
|
|
|
FT_CALLBACK_DEF( FT_ULong )
|
|
code_to_next8_12( TT_CMapTable* charmap,
|
|
FT_ULong char_code );
|
|
|
|
FT_CALLBACK_DEF( FT_UInt )
|
|
code_to_index10( TT_CMapTable* charmap,
|
|
FT_ULong char_code );
|
|
|
|
FT_CALLBACK_DEF( FT_ULong )
|
|
code_to_next10( TT_CMapTable* charmap,
|
|
FT_ULong char_code );
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <Function> */
|
|
/* TT_CharMap_Load */
|
|
/* */
|
|
/* <Description> */
|
|
/* Loads a given TrueType character map into memory. */
|
|
/* */
|
|
/* <Input> */
|
|
/* face :: A handle to the parent face object. */
|
|
/* stream :: A handle to the current stream object. */
|
|
/* */
|
|
/* <InOut> */
|
|
/* table :: A pointer to a cmap object. */
|
|
/* */
|
|
/* <Return> */
|
|
/* FreeType error code. 0 means success. */
|
|
/* */
|
|
/* <Note> */
|
|
/* The function assumes that the stream is already in use (i.e., */
|
|
/* opened). In case of error, all partially allocated tables are */
|
|
/* released. */
|
|
/* */
|
|
FT_LOCAL_DEF FT_Error
|
|
TT_CharMap_Load( TT_Face face,
|
|
TT_CMapTable* cmap,
|
|
FT_Stream stream )
|
|
{
|
|
FT_Error error;
|
|
FT_Memory memory;
|
|
FT_UShort num_SH, num_Seg, i;
|
|
FT_ULong j, n;
|
|
|
|
FT_UShort u, l;
|
|
|
|
TT_CMap0* cmap0;
|
|
TT_CMap2* cmap2;
|
|
TT_CMap4* cmap4;
|
|
TT_CMap6* cmap6;
|
|
TT_CMap8_12* cmap8_12;
|
|
TT_CMap10* cmap10;
|
|
|
|
TT_CMap2SubHeader* cmap2sub;
|
|
TT_CMap4Segment* segments;
|
|
TT_CMapGroup* groups;
|
|
|
|
|
|
if ( cmap->loaded )
|
|
return SFNT_Err_Ok;
|
|
|
|
memory = stream->memory;
|
|
|
|
if ( FILE_Seek( cmap->offset ) )
|
|
return error;
|
|
|
|
switch ( cmap->format )
|
|
{
|
|
case 0:
|
|
cmap0 = &cmap->c.cmap0;
|
|
|
|
if ( READ_UShort( cmap0->language ) ||
|
|
ALLOC( cmap0->glyphIdArray, 256L ) ||
|
|
FILE_Read( cmap0->glyphIdArray, 256L ) )
|
|
goto Fail;
|
|
|
|
cmap->get_index = code_to_index0;
|
|
cmap->get_next_char = code_to_next0;
|
|
break;
|
|
|
|
case 2:
|
|
num_SH = 0;
|
|
cmap2 = &cmap->c.cmap2;
|
|
|
|
/* allocate subheader keys */
|
|
|
|
if ( ALLOC_ARRAY( cmap2->subHeaderKeys, 256, FT_UShort ) ||
|
|
ACCESS_Frame( 2L + 512L ) )
|
|
goto Fail;
|
|
|
|
cmap2->language = GET_UShort();
|
|
|
|
for ( i = 0; i < 256; i++ )
|
|
{
|
|
u = (FT_UShort)( GET_UShort() / 8 );
|
|
cmap2->subHeaderKeys[i] = u;
|
|
|
|
if ( num_SH < u )
|
|
num_SH = u;
|
|
}
|
|
|
|
FORGET_Frame();
|
|
|
|
/* load subheaders */
|
|
|
|
cmap2->numGlyphId = l = (FT_UShort)(
|
|
( ( cmap->length - 2L * ( 256 + 3 ) - num_SH * 8L ) & 0xFFFF ) / 2 );
|
|
|
|
if ( ALLOC_ARRAY( cmap2->subHeaders,
|
|
num_SH + 1,
|
|
TT_CMap2SubHeader ) ||
|
|
ACCESS_Frame( ( num_SH + 1 ) * 8L ) )
|
|
{
|
|
FREE( cmap2->subHeaderKeys );
|
|
goto Fail;
|
|
}
|
|
|
|
cmap2sub = cmap2->subHeaders;
|
|
|
|
for ( i = 0; i <= num_SH; i++ )
|
|
{
|
|
cmap2sub->firstCode = GET_UShort();
|
|
cmap2sub->entryCount = GET_UShort();
|
|
cmap2sub->idDelta = GET_Short();
|
|
/* we apply the location offset immediately */
|
|
cmap2sub->idRangeOffset = (FT_UShort)(
|
|
GET_UShort() - ( num_SH - i ) * 8 - 2 );
|
|
|
|
cmap2sub++;
|
|
}
|
|
|
|
FORGET_Frame();
|
|
|
|
/* load glyph IDs */
|
|
|
|
if ( ALLOC_ARRAY( cmap2->glyphIdArray, l, FT_UShort ) ||
|
|
ACCESS_Frame( l * 2L ) )
|
|
{
|
|
FREE( cmap2->subHeaders );
|
|
FREE( cmap2->subHeaderKeys );
|
|
goto Fail;
|
|
}
|
|
|
|
for ( i = 0; i < l; i++ )
|
|
cmap2->glyphIdArray[i] = GET_UShort();
|
|
|
|
FORGET_Frame();
|
|
|
|
cmap->get_index = code_to_index2;
|
|
cmap->get_next_char = code_to_next2;
|
|
break;
|
|
|
|
case 4:
|
|
cmap4 = &cmap->c.cmap4;
|
|
|
|
/* load header */
|
|
|
|
if ( ACCESS_Frame( 10L ) )
|
|
goto Fail;
|
|
|
|
cmap4->language = GET_UShort();
|
|
cmap4->segCountX2 = GET_UShort();
|
|
cmap4->searchRange = GET_UShort();
|
|
cmap4->entrySelector = GET_UShort();
|
|
cmap4->rangeShift = GET_UShort();
|
|
|
|
num_Seg = (FT_UShort)( cmap4->segCountX2 / 2 );
|
|
|
|
FORGET_Frame();
|
|
|
|
/* load segments */
|
|
|
|
if ( ALLOC_ARRAY( cmap4->segments,
|
|
num_Seg,
|
|
TT_CMap4Segment ) ||
|
|
ACCESS_Frame( ( num_Seg * 4 + 1 ) * 2L ) )
|
|
goto Fail;
|
|
|
|
segments = cmap4->segments;
|
|
|
|
for ( i = 0; i < num_Seg; i++ )
|
|
segments[i].endCount = GET_UShort();
|
|
|
|
(void)GET_UShort();
|
|
|
|
for ( i = 0; i < num_Seg; i++ )
|
|
segments[i].startCount = GET_UShort();
|
|
|
|
for ( i = 0; i < num_Seg; i++ )
|
|
segments[i].idDelta = GET_Short();
|
|
|
|
for ( i = 0; i < num_Seg; i++ )
|
|
segments[i].idRangeOffset = GET_UShort();
|
|
|
|
FORGET_Frame();
|
|
|
|
cmap4->numGlyphId = l = (FT_UShort)(
|
|
( ( cmap->length - ( 16L + 8L * num_Seg ) ) & 0xFFFF ) / 2 );
|
|
|
|
/* load IDs */
|
|
|
|
if ( ALLOC_ARRAY( cmap4->glyphIdArray, l, FT_UShort ) ||
|
|
ACCESS_Frame( l * 2L ) )
|
|
{
|
|
FREE( cmap4->segments );
|
|
goto Fail;
|
|
}
|
|
|
|
for ( i = 0; i < l; i++ )
|
|
cmap4->glyphIdArray[i] = GET_UShort();
|
|
|
|
FORGET_Frame();
|
|
|
|
cmap4->last_segment = cmap4->segments;
|
|
|
|
cmap->get_index = code_to_index4;
|
|
cmap->get_next_char = code_to_next4;
|
|
break;
|
|
|
|
case 6:
|
|
cmap6 = &cmap->c.cmap6;
|
|
|
|
if ( ACCESS_Frame( 6L ) )
|
|
goto Fail;
|
|
|
|
cmap6->language = GET_UShort();
|
|
cmap6->firstCode = GET_UShort();
|
|
cmap6->entryCount = GET_UShort();
|
|
|
|
FORGET_Frame();
|
|
|
|
l = cmap6->entryCount;
|
|
|
|
if ( ALLOC_ARRAY( cmap6->glyphIdArray, l, FT_Short ) ||
|
|
ACCESS_Frame( l * 2L ) )
|
|
goto Fail;
|
|
|
|
for ( i = 0; i < l; i++ )
|
|
cmap6->glyphIdArray[i] = GET_UShort();
|
|
|
|
FORGET_Frame();
|
|
cmap->get_index = code_to_index6;
|
|
cmap->get_next_char = code_to_next6;
|
|
break;
|
|
|
|
case 8:
|
|
case 12:
|
|
cmap8_12 = &cmap->c.cmap8_12;
|
|
|
|
if ( ACCESS_Frame( 8L ) )
|
|
goto Fail;
|
|
|
|
cmap->length = GET_ULong();
|
|
cmap8_12->language = GET_ULong();
|
|
|
|
FORGET_Frame();
|
|
|
|
if ( cmap->format == 8 )
|
|
if ( FILE_Skip( 8192L ) )
|
|
goto Fail;
|
|
|
|
if ( READ_ULong( cmap8_12->nGroups ) )
|
|
goto Fail;
|
|
|
|
n = cmap8_12->nGroups;
|
|
|
|
if ( ALLOC_ARRAY( cmap8_12->groups, n, TT_CMapGroup ) ||
|
|
ACCESS_Frame( n * 3 * 4L ) )
|
|
goto Fail;
|
|
|
|
groups = cmap8_12->groups;
|
|
|
|
for ( j = 0; j < n; j++ )
|
|
{
|
|
groups[j].startCharCode = GET_ULong();
|
|
groups[j].endCharCode = GET_ULong();
|
|
groups[j].startGlyphID = GET_ULong();
|
|
}
|
|
|
|
FORGET_Frame();
|
|
|
|
cmap8_12->last_group = cmap8_12->groups;
|
|
|
|
cmap->get_index = code_to_index8_12;
|
|
cmap->get_next_char = code_to_next8_12;
|
|
break;
|
|
|
|
case 10:
|
|
cmap10 = &cmap->c.cmap10;
|
|
|
|
if ( ACCESS_Frame( 16L ) )
|
|
goto Fail;
|
|
|
|
cmap->length = GET_ULong();
|
|
cmap10->language = GET_ULong();
|
|
cmap10->startCharCode = GET_ULong();
|
|
cmap10->numChars = GET_ULong();
|
|
|
|
FORGET_Frame();
|
|
|
|
n = cmap10->numChars;
|
|
|
|
if ( ALLOC_ARRAY( cmap10->glyphs, n, FT_Short ) ||
|
|
ACCESS_Frame( n * 2L ) )
|
|
goto Fail;
|
|
|
|
for ( j = 0; j < n; j++ )
|
|
cmap10->glyphs[j] = GET_UShort();
|
|
|
|
FORGET_Frame();
|
|
cmap->get_index = code_to_index10;
|
|
cmap->get_next_char = code_to_next10;
|
|
break;
|
|
|
|
default: /* corrupt character mapping table */
|
|
return SFNT_Err_Invalid_CharMap_Format;
|
|
|
|
}
|
|
|
|
return SFNT_Err_Ok;
|
|
|
|
Fail:
|
|
TT_CharMap_Free( face, cmap );
|
|
return error;
|
|
}
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <Function> */
|
|
/* TT_CharMap_Free */
|
|
/* */
|
|
/* <Description> */
|
|
/* Destroys a character mapping table. */
|
|
/* */
|
|
/* <Input> */
|
|
/* face :: A handle to the parent face object. */
|
|
/* cmap :: A handle to a cmap object. */
|
|
/* */
|
|
/* <Return> */
|
|
/* FreeType error code. 0 means success. */
|
|
/* */
|
|
FT_LOCAL_DEF FT_Error
|
|
TT_CharMap_Free( TT_Face face,
|
|
TT_CMapTable* cmap )
|
|
{
|
|
FT_Memory memory;
|
|
|
|
|
|
if ( !cmap )
|
|
return SFNT_Err_Ok;
|
|
|
|
memory = face->root.driver->root.memory;
|
|
|
|
switch ( cmap->format )
|
|
{
|
|
case 0:
|
|
FREE( cmap->c.cmap0.glyphIdArray );
|
|
break;
|
|
|
|
case 2:
|
|
FREE( cmap->c.cmap2.subHeaderKeys );
|
|
FREE( cmap->c.cmap2.subHeaders );
|
|
FREE( cmap->c.cmap2.glyphIdArray );
|
|
break;
|
|
|
|
case 4:
|
|
FREE( cmap->c.cmap4.segments );
|
|
FREE( cmap->c.cmap4.glyphIdArray );
|
|
cmap->c.cmap4.segCountX2 = 0;
|
|
break;
|
|
|
|
case 6:
|
|
FREE( cmap->c.cmap6.glyphIdArray );
|
|
cmap->c.cmap6.entryCount = 0;
|
|
break;
|
|
|
|
case 8:
|
|
case 12:
|
|
FREE( cmap->c.cmap8_12.groups );
|
|
cmap->c.cmap8_12.nGroups = 0;
|
|
break;
|
|
|
|
case 10:
|
|
FREE( cmap->c.cmap10.glyphs );
|
|
cmap->c.cmap10.numChars = 0;
|
|
break;
|
|
|
|
default:
|
|
/* invalid table format, do nothing */
|
|
;
|
|
}
|
|
|
|
cmap->loaded = FALSE;
|
|
return SFNT_Err_Ok;
|
|
}
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <Function> */
|
|
/* code_to_index0 */
|
|
/* */
|
|
/* <Description> */
|
|
/* Converts the character code into a glyph index. Uses format 0. */
|
|
/* `charCode' must be in the range 0x00-0xFF (otherwise 0 is */
|
|
/* returned). */
|
|
/* */
|
|
/* <Input> */
|
|
/* charCode :: The wanted character code. */
|
|
/* cmap0 :: A pointer to a cmap table in format 0. */
|
|
/* */
|
|
/* <Return> */
|
|
/* Glyph index into the glyphs array. 0 if the glyph does not exist. */
|
|
/* */
|
|
FT_CALLBACK_DEF( FT_UInt )
|
|
code_to_index0( TT_CMapTable* cmap,
|
|
FT_ULong charCode )
|
|
{
|
|
TT_CMap0* cmap0 = &cmap->c.cmap0;
|
|
|
|
|
|
return ( charCode <= 0xFF ? cmap0->glyphIdArray[charCode] : 0 );
|
|
}
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <Function> */
|
|
/* code_to_next0 */
|
|
/* */
|
|
/* <Description> */
|
|
/* Finds the next encoded character after the given one. Uses */
|
|
/* format 0. `charCode' must be in the range 0x00-0xFF (otherwise 0 */
|
|
/* is returned). */
|
|
/* */
|
|
/* <Input> */
|
|
/* charCode :: The wanted character code. */
|
|
/* cmap0 :: A pointer to a cmap table in format 0. */
|
|
/* */
|
|
/* <Return> */
|
|
/* Next char code. 0 if no higher one is encoded. */
|
|
/* */
|
|
FT_CALLBACK_DEF( FT_ULong )
|
|
code_to_next0( TT_CMapTable* cmap,
|
|
FT_ULong charCode )
|
|
{
|
|
TT_CMap0* cmap0 = &cmap->c.cmap0;
|
|
|
|
|
|
while ( ++charCode <= 0xFF )
|
|
if ( cmap0->glyphIdArray[charCode] )
|
|
return ( charCode );
|
|
return ( 0 );
|
|
}
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <Function> */
|
|
/* code_to_index2 */
|
|
/* */
|
|
/* <Description> */
|
|
/* Converts the character code into a glyph index. Uses format 2. */
|
|
/* */
|
|
/* <Input> */
|
|
/* charCode :: The wanted character code. */
|
|
/* cmap2 :: A pointer to a cmap table in format 2. */
|
|
/* */
|
|
/* <Return> */
|
|
/* Glyph index into the glyphs array. 0 if the glyph does not exist. */
|
|
/* */
|
|
FT_CALLBACK_DEF( FT_UInt )
|
|
code_to_index2( TT_CMapTable* cmap,
|
|
FT_ULong charCode )
|
|
{
|
|
FT_UInt result, index1, offset;
|
|
FT_UInt char_lo;
|
|
FT_ULong char_hi;
|
|
TT_CMap2SubHeader* sh2;
|
|
TT_CMap2* cmap2;
|
|
|
|
|
|
cmap2 = &cmap->c.cmap2;
|
|
result = 0;
|
|
char_lo = (FT_UInt)( charCode & 0xFF );
|
|
char_hi = charCode >> 8;
|
|
|
|
if ( char_hi == 0 )
|
|
{
|
|
/* an 8-bit character code -- we use the subHeader 0 in this case */
|
|
/* to test whether the character code is in the charmap */
|
|
index1 = cmap2->subHeaderKeys[char_lo];
|
|
if ( index1 != 0 )
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
/* a 16-bit character code */
|
|
index1 = cmap2->subHeaderKeys[char_hi & 0xFF];
|
|
if ( index1 == 0 )
|
|
return 0;
|
|
}
|
|
|
|
sh2 = cmap2->subHeaders + index1;
|
|
char_lo -= sh2->firstCode;
|
|
|
|
if ( char_lo < (FT_UInt)sh2->entryCount )
|
|
{
|
|
offset = sh2->idRangeOffset / 2 + char_lo;
|
|
if ( offset < (FT_UInt)cmap2->numGlyphId )
|
|
{
|
|
result = cmap2->glyphIdArray[offset];
|
|
if ( result )
|
|
result = ( result + sh2->idDelta ) & 0xFFFF;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <Function> */
|
|
/* code_to_next2 */
|
|
/* */
|
|
/* <Description> */
|
|
/* Find the next encoded character. Uses format 2. */
|
|
/* */
|
|
/* <Input> */
|
|
/* charCode :: The wanted character code. */
|
|
/* cmap2 :: A pointer to a cmap table in format 2. */
|
|
/* */
|
|
/* <Return> */
|
|
/* Next encoded character. 0 if none exists. */
|
|
/* */
|
|
FT_CALLBACK_DEF( FT_ULong )
|
|
code_to_next2( TT_CMapTable* cmap,
|
|
FT_ULong charCode )
|
|
{
|
|
FT_UInt index1, offset;
|
|
FT_UInt char_lo;
|
|
FT_ULong char_hi;
|
|
TT_CMap2SubHeader* sh2;
|
|
TT_CMap2* cmap2;
|
|
|
|
|
|
cmap2 = &cmap->c.cmap2;
|
|
charCode++;
|
|
|
|
/*
|
|
* This is relatively simplistic -- look for a subHeader containing
|
|
* glyphs and then walk to the first glyph in that subHeader.
|
|
*/
|
|
while ( charCode < 0x10000 )
|
|
{
|
|
char_lo = (FT_UInt)( charCode & 0xFF );
|
|
char_hi = charCode >> 8;
|
|
|
|
if ( char_hi == 0 )
|
|
{
|
|
/* an 8-bit character code -- we use the subHeader 0 in this case */
|
|
/* to test whether the character code is in the charmap */
|
|
index1 = cmap2->subHeaderKeys[char_lo];
|
|
if ( index1 != 0 )
|
|
{
|
|
charCode++;
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* a 16-bit character code */
|
|
index1 = cmap2->subHeaderKeys[char_hi & 0xFF];
|
|
if ( index1 == 0 )
|
|
{
|
|
charCode = ( char_hi + 1 ) << 8;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
sh2 = cmap2->subHeaders + index1;
|
|
char_lo -= sh2->firstCode;
|
|
|
|
if ( char_lo > (FT_UInt)sh2->entryCount )
|
|
{
|
|
charCode = ( char_hi + 1 ) << 8;
|
|
continue;
|
|
}
|
|
|
|
offset = sh2->idRangeOffset / 2 + char_lo;
|
|
if ( offset >= (FT_UInt)cmap2->numGlyphId ||
|
|
cmap2->glyphIdArray[offset] == 0 )
|
|
{
|
|
charCode++;
|
|
continue;
|
|
}
|
|
|
|
return charCode;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <Function> */
|
|
/* code_to_index4 */
|
|
/* */
|
|
/* <Description> */
|
|
/* Converts the character code into a glyph index. Uses format 4. */
|
|
/* */
|
|
/* <Input> */
|
|
/* charCode :: The wanted character code. */
|
|
/* cmap4 :: A pointer to a cmap table in format 4. */
|
|
/* */
|
|
/* <Return> */
|
|
/* Glyph index into the glyphs array. 0 if the glyph does not exist. */
|
|
/* */
|
|
FT_CALLBACK_DEF( FT_UInt )
|
|
code_to_index4( TT_CMapTable* cmap,
|
|
FT_ULong charCode )
|
|
{
|
|
FT_UInt result, index1, segCount;
|
|
TT_CMap4* cmap4;
|
|
TT_CMap4Segment *seg4, *limit;
|
|
|
|
|
|
cmap4 = &cmap->c.cmap4;
|
|
result = 0;
|
|
segCount = cmap4->segCountX2 / 2;
|
|
limit = cmap4->segments + segCount;
|
|
|
|
/* first, check against the last used segment */
|
|
|
|
seg4 = cmap4->last_segment;
|
|
|
|
/* the following is equivalent to performing two tests, as in */
|
|
/* */
|
|
/* if ( charCode >= seg4->startCount && charCode <= seg4->endCount ) */
|
|
/* */
|
|
/* This is a bit strange, but it is faster, and the idea behind the */
|
|
/* cache is to significantly speed up charcode to glyph index */
|
|
/* conversion. */
|
|
|
|
if ( (FT_ULong)( charCode - seg4->startCount ) <
|
|
(FT_ULong)( seg4->endCount - seg4->startCount ) )
|
|
goto Found1;
|
|
|
|
for ( seg4 = cmap4->segments; seg4 < limit; seg4++ )
|
|
{
|
|
/* the ranges are sorted in increasing order. If we are out of */
|
|
/* the range here, the char code isn't in the charmap, so exit. */
|
|
|
|
if ( charCode > (FT_UInt)seg4->endCount )
|
|
continue;
|
|
|
|
if ( charCode >= (FT_UInt)seg4->startCount )
|
|
goto Found;
|
|
}
|
|
return 0;
|
|
|
|
Found:
|
|
cmap4->last_segment = seg4;
|
|
|
|
Found1:
|
|
/* if the idRangeOffset is 0, we can compute the glyph index */
|
|
/* directly */
|
|
|
|
if ( seg4->idRangeOffset == 0 )
|
|
result = ( charCode + seg4->idDelta ) & 0xFFFF;
|
|
else
|
|
{
|
|
/* otherwise, we must use the glyphIdArray to do it */
|
|
index1 = (FT_UInt)( seg4->idRangeOffset / 2
|
|
+ ( charCode - seg4->startCount )
|
|
+ ( seg4 - cmap4->segments )
|
|
- segCount );
|
|
|
|
if ( index1 < (FT_UInt)cmap4->numGlyphId &&
|
|
cmap4->glyphIdArray[index1] != 0 )
|
|
result = ( cmap4->glyphIdArray[index1] + seg4->idDelta ) & 0xFFFF;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <Function> */
|
|
/* code_to_next4 */
|
|
/* */
|
|
/* <Description> */
|
|
/* Find the next encoded character. Uses format 4. */
|
|
/* */
|
|
/* <Input> */
|
|
/* charCode :: The wanted character code. */
|
|
/* cmap :: A pointer to a cmap table in format 4. */
|
|
/* */
|
|
/* <Return> */
|
|
/* Next encoded character. 0 if none exists. */
|
|
/* */
|
|
FT_CALLBACK_DEF( FT_ULong )
|
|
code_to_next4( TT_CMapTable* cmap,
|
|
FT_ULong charCode )
|
|
{
|
|
FT_UInt index1, segCount;
|
|
TT_CMap4* cmap4;
|
|
TT_CMap4Segment *seg4, *limit;
|
|
|
|
|
|
cmap4 = &cmap->c.cmap4;
|
|
segCount = cmap4->segCountX2 / 2;
|
|
limit = cmap4->segments + segCount;
|
|
|
|
charCode++;
|
|
|
|
for ( seg4 = cmap4->segments; seg4 < limit; seg4++ )
|
|
{
|
|
/* The ranges are sorted in increasing order. If we are out of */
|
|
/* the range here, the char code isn't in the charmap, so exit. */
|
|
|
|
if ( charCode <= (FT_UInt)seg4->endCount )
|
|
goto Found;
|
|
}
|
|
return 0;
|
|
|
|
Found:
|
|
if ( charCode < (FT_ULong) seg4->startCount )
|
|
charCode = seg4->startCount;
|
|
|
|
/* if the idRangeOffset is 0, all chars in the map exist */
|
|
|
|
if ( seg4->idRangeOffset == 0 )
|
|
return ( charCode );
|
|
|
|
while ( charCode <= (FT_UInt) seg4->endCount )
|
|
{
|
|
/* otherwise, we must use the glyphIdArray to do it */
|
|
index1 = (FT_UInt)( seg4->idRangeOffset / 2
|
|
+ ( charCode - seg4->startCount )
|
|
+ ( seg4 - cmap4->segments )
|
|
- segCount );
|
|
|
|
if ( index1 < (FT_UInt)cmap4->numGlyphId &&
|
|
cmap4->glyphIdArray[index1] != 0 )
|
|
return ( charCode );
|
|
charCode++;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <Function> */
|
|
/* code_to_index6 */
|
|
/* */
|
|
/* <Description> */
|
|
/* Converts the character code into a glyph index. Uses format 6. */
|
|
/* */
|
|
/* <Input> */
|
|
/* charCode :: The wanted character code. */
|
|
/* cmap6 :: A pointer to a cmap table in format 6. */
|
|
/* */
|
|
/* <Return> */
|
|
/* Glyph index into the glyphs array. 0 if the glyph does not exist. */
|
|
/* */
|
|
FT_CALLBACK_DEF( FT_UInt )
|
|
code_to_index6( TT_CMapTable* cmap,
|
|
FT_ULong charCode )
|
|
{
|
|
TT_CMap6* cmap6;
|
|
FT_UInt result = 0;
|
|
|
|
|
|
cmap6 = &cmap->c.cmap6;
|
|
charCode -= cmap6->firstCode;
|
|
|
|
if ( charCode < (FT_UInt)cmap6->entryCount )
|
|
result = cmap6->glyphIdArray[charCode];
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <Function> */
|
|
/* code_to_next6 */
|
|
/* */
|
|
/* <Description> */
|
|
/* Find the next encoded character. Uses format 6. */
|
|
/* */
|
|
/* <Input> */
|
|
/* charCode :: The wanted character code. */
|
|
/* cmap :: A pointer to a cmap table in format 6. */
|
|
/* */
|
|
/* <Return> */
|
|
/* Next encoded character. 0 if none exists. */
|
|
/* */
|
|
FT_CALLBACK_DEF( FT_ULong )
|
|
code_to_next6( TT_CMapTable* cmap,
|
|
FT_ULong charCode )
|
|
{
|
|
TT_CMap6* cmap6;
|
|
|
|
|
|
charCode++;
|
|
|
|
cmap6 = &cmap->c.cmap6;
|
|
|
|
if ( charCode < (FT_ULong) cmap6->firstCode )
|
|
charCode = cmap6->firstCode;
|
|
|
|
charCode -= cmap6->firstCode;
|
|
|
|
while ( charCode < (FT_UInt)cmap6->entryCount )
|
|
{
|
|
if ( cmap6->glyphIdArray[charCode] != 0 )
|
|
return charCode + cmap6->firstCode;
|
|
charCode++;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <Function> */
|
|
/* code_to_index8_12 */
|
|
/* */
|
|
/* <Description> */
|
|
/* Converts the (possibly 32bit) character code into a glyph index. */
|
|
/* Uses format 8 or 12. */
|
|
/* */
|
|
/* <Input> */
|
|
/* charCode :: The wanted character code. */
|
|
/* cmap8_12 :: A pointer to a cmap table in format 8 or 12. */
|
|
/* */
|
|
/* <Return> */
|
|
/* Glyph index into the glyphs array. 0 if the glyph does not exist. */
|
|
/* */
|
|
FT_CALLBACK_DEF( FT_UInt )
|
|
code_to_index8_12( TT_CMapTable* cmap,
|
|
FT_ULong charCode )
|
|
{
|
|
TT_CMap8_12* cmap8_12;
|
|
TT_CMapGroup *group, *limit;
|
|
|
|
|
|
cmap8_12 = &cmap->c.cmap8_12;
|
|
limit = cmap8_12->groups + cmap8_12->nGroups;
|
|
|
|
/* first, check against the last used group */
|
|
|
|
group = cmap8_12->last_group;
|
|
|
|
/* the following is equivalent to performing two tests, as in */
|
|
/* */
|
|
/* if ( charCode >= group->startCharCode && */
|
|
/* charCode <= group->endCharCode ) */
|
|
/* */
|
|
/* This is a bit strange, but it is faster, and the idea behind the */
|
|
/* cache is to significantly speed up charcode to glyph index */
|
|
/* conversion. */
|
|
|
|
if ( (FT_ULong)( charCode - group->startCharCode ) <
|
|
(FT_ULong)( group->endCharCode - group->startCharCode ) )
|
|
goto Found1;
|
|
|
|
for ( group = cmap8_12->groups; group < limit; group++ )
|
|
{
|
|
/* the ranges are sorted in increasing order. If we are out of */
|
|
/* the range here, the char code isn't in the charmap, so exit. */
|
|
|
|
if ( charCode > group->endCharCode )
|
|
continue;
|
|
|
|
if ( charCode >= group->startCharCode )
|
|
goto Found;
|
|
}
|
|
return 0;
|
|
|
|
Found:
|
|
cmap8_12->last_group = group;
|
|
|
|
Found1:
|
|
return group->startGlyphID + (FT_UInt)( charCode - group->startCharCode );
|
|
}
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <Function> */
|
|
/* code_to_next8_12 */
|
|
/* */
|
|
/* <Description> */
|
|
/* Find the next encoded character. Uses format 8 or 12. */
|
|
/* */
|
|
/* <Input> */
|
|
/* charCode :: The wanted character code. */
|
|
/* cmap :: A pointer to a cmap table in format 8 or 12. */
|
|
/* */
|
|
/* <Return> */
|
|
/* Next encoded character. 0 if none exists. */
|
|
/* */
|
|
FT_CALLBACK_DEF( FT_ULong )
|
|
code_to_next8_12( TT_CMapTable* cmap,
|
|
FT_ULong charCode )
|
|
{
|
|
TT_CMap8_12* cmap8_12;
|
|
TT_CMapGroup *group, *limit;
|
|
|
|
|
|
charCode++;
|
|
cmap8_12 = &cmap->c.cmap8_12;
|
|
limit = cmap8_12->groups + cmap8_12->nGroups;
|
|
|
|
for ( group = cmap8_12->groups; group < limit; group++ )
|
|
{
|
|
/* the ranges are sorted in increasing order. If we are out of */
|
|
/* the range here, the char code isn't in the charmap, so exit. */
|
|
|
|
if ( charCode <= group->endCharCode )
|
|
goto Found;
|
|
}
|
|
return 0;
|
|
|
|
Found:
|
|
if ( charCode < group->startCharCode )
|
|
charCode = group->startCharCode;
|
|
|
|
return charCode;
|
|
}
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <Function> */
|
|
/* code_to_index10 */
|
|
/* */
|
|
/* <Description> */
|
|
/* Converts the (possibly 32bit) character code into a glyph index. */
|
|
/* Uses format 10. */
|
|
/* */
|
|
/* <Input> */
|
|
/* charCode :: The wanted character code. */
|
|
/* cmap10 :: A pointer to a cmap table in format 10. */
|
|
/* */
|
|
/* <Return> */
|
|
/* Glyph index into the glyphs array. 0 if the glyph does not exist. */
|
|
/* */
|
|
FT_CALLBACK_DEF( FT_UInt )
|
|
code_to_index10( TT_CMapTable* cmap,
|
|
FT_ULong charCode )
|
|
{
|
|
TT_CMap10* cmap10;
|
|
FT_UInt result = 0;
|
|
|
|
|
|
cmap10 = &cmap->c.cmap10;
|
|
charCode -= cmap10->startCharCode;
|
|
|
|
/* the overflow trick for comparison works here also since the number */
|
|
/* of glyphs (even if numChars is specified as ULong in the specs) in */
|
|
/* an OpenType font is limited to 64k */
|
|
|
|
if ( charCode < cmap10->numChars )
|
|
result = cmap10->glyphs[charCode];
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <Function> */
|
|
/* code_to_next10 */
|
|
/* */
|
|
/* <Description> */
|
|
/* Find the next encoded character. Uses format 10. */
|
|
/* */
|
|
/* <Input> */
|
|
/* charCode :: The wanted character code. */
|
|
/* cmap :: A pointer to a cmap table in format 10. */
|
|
/* */
|
|
/* <Return> */
|
|
/* Next encoded character. 0 if none exists. */
|
|
/* */
|
|
FT_CALLBACK_DEF( FT_ULong )
|
|
code_to_next10( TT_CMapTable* cmap,
|
|
FT_ULong charCode )
|
|
{
|
|
TT_CMap10* cmap10;
|
|
|
|
|
|
charCode++;
|
|
cmap10 = &cmap->c.cmap10;
|
|
|
|
if ( charCode < cmap10->startCharCode )
|
|
charCode = cmap10->startCharCode;
|
|
|
|
charCode -= cmap10->startCharCode;
|
|
|
|
/* the overflow trick for comparison works here also since the number */
|
|
/* of glyphs (even if numChars is specified as ULong in the specs) in */
|
|
/* an OpenType font is limited to 64k */
|
|
|
|
while ( charCode < cmap10->numChars )
|
|
{
|
|
if ( cmap10->glyphs[charCode] )
|
|
return ( charCode + cmap10->startCharCode );
|
|
charCode++;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* END */
|