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

Side by Side Diff: core/src/fxge/fx_freetype/fxft2.5.01/src/pshinter/pshglob.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 /* pshglob.c */

4 /* */

5 /* PostScript hinter global hinting management (body). */

6 /* Inspired by the new auto-hinter module. */

7 /* */

8 /* Copyright 2001-2004, 2006, 2010, 2012 by */

9 /* David Turner, Robert Wilhelm, and Werner Lemberg. */

10 /* */

11 /* This file is part of the FreeType project, and may only be used */

12 /* modified and distributed under the terms of the FreeType project */

13 /* license, LICENSE.TXT. By continuing to use, modify, or distribute */

14 /* this file you indicate that you have read the license and */

15 /* understand and accept it fully. */

16 /* */

17 /***************************************************************************/

18

19

20 #include "../../include/ft2build.h"

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

22 #include "../../include/freetype/internal/ftobjs.h"

23 #include "pshglob.h"

24

25 #ifdef DEBUG_HINTER

26 PSH_Globals ps_debug_globals = 0;

27 #endif

28

29

30 /*************************************************************************/

31 /*************************************************************************/

32 /*** ***/

33 /*** STANDARD WIDTHS ***/

34 /*** ***/

35 /*************************************************************************/

36 /*************************************************************************/

37

38

39 /* scale the widths/heights table */

40 static void

41 psh_globals_scale_widths( PSH_Globals globals,

42 FT_UInt direction )

43 {

44 PSH_Dimension dim = &globals->dimension[direction];

45 PSH_Widths stdw = &dim->stdw;

46 FT_UInt count = stdw->count;

47 PSH_Width width = stdw->widths;

48 PSH_Width stand = width; /* standard width/height */

49 FT_Fixed scale = dim->scale_mult;

50

51

52 if ( count > 0 )

53 {

54 width->cur = FT_MulFix( width->org, scale );

55 width->fit = FT_PIX_ROUND( width->cur );

56

57 width++;

58 count--;

59

60 for ( ; count > 0; count--, width++ )

61 {

62 FT_Pos w, dist;

63

64

65 w = FT_MulFix( width->org, scale );

66 dist = w - stand->cur;

67

68 if ( dist < 0 )

69 dist = -dist;

70

71 if ( dist < 128 )

72 w = stand->cur;

73

74 width->cur = w;

75 width->fit = FT_PIX_ROUND( w );

76 }

77 }

78 }

79

80

81 #if 0

82

83 /* org_width is is font units, result in device pixels, 26.6 format */

84 FT_LOCAL_DEF( FT_Pos )

85 psh_dimension_snap_width( PSH_Dimension dimension,

86 FT_Int org_width )

87 {

88 FT_UInt n;

89 FT_Pos width = FT_MulFix( org_width, dimension->scale_mult );

90 FT_Pos best = 64 + 32 + 2;

91 FT_Pos reference = width;

92

93

94 for ( n = 0; n < dimension->stdw.count; n++ )

95 {

96 FT_Pos w;

97 FT_Pos dist;

98

99

100 w = dimension->stdw.widths[n].cur;

101 dist = width - w;

102 if ( dist < 0 )

103 dist = -dist;

104 if ( dist < best )

105 {

106 best = dist;

107 reference = w;

108 }

109 }

110

111 if ( width >= reference )

112 {

113 width -= 0x21;

114 if ( width < reference )

115 width = reference;

116 }

117 else

118 {

119 width += 0x21;

120 if ( width > reference )

121 width = reference;

122 }

123

124 return width;

125 }

126

127 #endif /* 0 */

128

129

130 /*************************************************************************/

131 /*************************************************************************/

132 /*** ***/

133 /*** BLUE ZONES ***/

134 /*** ***/

135 /*************************************************************************/

136 /*************************************************************************/

137

138 static void

139 psh_blues_set_zones_0( PSH_Blues target,

140 FT_Bool is_others,

141 FT_UInt read_count,

142 FT_Short* read,

143 PSH_Blue_Table top_table,

144 PSH_Blue_Table bot_table )

