core/src/fxge/fx_freetype/fxft2.5.01/src/truetype/ttobjs.c - Issue 815103002: Update freetype to 2.5.4.

Side by Side Diff: core/src/fxge/fx_freetype/fxft2.5.01/src/truetype/ttobjs.c

Issue 815103002: Update freetype to 2.5.4. (Closed) Base URL: https://pdfium.googlesource.com/pdfium.git@master

Patch Set: Adjust GYP and GN Created 6 years ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
1 /***************************************************************************/

2 /* */

3 /* ttobjs.c */

4 /* */

5 /* Objects manager (body). */

6 /* */

7 /* Copyright 1996-2013 */

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 "../../include/ft2build.h"

20 #include "../../include/freetype/internal/ftdebug.h"

21 #include "../../include/freetype/internal/ftstream.h"

22 #include "../../include/freetype/tttags.h"

23 #include "../../include/freetype/internal/sfnt.h"

24 #include "../../include/freetype/ftttdrv.h"

25

26 #include "ttgload.h"

27 #include "ttpload.h"

28

29 #include "tterrors.h"

30

31 #ifdef TT_USE_BYTECODE_INTERPRETER

32 #include "ttinterp.h"

33 #endif

34

35 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING

36 #include "../../include/freetype/ttunpat.h"

37 #endif

38

39 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT

40 #include "ttgxvar.h"

41 #endif

42

43 /*************************************************************************/

44 /* */

45 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */

46 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */

47 /* messages during execution. */

48 /* */

49 #undef FT_COMPONENT

50 #define FT_COMPONENT trace_ttobjs

51

52

53 #ifdef TT_USE_BYTECODE_INTERPRETER

54

55 /*************************************************************************/

56 /* */

57 /* GLYPH ZONE FUNCTIONS */

58 /* */

59 /*************************************************************************/

60

61

62 /*************************************************************************/

63 /* */

64 /* <Function> */

65 /* tt_glyphzone_done */

66 /* */

67 /* <Description> */

68 /* Deallocate a glyph zone. */

69 /* */

70 /* <Input> */

71 /* zone :: A pointer to the target glyph zone. */

72 /* */

73 FT_LOCAL_DEF( void )

74 tt_glyphzone_done( TT_GlyphZone zone )

75 {

76 FT_Memory memory = zone->memory;

77

78

79 if ( memory )

80 {

81 FT_FREE( zone->contours );

82 FT_FREE( zone->tags );

83 FT_FREE( zone->cur );

84 FT_FREE( zone->org );

85 FT_FREE( zone->orus );

86

87 zone->max_points = zone->n_points = 0;

88 zone->max_contours = zone->n_contours = 0;

89 zone->memory = NULL;

90 }

91 }

92

93

94 /*************************************************************************/

95 /* */

96 /* <Function> */

97 /* tt_glyphzone_new */

98 /* */

99 /* <Description> */

100 /* Allocate a new glyph zone. */

101 /* */

102 /* <Input> */

103 /* memory :: A handle to the current memory object. */

104 /* */

105 /* maxPoints :: The capacity of glyph zone in points. */

106 /* */

107 /* maxContours :: The capacity of glyph zone in contours. */

108 /* */

109 /* <Output> */

110 /* zone :: A pointer to the target glyph zone record. */

111 /* */

112 /* <Return> */

113 /* FreeType error code. 0 means success. */

114 /* */

115 FT_LOCAL_DEF( FT_Error )

116 tt_glyphzone_new( FT_Memory memory,

117 FT_UShort maxPoints,

118 FT_Short maxContours,

119 TT_GlyphZone zone )

120 {

121 FT_Error error;

122

123

124 FT_MEM_ZERO( zone, sizeof ( *zone ) );

125 zone->memory = memory;

126

127 if ( FT_NEW_ARRAY( zone->org, maxPoints ) \|\|

128 FT_NEW_ARRAY( zone->cur, maxPoints ) \|\|

129 FT_NEW_ARRAY( zone->orus, maxPoints ) \|\|

130 FT_NEW_ARRAY( zone->tags, maxPoints ) \|\|

131 FT_NEW_ARRAY( zone->contours, maxContours ) )

132 {

133 tt_glyphzone_done( zone );

134 }

135 else

136 {

137 zone->max_points = maxPoints;

138 zone->max_contours = maxContours;

139 }

140

141 return error;

142 }

143 #endif /* TT_USE_BYTECODE_INTERPRETER */

144

145

146 /* Compare the face with a list of well-known `tricky' fonts. */

147 /* This list shall be expanded as we find more of them. */

148

149 static FT_Bool

150 tt_check_trickyness_family( FT_String* name )

151 {

152

153 #define TRICK_NAMES_MAX_CHARACTERS 16

154 #define TRICK_NAMES_COUNT 8

155

156 static const char trick_names[TRICK_NAMES_COUNT]

157 [TRICK_NAMES_MAX_CHARACTERS + 1] =

158 {

159 "DFKaiSho-SB", /* dfkaisb.ttf */

160 "DFKaiShu",

161 "DFKai-SB", /* kaiu.ttf */

162 "HuaTianKaiTi?", /* htkt2.ttf */

163 "HuaTianSongTi?", /* htst3.ttf */

164 "MingLiU", /* mingliu.ttf & mingliu.ttc */

165 "PMingLiU", /* mingliu.ttc */

166 "MingLi43", /* mingli.ttf */

167 };

168

169 int nn;

170

171

172 for ( nn = 0; nn < TRICK_NAMES_COUNT; nn++ )

173 if ( ft_strstr( name, trick_names[nn] ) )

174 return TRUE;

175

176 return FALSE;

177 }

178

179

180 /* XXX: This function should be in the `sfnt' module. */

