ref: a1656abd8f9acb5a1a546eee66a7a73fc6bfc076
dir: /src/sfnt/ttcmap.c/
/***************************************************************************/
/* */
/* ttcmap.c */
/* */
/* TrueType character mapping table (cmap) support (body). */
/* */
/* Copyright 1996-1999 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 <ftdebug.h>
#include <ttload.h>
#include <ttcmap.h>
#include <tterrors.h>
/* required by the tracing mode */
#undef FT_COMPONENT
#define FT_COMPONENT trace_ttcmap
static TT_UInt code_to_index0( TT_CMapTable* charmap, TT_ULong char_code );
static TT_UInt code_to_index2( TT_CMapTable* charmap, TT_ULong char_code );
static TT_UInt code_to_index4( TT_CMapTable* charmap, TT_ULong char_code );
static TT_UInt code_to_index6( TT_CMapTable* charmap, TT_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> */
/* 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. */
/* */
LOCAL_FUNC
TT_Error TT_CharMap_Load( TT_Face face,
TT_CMapTable* cmap,
FT_Stream stream )
{
TT_Error error;
FT_Memory memory;
TT_UShort num_SH, num_Seg, i;
TT_UShort u, l;
TT_CMap0* cmap0;
TT_CMap2* cmap2;
TT_CMap4* cmap4;
TT_CMap6* cmap6;
TT_CMap2SubHeader* cmap2sub;
TT_CMap4Segment* segments;
if ( cmap->loaded )
return TT_Err_Ok;
memory = stream->memory;
if ( FILE_Seek( cmap->offset ) )
return error;
switch ( cmap->format )
{
case 0:
cmap0 = &cmap->c.cmap0;
if ( ALLOC( cmap0->glyphIdArray, 256L ) ||
FILE_Read( (void*)cmap0->glyphIdArray, 256L ) )
goto Fail;
cmap->get_index = code_to_index0;
break;
case 2:
num_SH = 0;
cmap2 = &cmap->c.cmap2;
/* allocate subheader keys */
if ( ALLOC_ARRAY( cmap2->subHeaderKeys, 256, TT_UShort ) ||
ACCESS_Frame( 512L ) )
goto Fail;
for ( i = 0; i < 256; i++ )
{
u = GET_UShort() / 8;
cmap2->subHeaderKeys[i] = u;
if ( num_SH < u )
num_SH = u;
}
FORGET_Frame();
/* load subheaders */
cmap2->numGlyphId = l =
( ( 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 ) )
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 = GET_UShort() - ( num_SH - i ) * 8 - 2;
cmap2sub++;
}
FORGET_Frame();
/* load glyph IDs */
if ( ALLOC_ARRAY( cmap2->glyphIdArray, l, TT_UShort ) ||
ACCESS_Frame( l * 2L ) )
goto Fail;
for ( i = 0; i < l; i++ )
cmap2->glyphIdArray[i] = GET_UShort();
FORGET_Frame();
cmap->get_index = code_to_index2;
break;
case 4:
cmap4 = &cmap->c.cmap4;
/* load header */
if ( ACCESS_Frame( 8L ) )
goto Fail;
cmap4->segCountX2 = GET_UShort();
cmap4->searchRange = GET_UShort();
cmap4->entrySelector = GET_UShort();
cmap4->rangeShift = GET_UShort();
num_Seg = 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 =
( ( cmap->length - ( 16L + 8L * num_Seg ) ) & 0xFFFF ) /2;
/* load IDs */
if ( ALLOC_ARRAY( cmap4->glyphIdArray, l, TT_UShort ) ||
ACCESS_Frame( l*2L ) )
goto Fail;
for ( i = 0; i < l; i++ )
cmap4->glyphIdArray[i] = GET_UShort();
FORGET_Frame();
cmap->get_index = code_to_index4;
break;
case 6:
cmap6 = &cmap->c.cmap6;
if ( ACCESS_Frame( 4L ) )
goto Fail;
cmap6->firstCode = GET_UShort();
cmap6->entryCount = GET_UShort();
FORGET_Frame();
l = cmap6->entryCount;
if ( ALLOC_ARRAY( cmap6->glyphIdArray,
cmap6->entryCount,
TT_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;
break;
default: /* corrupt character mapping table */
return TT_Err_Invalid_CharMap_Format;
}
return TT_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> */
/* Error code. 0 means success. */
/* */
LOCAL_FUNC
TT_Error TT_CharMap_Free( TT_Face face,
TT_CMapTable* cmap )
{
FT_Memory memory;
if ( !cmap )
return TT_Err_Ok;
memory = face->root.driver->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;
default:
/* invalid table format, do nothing */
;
}
cmap->loaded = FALSE;
return TT_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. */
/* */
static
TT_UInt code_to_index0( TT_CMapTable* cmap,
TT_ULong charCode )
{
TT_CMap0* cmap0 = &cmap->c.cmap0;
return ( charCode <= 0xFF ? cmap0->glyphIdArray[charCode] : 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. */
/* */
static
TT_UInt code_to_index2( TT_CMapTable* cmap,
TT_ULong charCode )
{
TT_UInt result, index1, offset;
TT_UInt char_lo;
TT_ULong char_hi;
TT_CMap2SubHeader* sh2;
TT_CMap2* cmap2;
cmap2 = &cmap->c.cmap2;
result = 0;
char_lo = (TT_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 wether the character code is in the charmap */
if ( cmap2->subHeaderKeys[char_lo] == 0 )
{
result = cmap2->glyphIdArray[char_lo];
}
}
else
{
/* a 16-bit character code */
index1 = cmap2->subHeaderKeys[ char_hi & 0xFF ];
if (index1)
{
sh2 = cmap2->subHeaders + index1;
char_lo -= sh2->firstCode;
if (char_lo < sh2->entryCount)
{
offset = sh2->idRangeOffset/2 + char_lo;
if (offset < cmap2->numGlyphId)
{
result = cmap2->glyphIdArray[offset];
if (result)
result = (result + sh2->idDelta) & 0xFFFF;
}
}
}
}
return result;
}
/*************************************************************************/
/* */
/* <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. */
/* */
static
TT_UInt code_to_index4( TT_CMapTable* cmap,
TT_ULong charCode )
{
TT_UInt result, index1, segCount;
TT_CMap4* cmap4;
TT_CMap4Segment *seg4, *limit;
cmap4 = &cmap->c.cmap4;
result = 0;
segCount = cmap4->segCountX2 / 2;
seg4 = cmap4->segments;
limit = seg4 + segCount;
for ( ; seg4 < limit; seg4++, segCount-- )
{
if ( charCode <= seg4->endCount )
{
/* the ranges are sorted in increasing order, if we're out of */
/* the range here, the char code isn't in the charmap, so exit */
if ( charCode < seg4->startCount )
break;
/* when 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 = seg4->idRangeOffset/2 + (charCode - seg4->startCount)
- segCount;
if ( index1 < cmap4->numGlyphId &&
cmap4->glyphIdArray[index1] != 0 )
{
result = (cmap4->glyphIdArray[index1] + seg4->idDelta) & 0xFFFF;
}
}
break;
}
}
return result;
}
/*************************************************************************/
/* */
/* <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. */
/* */
static
TT_UInt code_to_index6( TT_CMapTable* cmap,
TT_ULong charCode )
{
TT_CMap6* cmap6;
TT_UInt result = 0;
cmap6 = &cmap->c.cmap6;
result = 0;
charCode -= cmap6->firstCode;
if ( charCode < cmap6->entryCount )
result = cmap6->glyphIdArray[charCode];
return result;
}
/* END */