145 {

146 FT_UInt count_top = top_table->count;

147 FT_UInt count_bot = bot_table->count;

148 FT_Bool first = 1;

149

150 FT_UNUSED( target );

151

152

153 for ( ; read_count > 1; read_count -= 2 )

154 {

155 FT_Int reference, delta;

156 FT_UInt count;

157 PSH_Blue_Zone zones, zone;

158 FT_Bool top;

159

160

161 /* read blue zone entry, and select target top/bottom zone */

162 top = 0;

163 if ( first \|\| is_others )

164 {

165 reference = read[1];

166 delta = read[0] - reference;

167

168 zones = bot_table->zones;

169 count = count_bot;

170 first = 0;

171 }

172 else

173 {

174 reference = read[0];

175 delta = read[1] - reference;

176

177 zones = top_table->zones;

178 count = count_top;

179 top = 1;

180 }

181

182 /* insert into sorted table */

183 zone = zones;

184 for ( ; count > 0; count--, zone++ )

185 {

186 if ( reference < zone->org_ref )

187 break;

188

189 if ( reference == zone->org_ref )

190 {

191 FT_Int delta0 = zone->org_delta;

192

193

194 /* we have two zones on the same reference position -- */

195 /* only keep the largest one */

196 if ( delta < 0 )

197 {

198 if ( delta < delta0 )

199 zone->org_delta = delta;

200 }

201 else

202 {

203 if ( delta > delta0 )

204 zone->org_delta = delta;

205 }

206 goto Skip;

207 }

208 }

209

210 for ( ; count > 0; count-- )

211 zone[count] = zone[count-1];

212

213 zone->org_ref = reference;

214 zone->org_delta = delta;

215

216 if ( top )

217 count_top++;

218 else

219 count_bot++;

220

221 Skip:

222 read += 2;

223 }

224

225 top_table->count = count_top;

226 bot_table->count = count_bot;

227 }

228

229

230 /* Re-read blue zones from the original fonts and store them into out */

231 /* private structure. This function re-orders, sanitizes and */

232 /* fuzz-expands the zones as well. */

233 static void

234 psh_blues_set_zones( PSH_Blues target,

235 FT_UInt count,

236 FT_Short* blues,

237 FT_UInt count_others,

238 FT_Short* other_blues,

239 FT_Int fuzz,

240 FT_Int family )

241 {

242 PSH_Blue_Table top_table, bot_table;

243 FT_Int count_top, count_bot;

244

245

246 if ( family )

247 {

248 top_table = &target->family_top;

249 bot_table = &target->family_bottom;

250 }

251 else

252 {

253 top_table = &target->normal_top;

254 bot_table = &target->normal_bottom;

255 }

256

257 /* read the input blue zones, and build two sorted tables */

258 /* (one for the top zones, the other for the bottom zones) */

259 top_table->count = 0;

260 bot_table->count = 0;

261

262 /* first, the blues */

263 psh_blues_set_zones_0( target, 0,

264 count, blues, top_table, bot_table );

265 psh_blues_set_zones_0( target, 1,

266 count_others, other_blues, top_table, bot_table );

267

268 count_top = top_table->count;

269 count_bot = bot_table->count;

270

271 /* sanitize top table */

272 if ( count_top > 0 )

273 {

274 PSH_Blue_Zone zone = top_table->zones;

275

276

277 for ( count = count_top; count > 0; count--, zone++ )

278 {

279 FT_Int delta;

280

281

282 if ( count > 1 )

283 {

284 delta = zone[1].org_ref - zone[0].org_ref;

285 if ( zone->org_delta > delta )

286 zone->org_delta = delta;

287 }

288

289 zone->org_bottom = zone->org_ref;

290 zone->org_top = zone->org_delta + zone->org_ref;

291 }

292 }

293

294 /* sanitize bottom table */

295 if ( count_bot > 0 )

296 {

297 PSH_Blue_Zone zone = bot_table->zones;

298

299

300 for ( count = count_bot; count > 0; count--, zone++ )

301 {

302 FT_Int delta;

303

304

305 if ( count > 1 )

306 {

307 delta = zone[0].org_ref - zone[1].org_ref;

308 if ( zone->org_delta < delta )

309 zone->org_delta = delta;

310 }

311

312 zone->org_top = zone->org_ref;

313 zone->org_bottom = zone->org_delta + zone->org_ref;

314 // XYQ 2006-3-11: FT PS hinter doesn't process wide zone well (a ll points shrinked to one horizontal line)

315 // therefore, we have to do some nasty thing here, because some fonts do give wide bottom zones.

316 // Our principle is to preserve the bottom line

317 // TEST DOC: bug#395 csl.pdf letters "y", "j", etc.

318 if (zone->org_top - zone->org_bottom > 10) {

319 zone->org_top = zone->org_bottom;

320 zone->org_delta = 0;

321 }

322 }

323 }

324

325 /* expand top and bottom tables with blue fuzz */

326 {

327 FT_Int dim, top, bot, delta;

328 PSH_Blue_Zone zone;

329

330

331 zone = top_table->zones;

332 count = count_top;

333

334 for ( dim = 1; dim >= 0; dim-- )

335 {

336 if ( count > 0 )

337 {

338 /* expand the bottom of the lowest zone normally */

339 zone->org_bottom -= fuzz;

340

341 /* expand the top and bottom of intermediate zones; */

342 /* checking that the interval is smaller than the fuzz */

343 top = zone->org_top;

344

345 for ( count--; count > 0; count-- )

346 {

347 bot = zone[1].org_bottom;

348 delta = bot - top;

349

350 if ( delta < 2 * fuzz )

351 zone[0].org_top = zone[1].org_bottom = top + delta / 2;

352 else

353 {

354 zone[0].org_top = top + fuzz;

355 zone[1].org_bottom = bot - fuzz;

356 }

357

358 zone++;

359 top = zone->org_top;

360 }

361

362 /* expand the top of the highest zone normally */

363 zone->org_top = top + fuzz;

364 }

365 zone = bot_table->zones;

366 count = count_bot;

367 }

368 }

369 }