181

182 /* Some PDF generators clear the checksums in the TrueType header table. */

183 /* For example, Quartz ContextPDF clears all entries, or Bullzip PDF */

184 /* Printer clears the entries for subsetted subtables. We thus have to */

185 /* recalculate the checksums where necessary. */

186

187 static FT_UInt32

188 tt_synth_sfnt_checksum( FT_Stream stream,

189 FT_ULong length )

190 {

191 FT_Error error;

192 FT_UInt32 checksum = 0;

193 int i;

194

195

196 if ( FT_FRAME_ENTER( length ) )

197 return 0;

198

199 for ( ; length > 3; length -= 4 )

200 checksum += (FT_UInt32)FT_GET_ULONG();

201

202 for ( i = 3; length > 0; length --, i-- )

203 checksum += (FT_UInt32)( FT_GET_BYTE() << ( i * 8 ) );

204

205 FT_FRAME_EXIT();

206

207 return checksum;

208 }

209

210

211 /* XXX: This function should be in the `sfnt' module. */

212

213 static FT_ULong

214 tt_get_sfnt_checksum( TT_Face face,

215 FT_UShort i )

216 {

217 #if 0 /* if we believe the written value, use following part. */

218 if ( face->dir_tables[i].CheckSum )

219 return face->dir_tables[i].CheckSum;

220 #endif

221

222 if ( !face->goto_table )

223 return 0;

224

225 if ( face->goto_table( face,

226 face->dir_tables[i].Tag,

227 face->root.stream,

228 NULL ) )

229 return 0;

230

231 return (FT_ULong)tt_synth_sfnt_checksum( face->root.stream,

232 face->dir_tables[i].Length );

233 }

234

235

236 typedef struct tt_sfnt_id_rec_

237 {

238 FT_ULong CheckSum;

239 FT_ULong Length;

240

241 } tt_sfnt_id_rec;

242

243

244 static FT_Bool

245 tt_check_trickyness_sfnt_ids( TT_Face face )

246 {

247 #define TRICK_SFNT_IDS_PER_FACE 3

248 #define TRICK_SFNT_IDS_NUM_FACES 17

249

250 static const tt_sfnt_id_rec sfnt_id[TRICK_SFNT_IDS_NUM_FACES]

251 [TRICK_SFNT_IDS_PER_FACE] = {

252

253 #define TRICK_SFNT_ID_cvt 0

254 #define TRICK_SFNT_ID_fpgm 1

255 #define TRICK_SFNT_ID_prep 2

256

257 { /* MingLiU 1995 */

258 { 0x05bcf058, 0x000002e4 }, /* cvt */

259 { 0x28233bf1, 0x000087c4 }, /* fpgm */

260 { 0xa344a1ea, 0x000001e1 } /* prep */

261 },

262 { /* MingLiU 1996- */

263 { 0x05bcf058, 0x000002e4 }, /* cvt */

264 { 0x28233bf1, 0x000087c4 }, /* fpgm */

265 { 0xa344a1eb, 0x000001e1 } /* prep */

266 },

267 { /* DFKaiShu */

268 { 0x11e5ead4, 0x00000350 }, /* cvt */

269 { 0x5a30ca3b, 0x00009063 }, /* fpgm */

270 { 0x13a42602, 0x0000007e } /* prep */

271 },

272 { /* HuaTianKaiTi */

273 { 0xfffbfffc, 0x00000008 }, /* cvt */

274 { 0x9c9e48b8, 0x0000bea2 }, /* fpgm */

275 { 0x70020112, 0x00000008 } /* prep */

276 },

277 { /* HuaTianSongTi */

278 { 0xfffbfffc, 0x00000008 }, /* cvt */

279 { 0x0a5a0483, 0x00017c39 }, /* fpgm */

280 { 0x70020112, 0x00000008 } /* prep */

281 },

282 { /* NEC fadpop7.ttf */

283 { 0x00000000, 0x00000000 }, /* cvt */

284 { 0x40c92555, 0x000000e5 }, /* fpgm */

285 { 0xa39b58e3, 0x0000117c } /* prep */

286 },

287 { /* NEC fadrei5.ttf */

288 { 0x00000000, 0x00000000 }, /* cvt */

289 { 0x33c41652, 0x000000e5 }, /* fpgm */

290 { 0x26d6c52a, 0x00000f6a } /* prep */

291 },

292 { /* NEC fangot7.ttf */

293 { 0x00000000, 0x00000000 }, /* cvt */

294 { 0x6db1651d, 0x0000019d }, /* fpgm */

295 { 0x6c6e4b03, 0x00002492 } /* prep */

296 },

297 { /* NEC fangyo5.ttf */

298 { 0x00000000, 0x00000000 }, /* cvt */

299 { 0x40c92555, 0x000000e5 }, /* fpgm */

300 { 0xde51fad0, 0x0000117c } /* prep */

301 },

302 { /* NEC fankyo5.ttf */

303 { 0x00000000, 0x00000000 }, /* cvt */

304 { 0x85e47664, 0x000000e5 }, /* fpgm */

305 { 0xa6c62831, 0x00001caa } /* prep */

306 },

307 { /* NEC fanrgo5.ttf */

308 { 0x00000000, 0x00000000 }, /* cvt */

309 { 0x2d891cfd, 0x0000019d }, /* fpgm */

310 { 0xa0604633, 0x00001de8 } /* prep */

311 },

312 { /* NEC fangot5.ttc */

313 { 0x00000000, 0x00000000 }, /* cvt */

314 { 0x40aa774c, 0x000001cb }, /* fpgm */

315 { 0x9b5caa96, 0x00001f9a } /* prep */

316 },

317 { /* NEC fanmin3.ttc */

318 { 0x00000000, 0x00000000 }, /* cvt */

319 { 0x0d3de9cb, 0x00000141 }, /* fpgm */

320 { 0xd4127766, 0x00002280 } /* prep */

321 },

322 { /* NEC FA-Gothic, 1996 */

323 { 0x00000000, 0x00000000 }, /* cvt */

324 { 0x4a692698, 0x000001f0 }, /* fpgm */

325 { 0x340d4346, 0x00001fca } /* prep */

326 },

327 { /* NEC FA-Minchou, 1996 */

328 { 0x00000000, 0x00000000 }, /* cvt */

329 { 0xcd34c604, 0x00000166 }, /* fpgm */

330 { 0x6cf31046, 0x000022b0 } /* prep */

331 },

332 { /* NEC FA-RoundGothicB, 1996 */

333 { 0x00000000, 0x00000000 }, /* cvt */

334 { 0x5da75315, 0x0000019d }, /* fpgm */

335 { 0x40745a5f, 0x000022e0 } /* prep */

336 },

337 { /* NEC FA-RoundGothicM, 1996 */

338 { 0x00000000, 0x00000000 }, /* cvt */

339 { 0xf055fc48, 0x000001c2 }, /* fpgm */

340 { 0x3900ded3, 0x00001e18 } /* prep */

341 }

342 };

343

344 FT_ULong checksum;

345 int num_matched_ids[TRICK_SFNT_IDS_NUM_FACES];

346 FT_Bool has_cvt, has_fpgm, has_prep;

347 FT_UShort i;

348 int j, k;

349

350

351 FT_MEM_SET( num_matched_ids, 0,

352 sizeof ( int ) * TRICK_SFNT_IDS_NUM_FACES );

353 has_cvt = FALSE;

354 has_fpgm = FALSE;

355 has_prep = FALSE;

356

357 for ( i = 0; i < face->num_tables; i++ )

358 {

359 checksum = 0;

360

361 switch( face->dir_tables[i].Tag )

362 {

363 case TTAG_cvt:

364 k = TRICK_SFNT_ID_cvt;

365 has_cvt = TRUE;

366 break;

367

368 case TTAG_fpgm:

369 k = TRICK_SFNT_ID_fpgm;

370 has_fpgm = TRUE;

371 break;

372

373 case TTAG_prep:

374 k = TRICK_SFNT_ID_prep;

375 has_prep = TRUE;

376 break;

377

378 default:

379 continue;

380 }

381

382 for ( j = 0; j < TRICK_SFNT_IDS_NUM_FACES; j++ )

383 if ( face->dir_tables[i].Length == sfnt_id[j][k].Length )

384 {

385 if ( !checksum )

386 checksum = tt_get_sfnt_checksum( face, i );

387

388 if ( sfnt_id[j][k].CheckSum == checksum )

389 num_matched_ids[j]++;

390

391 if ( num_matched_ids[j] == TRICK_SFNT_IDS_PER_FACE )

392 return TRUE;

393 }

394 }

395

396 for ( j = 0; j < TRICK_SFNT_IDS_NUM_FACES; j++ )

397 {

398 if ( !has_cvt && !sfnt_id[j][TRICK_SFNT_ID_cvt].Length )

399 num_matched_ids[j] ++;

400 if ( !has_fpgm && !sfnt_id[j][TRICK_SFNT_ID_fpgm].Length )

401 num_matched_ids[j] ++;

402 if ( !has_prep && !sfnt_id[j][TRICK_SFNT_ID_prep].Length )

403 num_matched_ids[j] ++;

404 if ( num_matched_ids[j] == TRICK_SFNT_IDS_PER_FACE )

405 return TRUE;

406 }

407

408 return FALSE;

409 }

