| /* |
| * Copyright (C) 2013 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| // Determine coverage of font given its raw "cmap" OpenType table |
| |
| #define LOG_TAG "Minikin" |
| |
| #include <vector> |
| using std::vector; |
| |
| #include <log/log.h> |
| |
| #include <minikin/CmapCoverage.h> |
| #include <minikin/SparseBitSet.h> |
| #include "MinikinInternal.h" |
| |
| namespace minikin { |
| |
| // These could perhaps be optimized to use __builtin_bswap16 and friends. |
| static uint32_t readU16(const uint8_t* data, size_t offset) { |
| return ((uint32_t)data[offset]) << 8 | ((uint32_t)data[offset + 1]); |
| } |
| |
| static uint32_t readU32(const uint8_t* data, size_t offset) { |
| return ((uint32_t)data[offset]) << 24 | ((uint32_t)data[offset + 1]) << 16 | |
| ((uint32_t)data[offset + 2]) << 8 | ((uint32_t)data[offset + 3]); |
| } |
| |
| static void addRange(vector<uint32_t>& coverage, uint32_t start, uint32_t end) { |
| #ifdef VERBOSE_DEBUG |
| ALOGD("adding range %d-%d\n", start, end); |
| #endif |
| if (coverage.empty() || coverage.back() < start) { |
| coverage.push_back(start); |
| coverage.push_back(end); |
| } else { |
| coverage.back() = end; |
| } |
| } |
| |
| // Get the coverage information out of a Format 4 subtable, storing it in the |
| // coverage vector |
| static bool getCoverageFormat4(vector<uint32_t>& coverage, |
| const uint8_t* data, |
| size_t size) { |
| const size_t kSegCountOffset = 6; |
| const size_t kEndCountOffset = 14; |
| const size_t kHeaderSize = 16; |
| const size_t kSegmentSize = |
| 8; // total size of array elements for one segment |
| if (kEndCountOffset > size) { |
| return false; |
| } |
| size_t segCount = readU16(data, kSegCountOffset) >> 1; |
| if (kHeaderSize + segCount * kSegmentSize > size) { |
| return false; |
| } |
| for (size_t i = 0; i < segCount; i++) { |
| uint32_t end = readU16(data, kEndCountOffset + 2 * i); |
| uint32_t start = readU16(data, kHeaderSize + 2 * (segCount + i)); |
| if (end < start) { |
| // invalid segment range: size must be positive |
| android_errorWriteLog(0x534e4554, "26413177"); |
| return false; |
| } |
| uint32_t rangeOffset = readU16(data, kHeaderSize + 2 * (3 * segCount + i)); |
| if (rangeOffset == 0) { |
| uint32_t delta = readU16(data, kHeaderSize + 2 * (2 * segCount + i)); |
| if (((end + delta) & 0xffff) > end - start) { |
| addRange(coverage, start, end + 1); |
| } else { |
| for (uint32_t j = start; j < end + 1; j++) { |
| if (((j + delta) & 0xffff) != 0) { |
| addRange(coverage, j, j + 1); |
| } |
| } |
| } |
| } else { |
| for (uint32_t j = start; j < end + 1; j++) { |
| uint32_t actualRangeOffset = |
| kHeaderSize + 6 * segCount + rangeOffset + (i + j - start) * 2; |
| if (actualRangeOffset + 2 > size) { |
| // invalid rangeOffset is considered a "warning" by OpenType Sanitizer |
| continue; |
| } |
| uint32_t glyphId = readU16(data, actualRangeOffset); |
| if (glyphId != 0) { |
| addRange(coverage, j, j + 1); |
| } |
| } |
| } |
| } |
| return true; |
| } |
| |
| // Get the coverage information out of a Format 12 subtable, storing it in the |
| // coverage vector |
| static bool getCoverageFormat12(vector<uint32_t>& coverage, |
| const uint8_t* data, |
| size_t size) { |
| const size_t kNGroupsOffset = 12; |
| const size_t kFirstGroupOffset = 16; |
| const size_t kGroupSize = 12; |
| const size_t kStartCharCodeOffset = 0; |
| const size_t kEndCharCodeOffset = 4; |
| const size_t kMaxNGroups = |
| 0xfffffff0 / kGroupSize; // protection against overflow |
| // For all values < kMaxNGroups, kFirstGroupOffset + nGroups * kGroupSize fits |
| // in 32 bits. |
| if (kFirstGroupOffset > size) { |
| return false; |
| } |
| uint32_t nGroups = readU32(data, kNGroupsOffset); |
| if (nGroups >= kMaxNGroups || |
| kFirstGroupOffset + nGroups * kGroupSize > size) { |
| android_errorWriteLog(0x534e4554, "25645298"); |
| return false; |
| } |
| for (uint32_t i = 0; i < nGroups; i++) { |
| uint32_t groupOffset = kFirstGroupOffset + i * kGroupSize; |
| uint32_t start = readU32(data, groupOffset + kStartCharCodeOffset); |
| uint32_t end = readU32(data, groupOffset + kEndCharCodeOffset); |
| if (end < start) { |
| // invalid group range: size must be positive |
| android_errorWriteLog(0x534e4554, "26413177"); |
| return false; |
| } |
| |
| // No need to read outside of Unicode code point range. |
| if (start > MAX_UNICODE_CODE_POINT) { |
| return true; |
| } |
| if (end > MAX_UNICODE_CODE_POINT) { |
| // file is inclusive, vector is exclusive |
| addRange(coverage, start, MAX_UNICODE_CODE_POINT + 1); |
| return true; |
| } |
| addRange(coverage, start, |
| end + 1); // file is inclusive, vector is exclusive |
| } |
| return true; |
| } |
| |
| // Lower value has higher priority. 0 for the highest priority table. |
| // kLowestPriority for unsupported tables. |
| // This order comes from HarfBuzz's hb-ot-font.cc and needs to be kept in sync |
| // with it. |
| constexpr uint8_t kLowestPriority = 255; |
| uint8_t getTablePriority(uint16_t platformId, uint16_t encodingId) { |
| if (platformId == 3 && encodingId == 10) { |
| return 0; |
| } |
| if (platformId == 0 && encodingId == 6) { |
| return 1; |
| } |
| if (platformId == 0 && encodingId == 4) { |
| return 2; |
| } |
| if (platformId == 3 && encodingId == 1) { |
| return 3; |
| } |
| if (platformId == 0 && encodingId == 3) { |
| return 4; |
| } |
| if (platformId == 0 && encodingId == 2) { |
| return 5; |
| } |
| if (platformId == 0 && encodingId == 1) { |
| return 6; |
| } |
| if (platformId == 0 && encodingId == 0) { |
| return 7; |
| } |
| // Tables other than above are not supported. |
| return kLowestPriority; |
| } |
| |
| SparseBitSet CmapCoverage::getCoverage(const uint8_t* cmap_data, |
| size_t cmap_size, |
| bool* has_cmap_format14_subtable) { |
| constexpr size_t kHeaderSize = 4; |
| constexpr size_t kNumTablesOffset = 2; |
| constexpr size_t kTableSize = 8; |
| constexpr size_t kPlatformIdOffset = 0; |
| constexpr size_t kEncodingIdOffset = 2; |
| constexpr size_t kOffsetOffset = 4; |
| constexpr size_t kFormatOffset = 0; |
| constexpr uint32_t kInvalidOffset = UINT32_MAX; |
| |
| if (kHeaderSize > cmap_size) { |
| return SparseBitSet(); |
| } |
| uint32_t numTables = readU16(cmap_data, kNumTablesOffset); |
| if (kHeaderSize + numTables * kTableSize > cmap_size) { |
| return SparseBitSet(); |
| } |
| |
| uint32_t bestTableOffset = kInvalidOffset; |
| uint16_t bestTableFormat = 0; |
| uint8_t bestTablePriority = kLowestPriority; |
| *has_cmap_format14_subtable = false; |
| for (uint32_t i = 0; i < numTables; ++i) { |
| const uint32_t tableHeadOffset = kHeaderSize + i * kTableSize; |
| const uint16_t platformId = |
| readU16(cmap_data, tableHeadOffset + kPlatformIdOffset); |
| const uint16_t encodingId = |
| readU16(cmap_data, tableHeadOffset + kEncodingIdOffset); |
| const uint32_t offset = readU32(cmap_data, tableHeadOffset + kOffsetOffset); |
| |
| if (offset > cmap_size - 2) { |
| continue; // Invalid table: not enough space to read. |
| } |
| const uint16_t format = readU16(cmap_data, offset + kFormatOffset); |
| |
| if (platformId == 0 /* Unicode */ && |
| encodingId == 5 /* Variation Sequences */) { |
| if (!(*has_cmap_format14_subtable) && format == 14) { |
| *has_cmap_format14_subtable = true; |
| } else { |
| // Ignore the (0, 5) table if we have already seen another valid one or |
| // it's in a format we don't understand. |
| } |
| } else { |
| uint32_t length; |
| uint32_t language; |
| |
| if (format == 4) { |
| constexpr size_t lengthOffset = 2; |
| constexpr size_t languageOffset = 4; |
| constexpr size_t minTableSize = languageOffset + 2; |
| if (offset > cmap_size - minTableSize) { |
| continue; // Invalid table: not enough space to read. |
| } |
| length = readU16(cmap_data, offset + lengthOffset); |
| language = readU16(cmap_data, offset + languageOffset); |
| } else if (format == 12) { |
| constexpr size_t lengthOffset = 4; |
| constexpr size_t languageOffset = 8; |
| constexpr size_t minTableSize = languageOffset + 4; |
| if (offset > cmap_size - minTableSize) { |
| continue; // Invalid table: not enough space to read. |
| } |
| length = readU32(cmap_data, offset + lengthOffset); |
| language = readU32(cmap_data, offset + languageOffset); |
| } else { |
| continue; |
| } |
| |
| if (length > cmap_size - offset) { |
| continue; // Invalid table: table length is larger than whole cmap data |
| // size. |
| } |
| if (language != 0) { |
| // Unsupported or invalid table: this is either a subtable for the |
| // Macintosh platform (which we don't support), or an invalid subtable |
| // since language field should be zero for non-Macintosh subtables. |
| continue; |
| } |
| const uint8_t priority = getTablePriority(platformId, encodingId); |
| if (priority < bestTablePriority) { |
| bestTableOffset = offset; |
| bestTablePriority = priority; |
| bestTableFormat = format; |
| } |
| } |
| if (*has_cmap_format14_subtable && |
| bestTablePriority == 0 /* highest priority */) { |
| // Already found the highest priority table and variation sequences table. |
| // No need to look at remaining tables. |
| break; |
| } |
| } |
| if (bestTableOffset == kInvalidOffset) { |
| return SparseBitSet(); |
| } |
| const uint8_t* tableData = cmap_data + bestTableOffset; |
| const size_t tableSize = cmap_size - bestTableOffset; |
| vector<uint32_t> coverageVec; |
| bool success; |
| if (bestTableFormat == 4) { |
| success = getCoverageFormat4(coverageVec, tableData, tableSize); |
| } else { |
| success = getCoverageFormat12(coverageVec, tableData, tableSize); |
| } |
| if (success && (coverageVec.size() != 0)) { |
| return SparseBitSet(&coverageVec.front(), coverageVec.size() >> 1); |
| } else { |
| return SparseBitSet(); |
| } |
| } |
| |
| } // namespace minikin |