370

371

372 /* reset the blues table when the device transform changes */

373 static void

374 psh_blues_scale_zones( PSH_Blues blues,

375 FT_Fixed scale,

376 FT_Pos delta )

377 {

378 FT_UInt count;

379 FT_UInt num;

380 PSH_Blue_Table table = 0;

381

382 /* */

383 /* Determine whether we need to suppress overshoots or */

384 /* not. We simply need to compare the vertical scale */

385 /* parameter to the raw bluescale value. Here is why: */

386 /* */

387 /* We need to suppress overshoots for all pointsizes. */

388 /* At 300dpi that satisfies: */

389 /* */

390 /* pointsize < 240bluescale + 0.49 /

391 /* */

392 /* This corresponds to: */

393 /* */

394 /* pixelsize < 1000bluescale + 49/24 /

395 /* */

396 /* scaleEM_Size < 1000bluescale + 49/24 */

397 /* */

398 /* However, for normal Type 1 fonts, EM_Size is 1000! */

399 /* We thus only check: */

400 /* */

401 /* scale < bluescale + 49/24000 */

402 /* */

403 /* which we shorten to */

404 /* */

405 /* "scale < bluescale" */

406 /* */

407 /* Note that `blue_scale' is stored 1000 times its real */

408 /* value, and that `scale' converts from font units to */

409 /* fractional pixels. */

410 /* */

411

412 /* 1000 / 64 = 125 / 8 */

413 if ( scale >= 0x20C49BAL )

414 blues->no_overshoots = FT_BOOL( scale < blues->blue_scale * 8 / 125 );

415 else

416 blues->no_overshoots = FT_BOOL( scale * 125 < blues->blue_scale * 8 );

417

418 /* */

419 /* The blue threshold is the font units distance under */

420 /* which overshoots are suppressed due to the BlueShift */

421 /* even if the scale is greater than BlueScale. */

422 /* */

423 /* It is the smallest distance such that */

424 /* */

425 /* dist <= BlueShift && distscale <= 0.5 pixels /

426 /* */

427 {

428 FT_Int threshold = blues->blue_shift;

429

430

431 while ( threshold > 0 && FT_MulFix( threshold, scale ) > 32 )

432 threshold--;

433

434 blues->blue_threshold = threshold;

435 }

436

437 for ( num = 0; num < 4; num++ )

438 {

439 PSH_Blue_Zone zone;

440

441

442 switch ( num )

443 {

444 case 0:

445 table = &blues->normal_top;

446 break;

447 case 1:

448 table = &blues->normal_bottom;

449 break;

450 case 2:

451 table = &blues->family_top;

452 break;

453 default:

454 table = &blues->family_bottom;

455 break;

456 }

457

458 zone = table->zones;

459 count = table->count;

460 for ( ; count > 0; count--, zone++ )

461 {

462 zone->cur_top = FT_MulFix( zone->org_top, scale ) + delta;

463 zone->cur_bottom = FT_MulFix( zone->org_bottom, scale ) + delta;

464 zone->cur_ref = FT_MulFix( zone->org_ref, scale ) + delta;

465 zone->cur_delta = FT_MulFix( zone->org_delta, scale );

466

467 /* round scaled reference position */

468 zone->cur_ref = FT_PIX_ROUND( zone->cur_ref );

469

470 #if 0

471 if ( zone->cur_ref > zone->cur_top )

472 zone->cur_ref -= 64;

473 else if ( zone->cur_ref < zone->cur_bottom )

474 zone->cur_ref += 64;

475 #endif

476 }

477 }

478

479 /* process the families now */

480

481 for ( num = 0; num < 2; num++ )

482 {

483 PSH_Blue_Zone zone1, zone2;

484 FT_UInt count1, count2;

485 PSH_Blue_Table normal, family;

486

487

488 switch ( num )

489 {

490 case 0:

491 normal = &blues->normal_top;

492 family = &blues->family_top;

493 break;

494

495 default:

496 normal = &blues->normal_bottom;

497 family = &blues->family_bottom;

498 }

499

500 zone1 = normal->zones;

501 count1 = normal->count;

502

503 for ( ; count1 > 0; count1--, zone1++ )

504 {

505 /* try to find a family zone whose reference position is less */

506 /* than 1 pixel far from the current zone */

507 zone2 = family->zones;

508 count2 = family->count;

509

510 for ( ; count2 > 0; count2--, zone2++ )

511 {

512 FT_Pos Delta;

513

514

515 Delta = zone1->org_ref - zone2->org_ref;

516 if ( Delta < 0 )

517 Delta = -Delta;

518

519 if ( FT_MulFix( Delta, scale ) < 64 )

520 {

521 zone1->cur_top = zone2->cur_top;

522 zone1->cur_bottom = zone2->cur_bottom;

523 zone1->cur_ref = zone2->cur_ref;

524 zone1->cur_delta = zone2->cur_delta;

525 break;

526 }

527 }

528 }

529 }

530 }