410

411

412 static FT_Bool

413 tt_check_trickyness( FT_Face face )

414 {

415 if ( !face )

416 return FALSE;

417

418 /* For first, check the face name for quick check. */

419 if ( face->family_name &&

420 tt_check_trickyness_family( face->family_name ) )

421 return TRUE;

422

423 /* Type42 fonts may lack `name' tables, we thus try to identify */

424 /* tricky fonts by checking the checksums of Type42-persistent */

425 /* sfnt tables (`cvt', `fpgm', and `prep'). */

426 if ( tt_check_trickyness_sfnt_ids( (TT_Face)face ) )

427 return TRUE;

428

429 return FALSE;

430 }

431

432

433 /* Check whether `.notdef' is the only glyph in the `loca' table. */

434 static FT_Bool

435 tt_check_single_notdef( FT_Face ttface )

436 {

437 FT_Bool result = FALSE;

438

439 TT_Face face = (TT_Face)ttface;

440 FT_UInt asize;

441 FT_ULong i;

442 FT_ULong glyph_index = 0;

443 FT_UInt count = 0;

444

445

446 for( i = 0; i < face->num_locations; i++ )

447 {

448 tt_face_get_location( face, i, &asize );

449 if ( asize > 0 )

450 {

451 count += 1;

452 if ( count > 1 )

453 break;

454 glyph_index = i;

455 }

456 }

457

458 /* Only have a single outline. */

459 if ( count == 1 )

460 {

461 if ( glyph_index == 0 )

462 result = TRUE;

463 else

464 {

465 /* FIXME: Need to test glyphname == .notdef ? */

466 FT_Error error;

467 char buf[8];

468

469

470 error = FT_Get_Glyph_Name( ttface, glyph_index, buf, 8 );

471 if ( !error &&

472 buf[0] == '.' && !ft_strncmp( buf, ".notdef", 8 ) )

473 result = TRUE;

474 }

475 }

476

477 return result;

478 }

479

480

481 /*************************************************************************/

482 /* */

483 /* <Function> */

