/src/freetype/src/truetype/ttpload.c
C | 599 lines | 330 code | 125 blank | 144 comment | 51 complexity | 70dba1db87618755ccccf6ef1bef3a52 MD5 | raw file
1/***************************************************************************/ 2/* */ 3/* ttpload.c */ 4/* */ 5/* TrueType-specific tables loader (body). */ 6/* */ 7/* Copyright 1996-2002, 2004-2012 by */ 8/* David Turner, Robert Wilhelm, and Werner Lemberg. */ 9/* */ 10/* This file is part of the FreeType project, and may only be used, */ 11/* modified, and distributed under the terms of the FreeType project */ 12/* license, LICENSE.TXT. By continuing to use, modify, or distribute */ 13/* this file you indicate that you have read the license and */ 14/* understand and accept it fully. */ 15/* */ 16/***************************************************************************/ 17 18 19#include <ft2build.h> 20#include FT_INTERNAL_DEBUG_H 21#include FT_INTERNAL_OBJECTS_H 22#include FT_INTERNAL_STREAM_H 23#include FT_TRUETYPE_TAGS_H 24 25#include "ttpload.h" 26 27#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT 28#include "ttgxvar.h" 29#endif 30 31#include "tterrors.h" 32 33 34 /*************************************************************************/ 35 /* */ 36 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ 37 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ 38 /* messages during execution. */ 39 /* */ 40#undef FT_COMPONENT 41#define FT_COMPONENT trace_ttpload 42 43 44 /*************************************************************************/ 45 /* */ 46 /* <Function> */ 47 /* tt_face_load_loca */ 48 /* */ 49 /* <Description> */ 50 /* Load the locations table. */ 51 /* */ 52 /* <InOut> */ 53 /* face :: A handle to the target face object. */ 54 /* */ 55 /* <Input> */ 56 /* stream :: The input stream. */ 57 /* */ 58 /* <Return> */ 59 /* FreeType error code. 0 means success. */ 60 /* */ 61 FT_LOCAL_DEF( FT_Error ) 62 tt_face_load_loca( TT_Face face, 63 FT_Stream stream ) 64 { 65 FT_Error error; 66 FT_ULong table_len; 67 FT_Int shift; 68 69 70 /* we need the size of the `glyf' table for malformed `loca' tables */ 71 error = face->goto_table( face, TTAG_glyf, stream, &face->glyf_len ); 72 73 /* it is possible that a font doesn't have a glyf table at all */ 74 /* or its size is zero */ 75 if ( error == TT_Err_Table_Missing ) 76 face->glyf_len = 0; 77 else if ( error ) 78 goto Exit; 79 80 FT_TRACE2(( "Locations " )); 81 error = face->goto_table( face, TTAG_loca, stream, &table_len ); 82 if ( error ) 83 { 84 error = TT_Err_Locations_Missing; 85 goto Exit; 86 } 87 88 if ( face->header.Index_To_Loc_Format != 0 ) 89 { 90 shift = 2; 91 92 if ( table_len >= 0x40000L ) 93 { 94 FT_TRACE2(( "table too large\n" )); 95 error = TT_Err_Invalid_Table; 96 goto Exit; 97 } 98 face->num_locations = table_len >> shift; 99 } 100 else 101 { 102 shift = 1; 103 104 if ( table_len >= 0x20000L ) 105 { 106 FT_TRACE2(( "table too large\n" )); 107 error = TT_Err_Invalid_Table; 108 goto Exit; 109 } 110 face->num_locations = table_len >> shift; 111 } 112 113 if ( face->num_locations != (FT_ULong)face->root.num_glyphs + 1 ) 114 { 115 FT_TRACE2(( "glyph count mismatch! loca: %d, maxp: %d\n", 116 face->num_locations - 1, face->root.num_glyphs )); 117 118 /* we only handle the case where `maxp' gives a larger value */ 119 if ( face->num_locations <= (FT_ULong)face->root.num_glyphs ) 120 { 121 FT_Long new_loca_len = 122 ( (FT_Long)( face->root.num_glyphs ) + 1 ) << shift; 123 124 TT_Table entry = face->dir_tables; 125 TT_Table limit = entry + face->num_tables; 126 127 FT_Long pos = FT_Stream_Pos( stream ); 128 FT_Long dist = 0x7FFFFFFFL; 129 130 131 /* compute the distance to next table in font file */ 132 for ( ; entry < limit; entry++ ) 133 { 134 FT_Long diff = entry->Offset - pos; 135 136 137 if ( diff > 0 && diff < dist ) 138 dist = diff; 139 } 140 141 if ( entry == limit ) 142 { 143 /* `loca' is the last table */ 144 dist = stream->size - pos; 145 } 146 147 if ( new_loca_len <= dist ) 148 { 149 face->num_locations = face->root.num_glyphs + 1; 150 table_len = new_loca_len; 151 152 FT_TRACE2(( "adjusting num_locations to %d\n", 153 face->num_locations )); 154 } 155 } 156 } 157 158 /* 159 * Extract the frame. We don't need to decompress it since 160 * we are able to parse it directly. 161 */ 162 if ( FT_FRAME_EXTRACT( table_len, face->glyph_locations ) ) 163 goto Exit; 164 165 FT_TRACE2(( "loaded\n" )); 166 167 Exit: 168 return error; 169 } 170 171 172 FT_LOCAL_DEF( FT_ULong ) 173 tt_face_get_location( TT_Face face, 174 FT_UInt gindex, 175 FT_UInt *asize ) 176 { 177 FT_ULong pos1, pos2; 178 FT_Byte* p; 179 FT_Byte* p_limit; 180 181 182 pos1 = pos2 = 0; 183 184 if ( gindex < face->num_locations ) 185 { 186 if ( face->header.Index_To_Loc_Format != 0 ) 187 { 188 p = face->glyph_locations + gindex * 4; 189 p_limit = face->glyph_locations + face->num_locations * 4; 190 191 pos1 = FT_NEXT_ULONG( p ); 192 pos2 = pos1; 193 194 if ( p + 4 <= p_limit ) 195 pos2 = FT_NEXT_ULONG( p ); 196 } 197 else 198 { 199 p = face->glyph_locations + gindex * 2; 200 p_limit = face->glyph_locations + face->num_locations * 2; 201 202 pos1 = FT_NEXT_USHORT( p ); 203 pos2 = pos1; 204 205 if ( p + 2 <= p_limit ) 206 pos2 = FT_NEXT_USHORT( p ); 207 208 pos1 <<= 1; 209 pos2 <<= 1; 210 } 211 } 212 213 /* Check broken location data */ 214 if ( pos1 > face->glyf_len ) 215 { 216 FT_TRACE1(( "tt_face_get_location:" 217 " too large offset=0x%08lx found for gid=0x%04lx," 218 " exceeding the end of glyf table (0x%08lx)\n", 219 pos1, gindex, face->glyf_len )); 220 *asize = 0; 221 return 0; 222 } 223 224 if ( pos2 > face->glyf_len ) 225 { 226 FT_TRACE1(( "tt_face_get_location:" 227 " too large offset=0x%08lx found for gid=0x%04lx," 228 " truncate at the end of glyf table (0x%08lx)\n", 229 pos2, gindex + 1, face->glyf_len )); 230 pos2 = face->glyf_len; 231 } 232 233 /* The `loca' table must be ordered; it refers to the length of */ 234 /* an entry as the difference between the current and the next */ 235 /* position. However, there do exist (malformed) fonts which */ 236 /* don't obey this rule, so we are only able to provide an */ 237 /* upper bound for the size. */ 238 /* */ 239 /* We get (intentionally) a wrong, non-zero result in case the */ 240 /* `glyf' table is missing. */ 241 if ( pos2 >= pos1 ) 242 *asize = (FT_UInt)( pos2 - pos1 ); 243 else 244 *asize = (FT_UInt)( face->glyf_len - pos1 ); 245 246 return pos1; 247 } 248 249 250 FT_LOCAL_DEF( void ) 251 tt_face_done_loca( TT_Face face ) 252 { 253 FT_Stream stream = face->root.stream; 254 255 256 FT_FRAME_RELEASE( face->glyph_locations ); 257 face->num_locations = 0; 258 } 259 260 261 262 /*************************************************************************/ 263 /* */ 264 /* <Function> */ 265 /* tt_face_load_cvt */ 266 /* */ 267 /* <Description> */ 268 /* Load the control value table into a face object. */ 269 /* */ 270 /* <InOut> */ 271 /* face :: A handle to the target face object. */ 272 /* */ 273 /* <Input> */ 274 /* stream :: A handle to the input stream. */ 275 /* */ 276 /* <Return> */ 277 /* FreeType error code. 0 means success. */ 278 /* */ 279 FT_LOCAL_DEF( FT_Error ) 280 tt_face_load_cvt( TT_Face face, 281 FT_Stream stream ) 282 { 283#ifdef TT_USE_BYTECODE_INTERPRETER 284 285 FT_Error error; 286 FT_Memory memory = stream->memory; 287 FT_ULong table_len; 288 289 290 FT_TRACE2(( "CVT " )); 291 292 error = face->goto_table( face, TTAG_cvt, stream, &table_len ); 293 if ( error ) 294 { 295 FT_TRACE2(( "is missing\n" )); 296 297 face->cvt_size = 0; 298 face->cvt = NULL; 299 error = TT_Err_Ok; 300 301 goto Exit; 302 } 303 304 face->cvt_size = table_len / 2; 305 306 if ( FT_NEW_ARRAY( face->cvt, face->cvt_size ) ) 307 goto Exit; 308 309 if ( FT_FRAME_ENTER( face->cvt_size * 2L ) ) 310 goto Exit; 311 312 { 313 FT_Short* cur = face->cvt; 314 FT_Short* limit = cur + face->cvt_size; 315 316 317 for ( ; cur < limit; cur++ ) 318 *cur = FT_GET_SHORT(); 319 } 320 321 FT_FRAME_EXIT(); 322 FT_TRACE2(( "loaded\n" )); 323 324#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT 325 if ( face->doblend ) 326 error = tt_face_vary_cvt( face, stream ); 327#endif 328 329 Exit: 330 return error; 331 332#else /* !TT_USE_BYTECODE_INTERPRETER */ 333 334 FT_UNUSED( face ); 335 FT_UNUSED( stream ); 336 337 return TT_Err_Ok; 338 339#endif 340 } 341 342 343 /*************************************************************************/ 344 /* */ 345 /* <Function> */ 346 /* tt_face_load_fpgm */ 347 /* */ 348 /* <Description> */ 349 /* Load the font program. */ 350 /* */ 351 /* <InOut> */ 352 /* face :: A handle to the target face object. */ 353 /* */ 354 /* <Input> */ 355 /* stream :: A handle to the input stream. */ 356 /* */ 357 /* <Return> */ 358 /* FreeType error code. 0 means success. */ 359 /* */ 360 FT_LOCAL_DEF( FT_Error ) 361 tt_face_load_fpgm( TT_Face face, 362 FT_Stream stream ) 363 { 364#ifdef TT_USE_BYTECODE_INTERPRETER 365 366 FT_Error error; 367 FT_ULong table_len; 368 369 370 FT_TRACE2(( "Font program " )); 371 372 /* The font program is optional */ 373 error = face->goto_table( face, TTAG_fpgm, stream, &table_len ); 374 if ( error ) 375 { 376 face->font_program = NULL; 377 face->font_program_size = 0; 378 error = TT_Err_Ok; 379 380 FT_TRACE2(( "is missing\n" )); 381 } 382 else 383 { 384 face->font_program_size = table_len; 385 if ( FT_FRAME_EXTRACT( table_len, face->font_program ) ) 386 goto Exit; 387 388 FT_TRACE2(( "loaded, %12d bytes\n", face->font_program_size )); 389 } 390 391 Exit: 392 return error; 393 394#else /* !TT_USE_BYTECODE_INTERPRETER */ 395 396 FT_UNUSED( face ); 397 FT_UNUSED( stream ); 398 399 return TT_Err_Ok; 400 401#endif 402 } 403 404 405 /*************************************************************************/ 406 /* */ 407 /* <Function> */ 408 /* tt_face_load_prep */ 409 /* */ 410 /* <Description> */ 411 /* Load the cvt program. */ 412 /* */ 413 /* <InOut> */ 414 /* face :: A handle to the target face object. */ 415 /* */ 416 /* <Input> */ 417 /* stream :: A handle to the input stream. */ 418 /* */ 419 /* <Return> */ 420 /* FreeType error code. 0 means success. */ 421 /* */ 422 FT_LOCAL_DEF( FT_Error ) 423 tt_face_load_prep( TT_Face face, 424 FT_Stream stream ) 425 { 426#ifdef TT_USE_BYTECODE_INTERPRETER 427 428 FT_Error error; 429 FT_ULong table_len; 430 431 432 FT_TRACE2(( "Prep program " )); 433 434 error = face->goto_table( face, TTAG_prep, stream, &table_len ); 435 if ( error ) 436 { 437 face->cvt_program = NULL; 438 face->cvt_program_size = 0; 439 error = TT_Err_Ok; 440 441 FT_TRACE2(( "is missing\n" )); 442 } 443 else 444 { 445 face->cvt_program_size = table_len; 446 if ( FT_FRAME_EXTRACT( table_len, face->cvt_program ) ) 447 goto Exit; 448 449 FT_TRACE2(( "loaded, %12d bytes\n", face->cvt_program_size )); 450 } 451 452 Exit: 453 return error; 454 455#else /* !TT_USE_BYTECODE_INTERPRETER */ 456 457 FT_UNUSED( face ); 458 FT_UNUSED( stream ); 459 460 return TT_Err_Ok; 461 462#endif 463 } 464 465 466 /*************************************************************************/ 467 /* */ 468 /* <Function> */ 469 /* tt_face_load_hdmx */ 470 /* */ 471 /* <Description> */ 472 /* Load the `hdmx' table into the face object. */ 473 /* */ 474 /* <Input> */ 475 /* face :: A handle to the target face object. */ 476 /* */ 477 /* stream :: A handle to the input stream. */ 478 /* */ 479 /* <Return> */ 480 /* FreeType error code. 0 means success. */ 481 /* */ 482 483 FT_LOCAL_DEF( FT_Error ) 484 tt_face_load_hdmx( TT_Face face, 485 FT_Stream stream ) 486 { 487 FT_Error error; 488 FT_Memory memory = stream->memory; 489 FT_UInt version, nn, num_records; 490 FT_ULong table_size, record_size; 491 FT_Byte* p; 492 FT_Byte* limit; 493 494 495 /* this table is optional */ 496 error = face->goto_table( face, TTAG_hdmx, stream, &table_size ); 497 if ( error || table_size < 8 ) 498 return TT_Err_Ok; 499 500 if ( FT_FRAME_EXTRACT( table_size, face->hdmx_table ) ) 501 goto Exit; 502 503 p = face->hdmx_table; 504 limit = p + table_size; 505 506 version = FT_NEXT_USHORT( p ); 507 num_records = FT_NEXT_USHORT( p ); 508 record_size = FT_NEXT_ULONG( p ); 509 510 /* The maximum number of bytes in an hdmx device record is the */ 511 /* maximum number of glyphs + 2; this is 0xFFFF + 2; this is */ 512 /* the reason why `record_size' is a long (which we read as */ 513 /* unsigned long for convenience). In practice, two bytes */ 514 /* sufficient to hold the size value. */ 515 /* */ 516 /* There are at least two fonts, HANNOM-A and HANNOM-B version */ 517 /* 2.0 (2005), which get this wrong: The upper two bytes of */ 518 /* the size value are set to 0xFF instead of 0x00. We catch */ 519 /* and fix this. */ 520 521 if ( record_size >= 0xFFFF0000UL ) 522 record_size &= 0xFFFFU; 523 524 /* The limit for `num_records' is a heuristic value. */ 525 526 if ( version != 0 || num_records > 255 || record_size > 0x10001L ) 527 { 528 error = TT_Err_Invalid_File_Format; 529 goto Fail; 530 } 531 532 if ( FT_NEW_ARRAY( face->hdmx_record_sizes, num_records ) ) 533 goto Fail; 534 535 for ( nn = 0; nn < num_records; nn++ ) 536 { 537 if ( p + record_size > limit ) 538 break; 539 540 face->hdmx_record_sizes[nn] = p[0]; 541 p += record_size; 542 } 543 544 face->hdmx_record_count = nn; 545 face->hdmx_table_size = table_size; 546 face->hdmx_record_size = record_size; 547 548 Exit: 549 return error; 550 551 Fail: 552 FT_FRAME_RELEASE( face->hdmx_table ); 553 face->hdmx_table_size = 0; 554 goto Exit; 555 } 556 557 558 FT_LOCAL_DEF( void ) 559 tt_face_free_hdmx( TT_Face face ) 560 { 561 FT_Stream stream = face->root.stream; 562 FT_Memory memory = stream->memory; 563 564 565 FT_FREE( face->hdmx_record_sizes ); 566 FT_FRAME_RELEASE( face->hdmx_table ); 567 } 568 569 570 /*************************************************************************/ 571 /* */ 572 /* Return the advance width table for a given pixel size if it is found */ 573 /* in the font's `hdmx' table (if any). */ 574 /* */ 575 FT_LOCAL_DEF( FT_Byte* ) 576 tt_face_get_device_metrics( TT_Face face, 577 FT_UInt ppem, 578 FT_UInt gindex ) 579 { 580 FT_UInt nn; 581 FT_Byte* result = NULL; 582 FT_ULong record_size = face->hdmx_record_size; 583 FT_Byte* record = face->hdmx_table + 8; 584 585 586 for ( nn = 0; nn < face->hdmx_record_count; nn++ ) 587 if ( face->hdmx_record_sizes[nn] == ppem ) 588 { 589 gindex += 2; 590 if ( gindex < record_size ) 591 result = record + nn * record_size + gindex; 592 break; 593 } 594 595 return result; 596 } 597 598 599/* END */