531

532

533 /* calculate the maximum height of given blue zones */

534 static FT_Short

535 psh_calc_max_height( FT_UInt num,

536 const FT_Short* values,

537 FT_Short cur_max )

538 {

539 FT_UInt count;

540

541

542 for ( count = 0; count < num; count += 2 )

543 {

544 FT_Short cur_height = values[count + 1] - values[count];

545

546

547 if ( cur_height > cur_max )

548 cur_max = cur_height;

549 }

550

551 return cur_max;

552 }

553

554

555 FT_LOCAL_DEF( void )

556 psh_blues_snap_stem( PSH_Blues blues,

557 FT_Int stem_top,

558 FT_Int stem_bot,

559 PSH_Alignment alignment )

560 {

561 PSH_Blue_Table table;

562 FT_UInt count;

563 FT_Pos delta;

564 PSH_Blue_Zone zone;

565 FT_Int no_shoots;

566

567

568 alignment->align = PSH_BLUE_ALIGN_NONE;

569

570 no_shoots = blues->no_overshoots;

571

572 /* look up stem top in top zones table */

573 table = &blues->normal_top;

574 count = table->count;

575 zone = table->zones;

576

577 for ( ; count > 0; count--, zone++ )

578 {

579 delta = stem_top - zone->org_bottom;

580 if ( delta < -blues->blue_fuzz )

581 break;

582

583 if ( stem_top <= zone->org_top + blues->blue_fuzz )

584 {

585 if ( no_shoots \|\| delta <= blues->blue_threshold )

586 {

587 alignment->align \|= PSH_BLUE_ALIGN_TOP;

588 alignment->align_top = zone->cur_ref;

589 }

590 break;

591 }

592 }

593

594 /* look up stem bottom in bottom zones table */

595 table = &blues->normal_bottom;

596 count = table->count;

597 zone = table->zones + count-1;

598

599 for ( ; count > 0; count--, zone-- )

600 {

601 delta = zone->org_top - stem_bot;

602 if ( delta < -blues->blue_fuzz )

603 break;

604

605 if ( stem_bot >= zone->org_bottom - blues->blue_fuzz )

606 {

607 if ( no_shoots \|\| delta < blues->blue_threshold )

608 {

609 alignment->align \|= PSH_BLUE_ALIGN_BOT;

610 alignment->align_bot = zone->cur_ref;

611 }

612 break;

613 }

614 }

615 }

616

617

618 /*************************************************************************/

619 /*************************************************************************/

620 /*** ***/

621 /*** GLOBAL HINTS ***/

622 /*** ***/

623 /*************************************************************************/

624 /*************************************************************************/

625

626 static void

627 psh_globals_destroy( PSH_Globals globals )

628 {

629 if ( globals )

630 {

631 FT_Memory memory;

632

633

634 memory = globals->memory;

635 globals->dimension[0].stdw.count = 0;

636 globals->dimension[1].stdw.count = 0;

637

638 globals->blues.normal_top.count = 0;

639 globals->blues.normal_bottom.count = 0;

640 globals->blues.family_top.count = 0;

641 globals->blues.family_bottom.count = 0;

642

643 FT_FREE( globals );

644

645 #ifdef DEBUG_HINTER

646 ps_debug_globals = 0;

647 #endif

648 }

649 }

650

651

652 static FT_Error