484 /* tt_face_init */

485 /* */

486 /* <Description> */

487 /* Initialize a given TrueType face object. */

488 /* */

489 /* <Input> */

490 /* stream :: The source font stream. */

491 /* */

492 /* face_index :: The index of the font face in the resource. */

493 /* */

494 /* num_params :: Number of additional generic parameters. Ignored. */

495 /* */

496 /* params :: Additional generic parameters. Ignored. */

497 /* */

498 /* <InOut> */

499 /* face :: The newly built face object. */

500 /* */

501 /* <Return> */

502 /* FreeType error code. 0 means success. */

503 /* */

504 FT_LOCAL_DEF( FT_Error )

505 tt_face_init( FT_Stream stream,

506 FT_Face ttface, /* TT_Face */

507 FT_Int face_index,

508 FT_Int num_params,

509 FT_Parameter* params )

510 {

511 FT_Error error;

512 FT_Library library;

513 SFNT_Service sfnt;

514 TT_Face face = (TT_Face)ttface;

515

516

517 FT_TRACE2(( "TTF driver\n" ));

518

519 library = ttface->driver->root.library;

520

521 sfnt = (SFNT_Service)FT_Get_Module_Interface( library, "sfnt" );

522 if ( !sfnt )

523 {

524 FT_ERROR(( "tt_face_init: cannot access `sfnt' module\n" ));

525 error = FT_THROW( Missing_Module );

526 goto Exit;

527 }

528

529 /* create input stream from resource */

530 if ( FT_STREAM_SEEK( 0 ) )

531 goto Exit;

532

533 /* check that we have a valid TrueType file */

534 error = sfnt->init_face( stream, face, face_index, num_params, params );

535 if ( error )

536 goto Exit;

537

538 /* We must also be able to accept Mac/GX fonts, as well as OT ones. */

539 /* The 0x00020000 tag is completely undocumented; some fonts from */

540 /* Arphic made for Chinese Windows 3.1 have this. */

541 if ( face->format_tag != 0x00010000L && /* MS fonts */

542 face->format_tag != 0x00020000L && /* CJK fonts for Win 3.1 */

543 face->format_tag != TTAG_true ) /* Mac fonts */

544 {

545 FT_TRACE2(( " not a TTF font\n" ));

546 goto Bad_Format;

547 }

548 else

549 {

550 FT_ULong table_len;

551 if (face->goto_table( face, TTAG_CFF, stream, &table_len) != TT_ Err_Table_Missing &&

552 face->goto_table( face, TTAG_loca, stream, &table_len) = = TT_Err_Table_Missing)

553 {

554 FT_TRACE2(( "[not a valid TTF font]\n" ));

555 goto Bad_Format;

556 }

557 }

558

559 #ifdef TT_USE_BYTECODE_INTERPRETER

560 ttface->face_flags \|= FT_FACE_FLAG_HINTER;

561 #endif

562

563 /* If we are performing a simple font format check, exit immediately. */

564 if ( face_index < 0 )

565 return FT_Err_Ok;

566

567 /* Load font directory */

568 error = sfnt->load_face( stream, face, face_index, num_params, params );

569 if ( error )

570 goto Exit;

571

572 if ( tt_check_trickyness( ttface ) )

573 ttface->face_flags \|= FT_FACE_FLAG_TRICKY;

574

575 error = tt_face_load_hdmx( face, stream );

576 if ( error )

577 goto Exit;

578

579 if ( FT_IS_SCALABLE( ttface ) )

580 {

581

582 #ifdef FT_CONFIG_OPTION_INCREMENTAL

583

584 if ( !ttface->internal->incremental_interface )

585 error = tt_face_load_loca( face, stream );

586 if ( !error )

587 error = tt_face_load_cvt( face, stream );

588 if ( !error )

589 error = tt_face_load_fpgm( face, stream );

590 if ( !error )

591 error = tt_face_load_prep( face, stream );

592

593 /* Check the scalable flag based on `loca'. */

594 if ( !ttface->internal->incremental_interface &&

595 ttface->num_fixed_sizes &&

596 face->glyph_locations &&

597 tt_check_single_notdef( ttface ) )

598 {

599 FT_TRACE5(( "tt_face_init:"

600 " Only the `.notdef' glyph has an outline.\n"

601 " "

602 " Resetting scalable flag to FALSE.\n" ));

603

604 ttface->face_flags &= ~FT_FACE_FLAG_SCALABLE;

605 }

606

607 #else

608

609 if ( !error )

610 error = tt_face_load_loca( face, stream );

611 if ( !error )

612 error = tt_face_load_cvt( face, stream );

613 if ( !error )

614 error = tt_face_load_fpgm( face, stream );

615 if ( !error )

616 error = tt_face_load_prep( face, stream );

617

618 /* Check the scalable flag based on `loca'. */

619 if ( ttface->num_fixed_sizes &&

620 face->glyph_locations &&

621 tt_check_single_notdef( ttface ) )

622 {

623 FT_TRACE5(( "tt_face_init:"

624 " Only the `.notdef' glyph has an outline.\n"

625 " "

626 " Resetting scalable flag to FALSE.\n" ));

627

628 ttface->face_flags &= ~FT_FACE_FLAG_SCALABLE;

629 }

630

631 #endif

632

633 }

634

635 #if defined( TT_CONFIG_OPTION_UNPATENTED_HINTING ) && \

636 !defined( TT_CONFIG_OPTION_BYTECODE_INTERPRETER )

637

638 {

639 FT_Bool unpatented_hinting;

640 int i;

641

642

643 /* Determine whether unpatented hinting is to be used for this face. */

644 unpatented_hinting = FT_BOOL

645 ( library->debug_hooks[FT_DEBUG_HOOK_UNPATENTED_HINTING] != NULL );

646

647 for ( i = 0; i < num_params && !face->unpatented_hinting; i++ )

648 if ( params[i].tag == FT_PARAM_TAG_UNPATENTED_HINTING )

649 unpatented_hinting = TRUE;

650

651 if ( !unpatented_hinting )

652 ttface->internal->ignore_unpatented_hinter = TRUE;

653 }

654

655 #endif /* TT_CONFIG_OPTION_UNPATENTED_HINTING &&

656 !TT_CONFIG_OPTION_BYTECODE_INTERPRETER */

657

658 /* initialize standard glyph loading routines */

659 TT_Init_Glyph_Loading( face );

660

661 Exit:

662 return error;

663

664 Bad_Format:

665 error = FT_THROW( Unknown_File_Format );

666 goto Exit;

667 }

