| /* |
| * Copyright 2011 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "SkAutoMalloc.h" |
| #include "SkEndian.h" |
| #include "SkFontStream.h" |
| #include "SkStream.h" |
| |
| struct SkSFNTHeader { |
| uint32_t fVersion; |
| uint16_t fNumTables; |
| uint16_t fSearchRange; |
| uint16_t fEntrySelector; |
| uint16_t fRangeShift; |
| }; |
| |
| struct SkTTCFHeader { |
| uint32_t fTag; |
| uint32_t fVersion; |
| uint32_t fNumOffsets; |
| uint32_t fOffset0; // the first of N (fNumOffsets) |
| }; |
| |
| union SkSharedTTHeader { |
| SkSFNTHeader fSingle; |
| SkTTCFHeader fCollection; |
| }; |
| |
| struct SkSFNTDirEntry { |
| uint32_t fTag; |
| uint32_t fChecksum; |
| uint32_t fOffset; |
| uint32_t fLength; |
| }; |
| |
| static bool read(SkStream* stream, void* buffer, size_t amount) { |
| return stream->read(buffer, amount) == amount; |
| } |
| |
| static bool skip(SkStream* stream, size_t amount) { |
| return stream->skip(amount) == amount; |
| } |
| |
| /** Return the number of tables, or if this is a TTC (collection), return the |
| number of tables in the first element of the collection. In either case, |
| if offsetToDir is not-null, set it to the offset to the beginning of the |
| table headers (SkSFNTDirEntry), relative to the start of the stream. |
| |
| On an error, return 0 for number of tables, and ignore offsetToDir |
| */ |
| static int count_tables(SkStream* stream, int ttcIndex, size_t* offsetToDir) { |
| SkASSERT(ttcIndex >= 0); |
| |
| SkAutoSMalloc<1024> storage(sizeof(SkSharedTTHeader)); |
| SkSharedTTHeader* header = (SkSharedTTHeader*)storage.get(); |
| |
| if (!read(stream, header, sizeof(SkSharedTTHeader))) { |
| return 0; |
| } |
| |
| // by default, SkSFNTHeader is at the start of the stream |
| size_t offset = 0; |
| |
| // if we're really a collection, the first 4-bytes will be 'ttcf' |
| uint32_t tag = SkEndian_SwapBE32(header->fCollection.fTag); |
| if (SkSetFourByteTag('t', 't', 'c', 'f') == tag) { |
| unsigned count = SkEndian_SwapBE32(header->fCollection.fNumOffsets); |
| if ((unsigned)ttcIndex >= count) { |
| return 0; |
| } |
| |
| if (ttcIndex > 0) { // need to read more of the shared header |
| stream->rewind(); |
| size_t amount = sizeof(SkSharedTTHeader) + ttcIndex * sizeof(uint32_t); |
| header = (SkSharedTTHeader*)storage.reset(amount); |
| if (!read(stream, header, amount)) { |
| return 0; |
| } |
| } |
| // this is the offset to the local SkSFNTHeader |
| offset = SkEndian_SwapBE32((&header->fCollection.fOffset0)[ttcIndex]); |
| stream->rewind(); |
| if (!skip(stream, offset)) { |
| return 0; |
| } |
| if (!read(stream, header, sizeof(SkSFNTHeader))) { |
| return 0; |
| } |
| } |
| |
| if (offsetToDir) { |
| // add the size of the header, so we will point to the DirEntries |
| *offsetToDir = offset + sizeof(SkSFNTHeader); |
| } |
| return SkEndian_SwapBE16(header->fSingle.fNumTables); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| struct SfntHeader { |
| SfntHeader() : fCount(0), fDir(nullptr) {} |
| ~SfntHeader() { sk_free(fDir); } |
| |
| /** If it returns true, then fCount and fDir are properly initialized. |
| Note: fDir will point to the raw array of SkSFNTDirEntry values, |
| meaning they will still be in the file's native endianness (BE). |
| |
| fDir will be automatically freed when this object is destroyed |
| */ |
| bool init(SkStream* stream, int ttcIndex) { |
| stream->rewind(); |
| |
| size_t offsetToDir; |
| fCount = count_tables(stream, ttcIndex, &offsetToDir); |
| if (0 == fCount) { |
| return false; |
| } |
| |
| stream->rewind(); |
| if (!skip(stream, offsetToDir)) { |
| return false; |
| } |
| |
| size_t size = fCount * sizeof(SkSFNTDirEntry); |
| fDir = reinterpret_cast<SkSFNTDirEntry*>(sk_malloc_throw(size)); |
| return read(stream, fDir, size); |
| } |
| |
| int fCount; |
| SkSFNTDirEntry* fDir; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| int SkFontStream::CountTTCEntries(SkStream* stream) { |
| stream->rewind(); |
| |
| SkSharedTTHeader shared; |
| if (!read(stream, &shared, sizeof(shared))) { |
| return 0; |
| } |
| |
| // if we're really a collection, the first 4-bytes will be 'ttcf' |
| uint32_t tag = SkEndian_SwapBE32(shared.fCollection.fTag); |
| if (SkSetFourByteTag('t', 't', 'c', 'f') == tag) { |
| return SkEndian_SwapBE32(shared.fCollection.fNumOffsets); |
| } else { |
| return 1; // normal 'sfnt' has 1 dir entry |
| } |
| } |
| |
| int SkFontStream::GetTableTags(SkStream* stream, int ttcIndex, |
| SkFontTableTag tags[]) { |
| SfntHeader header; |
| if (!header.init(stream, ttcIndex)) { |
| return 0; |
| } |
| |
| if (tags) { |
| for (int i = 0; i < header.fCount; i++) { |
| tags[i] = SkEndian_SwapBE32(header.fDir[i].fTag); |
| } |
| } |
| return header.fCount; |
| } |
| |
| size_t SkFontStream::GetTableData(SkStream* stream, int ttcIndex, |
| SkFontTableTag tag, |
| size_t offset, size_t length, void* data) { |
| SfntHeader header; |
| if (!header.init(stream, ttcIndex)) { |
| return 0; |
| } |
| |
| for (int i = 0; i < header.fCount; i++) { |
| if (SkEndian_SwapBE32(header.fDir[i].fTag) == tag) { |
| size_t realOffset = SkEndian_SwapBE32(header.fDir[i].fOffset); |
| size_t realLength = SkEndian_SwapBE32(header.fDir[i].fLength); |
| // now sanity check the caller's offset/length |
| if (offset >= realLength) { |
| return 0; |
| } |
| // if the caller is trusting the length from the file, then a |
| // hostile file might choose a value which would overflow offset + |
| // length. |
| if (offset + length < offset) { |
| return 0; |
| } |
| if (length > realLength - offset) { |
| length = realLength - offset; |
| } |
| if (data) { |
| // skip the stream to the part of the table we want to copy from |
| stream->rewind(); |
| size_t bytesToSkip = realOffset + offset; |
| if (!skip(stream, bytesToSkip)) { |
| return 0; |
| } |
| if (!read(stream, data, length)) { |
| return 0; |
| } |
| } |
| return length; |
| } |
| } |
| return 0; |
| } |