653 psh_globals_new( FT_Memory memory,

654 T1_Private* priv,

655 PSH_Globals *aglobals )

656 {

657 PSH_Globals globals = NULL;

658 FT_Error error;

659

660

661 if ( !FT_NEW( globals ) )

662 {

663 FT_UInt count;

664 FT_Short* read;

665

666

667 globals->memory = memory;

668

669 /* copy standard widths */

670 {

671 PSH_Dimension dim = &globals->dimension[1];

672 PSH_Width write = dim->stdw.widths;

673

674

675 write->org = priv->standard_width[0];

676 write++;

677

678 read = priv->snap_widths;

679 for ( count = priv->num_snap_widths; count > 0; count-- )

680 {

681 write->org = *read;

682 write++;

683 read++;

684 }

685

686 dim->stdw.count = priv->num_snap_widths + 1;

687 }

688

689 /* copy standard heights */

690 {

691 PSH_Dimension dim = &globals->dimension[0];

692 PSH_Width write = dim->stdw.widths;

693

694

695 write->org = priv->standard_height[0];

696 write++;

697 read = priv->snap_heights;

698 for ( count = priv->num_snap_heights; count > 0; count-- )

699 {

700 write->org = *read;

701 write++;

702 read++;

703 }

704

705 dim->stdw.count = priv->num_snap_heights + 1;

706 }

707

708 /* copy blue zones */

709 psh_blues_set_zones( &globals->blues, priv->num_blue_values,

710 priv->blue_values, priv->num_other_blues,

711 priv->other_blues, priv->blue_fuzz, 0 );

712

713 psh_blues_set_zones( &globals->blues, priv->num_family_blues,

714 priv->family_blues, priv->num_family_other_blues,

715 priv->family_other_blues, priv->blue_fuzz, 1 );

716

717 /* limit the BlueScale value to `1 / max_of_blue_zone_heights' */

718 {

719 FT_Fixed max_scale;

720 FT_Short max_height = 1;

721

722

723 max_height = psh_calc_max_height( priv->num_blue_values,

724 priv->blue_values,

725 max_height );

726 max_height = psh_calc_max_height( priv->num_other_blues,

727 priv->other_blues,

728 max_height );

729 max_height = psh_calc_max_height( priv->num_family_blues,

730 priv->family_blues,

731 max_height );

732 max_height = psh_calc_max_height( priv->num_family_other_blues,

733 priv->family_other_blues,

734 max_height );

735

736 /* BlueScale is scaled 1000 times */

737 max_scale = FT_DivFix( 1000, max_height );

738 globals->blues.blue_scale = priv->blue_scale < max_scale

739 ? priv->blue_scale

740 : max_scale;

741 }

742

743 globals->blues.blue_shift = priv->blue_shift;

744 globals->blues.blue_fuzz = priv->blue_fuzz;

745

746 globals->dimension[0].scale_mult = 0;

747 globals->dimension[0].scale_delta = 0;

748 globals->dimension[1].scale_mult = 0;

749 globals->dimension[1].scale_delta = 0;

750

751 #ifdef DEBUG_HINTER

752 ps_debug_globals = globals;

753 #endif

754 }

755

756 *aglobals = globals;

757 return error;

758 }

759

760

761 FT_LOCAL_DEF( FT_Error )

762 psh_globals_set_scale( PSH_Globals globals,

763 FT_Fixed x_scale,

764 FT_Fixed y_scale,

765 FT_Fixed x_delta,

766 FT_Fixed y_delta )

767 {

768 PSH_Dimension dim = &globals->dimension[0];

769

770

771 dim = &globals->dimension[0];

772 if ( x_scale != dim->scale_mult \|\|

773 x_delta != dim->scale_delta )

774 {

775 dim->scale_mult = x_scale;

776 dim->scale_delta = x_delta;

777

778 psh_globals_scale_widths( globals, 0 );

779 }

780

781 dim = &globals->dimension[1];

782 if ( y_scale != dim->scale_mult \|\|

783 y_delta != dim->scale_delta )

784 {

785 dim->scale_mult = y_scale;

786 dim->scale_delta = y_delta;

787

788 psh_globals_scale_widths( globals, 1 );

789 psh_blues_scale_zones( &globals->blues, y_scale, y_delta );

790 }

791

792 return 0;

793 }

794

795

796 FT_LOCAL_DEF( void )

797 psh_globals_funcs_init( PSH_Globals_FuncsRec* funcs )

798 {

799 funcs->create = psh_globals_new;

800 funcs->set_scale = psh_globals_set_scale;

801 funcs->destroy = psh_globals_destroy;

802 }

803

804

805 /* END */

OLD	NEW