| /* |
| * %W% %E% |
| * |
| * (C) Copyright IBM Corp. 1998 - All Rights Reserved |
| * |
| * Portions Copyright 1998 by Sun Microsystems, Inc., |
| * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A. |
| * All rights reserved. |
| * |
| * This software is the confidential and proprietary information |
| * of Sun Microsystems, Inc. ("Confidential Information"). You |
| * shall not disclose such Confidential Information and shall use |
| * it only in accordance with the terms of the license agreement |
| * you entered into with Sun. |
| * |
| * The original version of this source code and documentation is |
| * copyrighted and owned by IBM. These materials are provided |
| * under terms of a License Agreement between IBM and Sun. |
| * This technology is protected by multiple US and International |
| * patents. This notice and attribution to IBM may not be removed. |
| */ |
| |
| #include "LETypes.h" |
| #include "LESwaps.h" |
| |
| #include "sfnt.h" |
| #include "cmaps.h" |
| |
| // |
| // Finds the high bit by binary searching |
| // through the bits in value. |
| // |
| le_int8 highBit(le_uint32 value) |
| { |
| le_uint8 bit = 0; |
| |
| if (value >= 1 << 16) { |
| value >>= 16; |
| bit += 16; |
| } |
| |
| if (value >= 1 << 8) { |
| value >>= 8; |
| bit += 8; |
| } |
| |
| if (value >= 1 << 4) { |
| value >>= 4; |
| bit += 4; |
| } |
| |
| if (value >= 1 << 2) { |
| value >>= 2; |
| bit += 2; |
| } |
| |
| if (value >= 1 << 1) { |
| value >>= 1; |
| bit += 1; |
| } |
| |
| return bit; |
| } |
| |
| CMAPMapper *CMAPMapper::createUnicodeMapper(const CMAPTable *cmap) |
| { |
| le_uint16 i; |
| le_uint16 nSubtables = SWAPW(cmap->numberSubtables); |
| const CMAPEncodingSubtable *subtable = NULL; |
| le_uint32 offset1 = 0, offset10 = 0; |
| |
| for (i = 0; i < nSubtables; i += 1) { |
| const CMAPEncodingSubtableHeader *esh = &cmap->encodingSubtableHeaders[i]; |
| |
| if (SWAPW(esh->platformID) == 3) { |
| switch (SWAPW(esh->platformSpecificID)) { |
| case 1: |
| offset1 = SWAPL(esh->encodingOffset); |
| break; |
| |
| case 10: |
| offset10 = SWAPL(esh->encodingOffset); |
| break; |
| } |
| } |
| } |
| |
| |
| if (offset10 != 0) |
| { |
| subtable = (const CMAPEncodingSubtable *) ((const char *) cmap + offset10); |
| } else if (offset1 != 0) { |
| subtable = (const CMAPEncodingSubtable *) ((const char *) cmap + offset1); |
| } else { |
| return NULL; |
| } |
| |
| switch (SWAPW(subtable->format)) { |
| case 4: |
| return new CMAPFormat4Mapper(cmap, (const CMAPFormat4Encoding *) subtable); |
| |
| case 12: |
| { |
| const CMAPFormat12Encoding *encoding = (const CMAPFormat12Encoding *) subtable; |
| |
| return new CMAPGroupMapper(cmap, encoding->groups, SWAPL(encoding->nGroups)); |
| } |
| |
| default: |
| break; |
| } |
| |
| return NULL; |
| } |
| |
| CMAPFormat4Mapper::CMAPFormat4Mapper(const CMAPTable *cmap, const CMAPFormat4Encoding *header) |
| : CMAPMapper(cmap) |
| { |
| le_uint16 segCount = SWAPW(header->segCountX2) / 2; |
| |
| fEntrySelector = SWAPW(header->entrySelector); |
| fRangeShift = SWAPW(header->rangeShift) / 2; |
| fEndCodes = &header->endCodes[0]; |
| fStartCodes = &header->endCodes[segCount + 1]; // + 1 for reservedPad... |
| fIdDelta = &fStartCodes[segCount]; |
| fIdRangeOffset = &fIdDelta[segCount]; |
| } |
| |
| LEGlyphID CMAPFormat4Mapper::unicodeToGlyph(LEUnicode32 unicode32) const |
| { |
| if (unicode32 >= 0x10000) { |
| return 0; |
| } |
| |
| LEUnicode16 unicode = (LEUnicode16) unicode32; |
| le_uint16 index = 0; |
| le_uint16 probe = 1 << fEntrySelector; |
| LEGlyphID result = 0; |
| |
| if (SWAPW(fStartCodes[fRangeShift]) <= unicode) { |
| index = fRangeShift; |
| } |
| |
| while (probe > (1 << 0)) { |
| probe >>= 1; |
| |
| if (SWAPW(fStartCodes[index + probe]) <= unicode) { |
| index += probe; |
| } |
| } |
| |
| if (unicode >= SWAPW(fStartCodes[index]) && unicode <= SWAPW(fEndCodes[index])) { |
| if (fIdRangeOffset[index] == 0) { |
| result = (LEGlyphID) unicode; |
| } else { |
| le_uint16 offset = unicode - SWAPW(fStartCodes[index]); |
| le_uint16 rangeOffset = SWAPW(fIdRangeOffset[index]); |
| le_uint16 *glyphIndexTable = (le_uint16 *) ((char *) &fIdRangeOffset[index] + rangeOffset); |
| |
| result = SWAPW(glyphIndexTable[offset]); |
| } |
| |
| result += SWAPW(fIdDelta[index]); |
| } else { |
| result = 0; |
| } |
| |
| return result; |
| } |
| |
| CMAPFormat4Mapper::~CMAPFormat4Mapper() |
| { |
| // parent destructor does it all |
| } |
| |
| CMAPGroupMapper::CMAPGroupMapper(const CMAPTable *cmap, const CMAPGroup *groups, le_uint32 nGroups) |
| : CMAPMapper(cmap), fGroups(groups) |
| { |
| le_uint8 bit = highBit(nGroups); |
| fPower = 1 << bit; |
| fRangeOffset = nGroups - fPower; |
| } |
| |
| LEGlyphID CMAPGroupMapper::unicodeToGlyph(LEUnicode32 unicode32) const |
| { |
| le_int32 probe = fPower; |
| le_int32 range = 0; |
| |
| if (SWAPL(fGroups[fRangeOffset].startCharCode) <= unicode32) { |
| range = fRangeOffset; |
| } |
| |
| while (probe > (1 << 0)) { |
| probe >>= 1; |
| |
| if (SWAPL(fGroups[range + probe].startCharCode) <= unicode32) { |
| range += probe; |
| } |
| } |
| |
| if (SWAPL(fGroups[range].startCharCode) <= unicode32 && SWAPL(fGroups[range].endCharCode) >= unicode32) { |
| return (LEGlyphID) (SWAPL(fGroups[range].startGlyphCode) + unicode32 - SWAPL(fGroups[range].startCharCode)); |
| } |
| |
| return 0; |
| } |
| |
| CMAPGroupMapper::~CMAPGroupMapper() |
| { |
| // parent destructor does it all |
| } |
| |