668

669

670 /*************************************************************************/

671 /* */

672 /* <Function> */

673 /* tt_face_done */

674 /* */

675 /* <Description> */

676 /* Finalize a given face object. */

677 /* */

678 /* <Input> */

679 /* face :: A pointer to the face object to destroy. */

680 /* */

681 FT_LOCAL_DEF( void )

682 tt_face_done( FT_Face ttface ) /* TT_Face */

683 {

684 TT_Face face = (TT_Face)ttface;

685 FT_Memory memory;

686 FT_Stream stream;

687 SFNT_Service sfnt;

688

689

690 if ( !face )

691 return;

692

693 memory = ttface->memory;

694 stream = ttface->stream;

695 sfnt = (SFNT_Service)face->sfnt;

696

697 /* for `extended TrueType formats' (i.e. compressed versions) */

698 if ( face->extra.finalizer )

699 face->extra.finalizer( face->extra.data );

700

701 if ( sfnt )

702 sfnt->done_face( face );

703

704 /* freeing the locations table */

705 tt_face_done_loca( face );

706

707 tt_face_free_hdmx( face );

708

709 /* freeing the CVT */

710 FT_FREE( face->cvt );

711 face->cvt_size = 0;

712

713 /* freeing the programs */

714 FT_FRAME_RELEASE( face->font_program );

715 FT_FRAME_RELEASE( face->cvt_program );

716 face->font_program_size = 0;

717 face->cvt_program_size = 0;

718

719 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT

720 tt_done_blend( memory, face->blend );

721 face->blend = NULL;

722 #endif

723 }

724

725

726 /*************************************************************************/

727 /* */

728 /* SIZE FUNCTIONS */

729 /* */

730 /*************************************************************************/

731

732 #ifdef TT_USE_BYTECODE_INTERPRETER

733

734 /*************************************************************************/

735 /* */

736 /* <Function> */

737 /* tt_size_run_fpgm */

738 /* */

739 /* <Description> */

740 /* Run the font program. */

741 /* */

742 /* <Input> */

743 /* size :: A handle to the size object. */

744 /* */

745 /* pedantic :: Set if bytecode execution should be pedantic. */

746 /* */

747 /* <Return> */

748 /* FreeType error code. 0 means success. */

749 /* */

750 FT_LOCAL_DEF( FT_Error )

751 tt_size_run_fpgm( TT_Size size,

752 FT_Bool pedantic )

753 {

754 TT_Face face = (TT_Face)size->root.face;

755 TT_ExecContext exec;

756 FT_Error error;

757

758

759 /* debugging instances have their own context */

760 if ( size->debug )

761 exec = size->context;

762 else

763 exec = ( (TT_Driver)FT_FACE_DRIVER( face ) )->context;

764

765 if ( !exec )

766 return FT_THROW( Could_Not_Find_Context );

767

768 TT_Load_Context( exec, face, size );

769

770 exec->callTop = 0;

771 exec->top = 0;

772

773 exec->period = 64;

774 exec->phase = 0;

775 exec->threshold = 0;

776

777 exec->instruction_trap = FALSE;

778 exec->F_dot_P = 0x4000L;

779

780 exec->pedantic_hinting = pedantic;

781

782 {

783 FT_Size_Metrics* metrics = &exec->metrics;

784 TT_Size_Metrics* tt_metrics = &exec->tt_metrics;

785

786

787 metrics->x_ppem = 0;

788 metrics->y_ppem = 0;

789 metrics->x_scale = 0;

790 metrics->y_scale = 0;

791

792 tt_metrics->ppem = 0;

793 tt_metrics->scale = 0;

794 tt_metrics->ratio = 0x10000L;

795 }

796

797 /* allow font program execution */

798 TT_Set_CodeRange( exec,

799 tt_coderange_font,

800 face->font_program,

801 face->font_program_size );

802

803 /* disable CVT and glyph programs coderange */

804 TT_Clear_CodeRange( exec, tt_coderange_cvt );

805 TT_Clear_CodeRange( exec, tt_coderange_glyph );

806

807 if ( face->font_program_size > 0 )

808 {

809 error = TT_Goto_CodeRange( exec, tt_coderange_font, 0 );

810

811 if ( !error )

812 {

813 FT_TRACE4(( "Executing `fpgm' table.\n" ));

814

815 error = face->interpreter( exec );

816 }

817 }

818 else

819 error = FT_Err_Ok;

820

821 if ( !error )

822 TT_Save_Context( exec, size );

823

824 return error;

825 }

826

827

828 /*************************************************************************/

829 /* */

830 /* <Function> */

831 /* tt_size_run_prep */

832 /* */

833 /* <Description> */

834 /* Run the control value program. */

835 /* */

836 /* <Input> */

837 /* size :: A handle to the size object. */

838 /* */

839 /* pedantic :: Set if bytecode execution should be pedantic. */

840 /* */

841 /* <Return> */

842 /* FreeType error code. 0 means success. */

843 /* */

844 FT_LOCAL_DEF( FT_Error )

845 tt_size_run_prep( TT_Size size,

846 FT_Bool pedantic )

847 {

848 TT_Face face = (TT_Face)size->root.face;

849 TT_ExecContext exec;

850 FT_Error error;

851

852

853 /* debugging instances have their own context */

854 if ( size->debug )

855 exec = size->context;

856 else

857 exec = ( (TT_Driver)FT_FACE_DRIVER( face ) )->context;

858

859 if ( !exec )

860 return FT_THROW( Could_Not_Find_Context );

861

862 TT_Load_Context( exec, face, size );

863

864 exec->callTop = 0;

865 exec->top = 0;

866

867 exec->instruction_trap = FALSE;

868

869 exec->pedantic_hinting = pedantic;

870

871 TT_Set_CodeRange( exec,

872 tt_coderange_cvt,

873 face->cvt_program,

874 face->cvt_program_size );

875

876 TT_Clear_CodeRange( exec, tt_coderange_glyph );

877

878 if ( face->cvt_program_size > 0 )

879 {

880 error = TT_Goto_CodeRange( exec, tt_coderange_cvt, 0 );

881

882 if ( !error && !size->debug )

883 {

884 FT_TRACE4(( "Executing `prep' table.\n" ));

885

886 error = face->interpreter( exec );

887 }

888 }

889 else

890 error = FT_Err_Ok;

891

892 /* UNDOCUMENTED! The MS rasterizer doesn't allow the following */

893 /* graphics state variables to be modified by the CVT program. */

894

895 exec->GS.dualVector.x = 0x4000;

896 exec->GS.dualVector.y = 0;

897 exec->GS.projVector.x = 0x4000;

898 exec->GS.projVector.y = 0x0;

899 exec->GS.freeVector.x = 0x4000;

900 exec->GS.freeVector.y = 0x0;

901

902 exec->GS.rp0 = 0;

903 exec->GS.rp1 = 0;

904 exec->GS.rp2 = 0;

905

906 exec->GS.gep0 = 1;

907 exec->GS.gep1 = 1;

908 exec->GS.gep2 = 1;

909

910 exec->GS.loop = 1;

911

912 /* save as default graphics state */

913 size->GS = exec->GS;

914

915 TT_Save_Context( exec, size );

916

917 return error;

918 }

919

920 #endif /* TT_USE_BYTECODE_INTERPRETER */

921

922

923 #ifdef TT_USE_BYTECODE_INTERPRETER

924

925 static void

926 tt_size_done_bytecode( FT_Size ftsize )

927 {

928 TT_Size size = (TT_Size)ftsize;

929 TT_Face face = (TT_Face)ftsize->face;

930 FT_Memory memory = face->root.memory;

931

932

933 if ( size->debug )

934 {

935 /* the debug context must be deleted by the debugger itself */

936 size->context = NULL;

937 size->debug = FALSE;

938 }

939

940 FT_FREE( size->cvt );

941 size->cvt_size = 0;

942

943 /* free storage area */

944 FT_FREE( size->storage );

945 size->storage_size = 0;

946

947 /* twilight zone */

948 tt_glyphzone_done( &size->twilight );

949

950 FT_FREE( size->function_defs );

951 FT_FREE( size->instruction_defs );

952

953 size->num_function_defs = 0;

954 size->max_function_defs = 0;

955 size->num_instruction_defs = 0;

956 size->max_instruction_defs = 0;

957

958 size->max_func = 0;

959 size->max_ins = 0;

960

961 size->bytecode_ready = 0;

962 size->cvt_ready = 0;

963 }

964

965

966 /* Initialize bytecode-related fields in the size object. */

967 /* We do this only if bytecode interpretation is really needed. */

968 static FT_Error

969 tt_size_init_bytecode( FT_Size ftsize,

970 FT_Bool pedantic )

971 {

972 FT_Error error;

973 TT_Size size = (TT_Size)ftsize;

974 TT_Face face = (TT_Face)ftsize->face;

975 FT_Memory memory = face->root.memory;

976 FT_Int i;

977

978 FT_UShort n_twilight;

979 TT_MaxProfile* maxp = &face->max_profile;

980

981

982 size->bytecode_ready = 1;

983 size->cvt_ready = 0;

984

985 size->max_function_defs = maxp->maxFunctionDefs;

986 size->max_instruction_defs = maxp->maxInstructionDefs;

987

988 size->num_function_defs = 0;

989 size->num_instruction_defs = 0;

990

991 size->max_func = 0;

992 size->max_ins = 0;

993

994 size->cvt_size = face->cvt_size;

995 size->storage_size = maxp->maxStorage;

996

997 /* Set default metrics */

998 {

999 TT_Size_Metrics* metrics = &size->ttmetrics;

1000

1001

1002 metrics->rotated = FALSE;

1003 metrics->stretched = FALSE;

1004

1005 /* set default compensation (all 0) */

1006 for ( i = 0; i < 4; i++ )

1007 metrics->compensations[i] = 0;

1008 }

1009

1010 /* allocate function defs, instruction defs, cvt, and storage area */

1011 if ( FT_NEW_ARRAY( size->function_defs, size->max_function_defs ) \|\|

1012 FT_NEW_ARRAY( size->instruction_defs, size->max_instruction_defs ) \|\|

1013 FT_NEW_ARRAY( size->cvt, size->cvt_size ) \|\|

1014 FT_NEW_ARRAY( size->storage, size->storage_size ) )

1015 goto Exit;

1016

1017 /* reserve twilight zone */

1018 n_twilight = maxp->maxTwilightPoints;

1019

1020 /* there are 4 phantom points (do we need this?) */

1021 n_twilight += 4;

1022

1023 error = tt_glyphzone_new( memory, n_twilight, 0, &size->twilight );

1024 if ( error )

1025 goto Exit;

1026

1027 size->twilight.n_points = n_twilight;

1028

1029 size->GS = tt_default_graphics_state;

1030

1031 /* set `face->interpreter' according to the debug hook present */

1032 {

1033 FT_Library library = face->root.driver->root.library;

1034

1035

1036 face->interpreter = (TT_Interpreter)

1037 library->debug_hooks[FT_DEBUG_HOOK_TRUETYPE];

1038 if ( !face->interpreter )

1039 face->interpreter = (TT_Interpreter)TT_RunIns;

1040 }

1041

1042 /* Fine, now run the font program! */

1043 error = tt_size_run_fpgm( size, pedantic );

1044 /* It seems fpgm proc is causing some problem for some font, so we ignor e the error. TESTDOC: Bug #12690 - Restaurantkarte_Oktober09+Wild.pdf*/

1045 if ( error )

1046 tt_size_done_bytecode( ftsize );

1047 return TT_Err_Ok;

1048

1049 Exit:

1050 if ( error )

1051 tt_size_done_bytecode( ftsize );

1052

1053 return error;

1054 }

1055

1056

1057 FT_LOCAL_DEF( FT_Error )

1058 tt_size_ready_bytecode( TT_Size size,

1059 FT_Bool pedantic )

1060 {

1061 FT_Error error = FT_Err_Ok;

1062

1063

1064 if ( !size->bytecode_ready )

1065 {

1066 error = tt_size_init_bytecode( (FT_Size)size, pedantic );

1067 if ( error )

1068 goto Exit;

1069 }

1070

1071 /* rescale CVT when needed */

1072 if ( !size->cvt_ready )

1073 {

1074 FT_UInt i;

1075 TT_Face face = (TT_Face)size->root.face;

1076

1077

1078 /* Scale the cvt values to the new ppem. */

1079 /* We use by default the y ppem to scale the CVT. */

1080 for ( i = 0; i < size->cvt_size; i++ )

1081 size->cvt[i] = FT_MulFix( face->cvt[i], size->ttmetrics.scale );

1082

1083 /* all twilight points are originally zero */

1084 for ( i = 0; i < (FT_UInt)size->twilight.n_points; i++ )

1085 {

1086 size->twilight.org[i].x = 0;

1087 size->twilight.org[i].y = 0;

1088 size->twilight.cur[i].x = 0;

1089 size->twilight.cur[i].y = 0;

1090 }

1091

1092 /* clear storage area */

1093 for ( i = 0; i < (FT_UInt)size->storage_size; i++ )

1094 size->storage[i] = 0;

1095

1096 size->GS = tt_default_graphics_state;

1097

1098 tt_size_run_prep( size, pedantic );/* It seems prep proc is causing some p roblem for some font, so we ignore the error. TESTDOC: Bug #5025 - naredba-rd-16 -296.pdf */

1099 /* However we can't disable the prep. TESTDOC: Bug #0063 - 050826_diff er_table.pdf, page #4 */

1100 if ( !error )

1101 size->cvt_ready = 1;

1102 }

1103

1104 Exit:

1105 return error;

1106 }

1107

1108 #endif /* TT_USE_BYTECODE_INTERPRETER */

1109

1110

1111 /*************************************************************************/

1112 /* */

1113 /* <Function> */

1114 /* tt_size_init */

1115 /* */

1116 /* <Description> */

1117 /* Initialize a new TrueType size object. */

1118 /* */

1119 /* <InOut> */

1120 /* size :: A handle to the size object. */

1121 /* */

1122 /* <Return> */

1123 /* FreeType error code. 0 means success. */

1124 /* */

1125 FT_LOCAL_DEF( FT_Error )

1126 tt_size_init( FT_Size ttsize ) /* TT_Size */

1127 {

1128 TT_Size size = (TT_Size)ttsize;

1129 FT_Error error = FT_Err_Ok;

1130

1131 #ifdef TT_USE_BYTECODE_INTERPRETER

1132 size->bytecode_ready = 0;

1133 size->cvt_ready = 0;

1134 #endif

1135

1136 size->ttmetrics.valid = FALSE;

1137 size->strike_index = 0xFFFFFFFFUL;

1138

1139 return error;

1140 }

1141

1142

1143 /*************************************************************************/

1144 /* */

1145 /* <Function> */

1146 /* tt_size_done */

1147 /* */

1148 /* <Description> */

1149 /* The TrueType size object finalizer. */

1150 /* */

1151 /* <Input> */

1152 /* size :: A handle to the target size object. */

1153 /* */

1154 FT_LOCAL_DEF( void )

1155 tt_size_done( FT_Size ttsize ) /* TT_Size */

1156 {

1157 TT_Size size = (TT_Size)ttsize;

1158

1159

1160 #ifdef TT_USE_BYTECODE_INTERPRETER

1161 if ( size->bytecode_ready )

1162 tt_size_done_bytecode( ttsize );

1163 #endif

1164

1165 size->ttmetrics.valid = FALSE;

1166 }

1167

1168

1169 /*************************************************************************/

1170 /* */

1171 /* <Function> */

1172 /* tt_size_reset */

1173 /* */

1174 /* <Description> */

1175 /* Reset a TrueType size when resolutions and character dimensions */

1176 /* have been changed. */

1177 /* */

1178 /* <Input> */

1179 /* size :: A handle to the target size object. */

1180 /* */

1181 FT_LOCAL_DEF( FT_Error )

1182 tt_size_reset( TT_Size size )

1183 {

1184 TT_Face face;

1185 FT_Error error = FT_Err_Ok;

1186 FT_Size_Metrics* metrics;

1187

1188

1189 size->ttmetrics.valid = FALSE;

1190

1191 face = (TT_Face)size->root.face;

1192

1193 metrics = &size->metrics;

1194

1195 /* copy the result from base layer */

1196 *metrics = size->root.metrics;

1197

1198 if ( metrics->x_ppem < 1 \|\| metrics->y_ppem < 1 )

1199 return FT_THROW( Invalid_PPem );

1200

1201 /* This bit flag, if set, indicates that the ppems must be */

1202 /* rounded to integers. Nearly all TrueType fonts have this bit */

1203 /* set, as hinting won't work really well otherwise. */

1204 /* */

1205 if ( face->header.Flags & 8 )

1206 {

1207 metrics->x_scale = FT_DivFix( metrics->x_ppem << 6,

1208 face->root.units_per_EM );

1209 metrics->y_scale = FT_DivFix( metrics->y_ppem << 6,

1210 face->root.units_per_EM );

1211

1212 metrics->ascender =

1213 FT_PIX_ROUND( FT_MulFix( face->root.ascender, metrics->y_scale ) );

1214 metrics->descender =

1215 FT_PIX_ROUND( FT_MulFix( face->root.descender, metrics->y_scale ) );

1216 metrics->height =

1217 FT_PIX_ROUND( FT_MulFix( face->root.height, metrics->y_scale ) );

1218 metrics->max_advance =

1219 FT_PIX_ROUND( FT_MulFix( face->root.max_advance_width,

1220 metrics->x_scale ) );

1221 }

1222

1223 /* compute new transformation */

1224 if ( metrics->x_ppem >= metrics->y_ppem )

1225 {

1226 size->ttmetrics.scale = metrics->x_scale;

1227 size->ttmetrics.ppem = metrics->x_ppem;

1228 size->ttmetrics.x_ratio = 0x10000L;

1229 size->ttmetrics.y_ratio = FT_DivFix( metrics->y_ppem,

1230 metrics->x_ppem );

1231 }

1232 else

1233 {

1234 size->ttmetrics.scale = metrics->y_scale;

1235 size->ttmetrics.ppem = metrics->y_ppem;

1236 size->ttmetrics.x_ratio = FT_DivFix( metrics->x_ppem,

1237 metrics->y_ppem );

1238 size->ttmetrics.y_ratio = 0x10000L;

1239 }

1240

1241 #ifdef TT_USE_BYTECODE_INTERPRETER

1242 size->cvt_ready = 0;

1243 #endif /* TT_USE_BYTECODE_INTERPRETER */

1244

1245 if ( !error )

1246 size->ttmetrics.valid = TRUE;

1247

1248 return error;

1249 }

1250

1251

1252 /*************************************************************************/

1253 /* */

1254 /* <Function> */

1255 /* tt_driver_init */

1256 /* */

1257 /* <Description> */

1258 /* Initialize a given TrueType driver object. */

1259 /* */

1260 /* <Input> */

1261 /* driver :: A handle to the target driver object. */

1262 /* */

1263 /* <Return> */

1264 /* FreeType error code. 0 means success. */

1265 /* */

1266 FT_LOCAL_DEF( FT_Error )

1267 tt_driver_init( FT_Module ttdriver ) /* TT_Driver */

1268 {

1269

1270 #ifdef TT_USE_BYTECODE_INTERPRETER

1271

1272 TT_Driver driver = (TT_Driver)ttdriver;

1273

1274

1275 if ( !TT_New_Context( driver ) )

1276 return FT_THROW( Could_Not_Find_Context );

1277

1278 #ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING

1279 driver->interpreter_version = TT_INTERPRETER_VERSION_38;

1280 #else

1281 driver->interpreter_version = TT_INTERPRETER_VERSION_35;

1282 #endif

1283

1284 #else /* !TT_USE_BYTECODE_INTERPRETER */

1285

1286 FT_UNUSED( ttdriver );

1287

1288 #endif /* !TT_USE_BYTECODE_INTERPRETER */

1289

1290 return FT_Err_Ok;

1291 }

1292

1293

1294 /*************************************************************************/

1295 /* */

1296 /* <Function> */

1297 /* tt_driver_done */

1298 /* */

1299 /* <Description> */

1300 /* Finalize a given TrueType driver. */

1301 /* */

1302 /* <Input> */

1303 /* driver :: A handle to the target TrueType driver. */

1304 /* */

1305 FT_LOCAL_DEF( void )

1306 tt_driver_done( FT_Module ttdriver ) /* TT_Driver */

1307 {

1308 #ifdef TT_USE_BYTECODE_INTERPRETER

1309 TT_Driver driver = (TT_Driver)ttdriver;

1310

1311

1312 /* destroy the execution context */

1313 if ( driver->context )

1314 {

1315 TT_Done_Context( driver->context );

1316 driver->context = NULL;

1317 }

1318 #else

1319 FT_UNUSED( ttdriver );

1320 #endif

1321

1322 }

1323

1324

1325 /*************************************************************************/

1326 /* */

1327 /* <Function> */

1328 /* tt_slot_init */

1329 /* */

1330 /* <Description> */

1331 /* Initialize a new slot object. */

1332 /* */

1333 /* <InOut> */

1334 /* slot :: A handle to the slot object. */

1335 /* */

1336 /* <Return> */

1337 /* FreeType error code. 0 means success. */

1338 /* */

1339 FT_LOCAL_DEF( FT_Error )

1340 tt_slot_init( FT_GlyphSlot slot )

1341 {

1342 return FT_GlyphLoader_CreateExtra( slot->internal->loader );

1343 }

1344

1345

1346 /* END */

OLD	NEW