blob: e4812ef87d2c04eb5c4a0ace5cc0bfc00ca16827 [file] [log] [blame]
// Copyright 2016 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#include "core/fxge/cfx_folderfontinfo.h"
#include <limits>
#include <utility>
#include "build/build_config.h"
#include "core/fxcrt/fx_codepage.h"
#include "core/fxcrt/fx_extension.h"
#include "core/fxcrt/fx_folder.h"
#include "core/fxcrt/fx_memory_wrappers.h"
#include "core/fxcrt/fx_safe_types.h"
#include "core/fxcrt/fx_system.h"
#include "core/fxge/cfx_fontmapper.h"
#include "core/fxge/fx_font.h"
#include "third_party/base/containers/contains.h"
#include "third_party/base/cxx17_backports.h"
namespace {
const struct {
const char* m_pName;
const char* m_pSubstName;
} Base14Substs[] = {
{"Courier", "Courier New"},
{"Courier-Bold", "Courier New Bold"},
{"Courier-BoldOblique", "Courier New Bold Italic"},
{"Courier-Oblique", "Courier New Italic"},
{"Helvetica", "Arial"},
{"Helvetica-Bold", "Arial Bold"},
{"Helvetica-BoldOblique", "Arial Bold Italic"},
{"Helvetica-Oblique", "Arial Italic"},
{"Times-Roman", "Times New Roman"},
{"Times-Bold", "Times New Roman Bold"},
{"Times-BoldItalic", "Times New Roman Bold Italic"},
{"Times-Italic", "Times New Roman Italic"},
};
// Used with std::unique_ptr to automatically call fclose().
struct FxFileCloser {
inline void operator()(FILE* h) const {
if (h)
fclose(h);
}
};
bool FindFamilyNameMatch(ByteStringView family_name,
const ByteString& installed_font_name) {
Optional<size_t> result = installed_font_name.Find(family_name, 0);
if (!result.has_value())
return false;
size_t next_index = result.value() + family_name.GetLength();
// Rule out the case that |family_name| is a substring of
// |installed_font_name| but their family names are actually different words.
// For example: "Univers" and "Universal" are not a match because they have
// different family names, but "Univers" and "Univers Bold" are a match.
if (installed_font_name.IsValidIndex(next_index) &&
FXSYS_IsLowerASCII(installed_font_name[next_index])) {
return false;
}
return true;
}
ByteString ReadStringFromFile(FILE* pFile, uint32_t size) {
ByteString result;
{
// Span's lifetime must end before ReleaseBuffer() below.
pdfium::span<char> buffer = result.GetBuffer(size);
if (!fread(buffer.data(), size, 1, pFile))
return ByteString();
}
result.ReleaseBuffer(size);
return result;
}
ByteString LoadTableFromTT(FILE* pFile,
const uint8_t* pTables,
uint32_t nTables,
uint32_t tag,
uint32_t fileSize) {
for (uint32_t i = 0; i < nTables; i++) {
const uint8_t* p = pTables + i * 16;
if (FXSYS_UINT32_GET_MSBFIRST(p) == tag) {
uint32_t offset = FXSYS_UINT32_GET_MSBFIRST(p + 8);
uint32_t size = FXSYS_UINT32_GET_MSBFIRST(p + 12);
if (offset > std::numeric_limits<uint32_t>::max() - size ||
offset + size > fileSize || fseek(pFile, offset, SEEK_SET) < 0) {
return ByteString();
}
return ReadStringFromFile(pFile, size);
}
}
return ByteString();
}
uint32_t GetCharset(int charset) {
switch (charset) {
case FX_CHARSET_ShiftJIS:
return CHARSET_FLAG_SHIFTJIS;
case FX_CHARSET_ChineseSimplified:
return CHARSET_FLAG_GB;
case FX_CHARSET_ChineseTraditional:
return CHARSET_FLAG_BIG5;
case FX_CHARSET_Hangul:
return CHARSET_FLAG_KOREAN;
case FX_CHARSET_Symbol:
return CHARSET_FLAG_SYMBOL;
case FX_CHARSET_ANSI:
return CHARSET_FLAG_ANSI;
default:
break;
}
return 0;
}
int32_t GetSimilarValue(int weight,
bool bItalic,
int pitch_family,
uint32_t style,
bool bMatchName,
size_t familyNameLength,
size_t bsNameLength) {
int32_t iSimilarValue = 0;
if (bMatchName && (familyNameLength == bsNameLength))
iSimilarValue += 4;
if (FontStyleIsForceBold(style) == (weight > 400))
iSimilarValue += 16;
if (FontStyleIsItalic(style) == bItalic)
iSimilarValue += 16;
if (FontStyleIsSerif(style) == FontFamilyIsRoman(pitch_family))
iSimilarValue += 16;
if (FontStyleIsScript(style) == FontFamilyIsScript(pitch_family))
iSimilarValue += 8;
if (FontStyleIsFixedPitch(style) == FontFamilyIsFixedPitch(pitch_family))
iSimilarValue += 8;
return iSimilarValue;
}
} // namespace
CFX_FolderFontInfo::CFX_FolderFontInfo() = default;
CFX_FolderFontInfo::~CFX_FolderFontInfo() = default;
void CFX_FolderFontInfo::AddPath(const ByteString& path) {
m_PathList.push_back(path);
}
bool CFX_FolderFontInfo::EnumFontList(CFX_FontMapper* pMapper) {
m_pMapper = pMapper;
for (const auto& path : m_PathList)
ScanPath(path);
return true;
}
void CFX_FolderFontInfo::ScanPath(const ByteString& path) {
std::unique_ptr<FX_FolderHandle, FxFolderHandleCloser> handle(
FX_OpenFolder(path.c_str()));
if (!handle)
return;
ByteString filename;
bool bFolder;
while (FX_GetNextFile(handle.get(), &filename, &bFolder)) {
if (bFolder) {
if (filename == "." || filename == "..")
continue;
} else {
ByteString ext = filename.Last(4);
ext.MakeLower();
if (ext != ".ttf" && ext != ".ttc" && ext != ".otf")
continue;
}
ByteString fullpath = path;
#if defined(OS_WIN)
fullpath += "\\";
#else
fullpath += "/";
#endif
fullpath += filename;
bFolder ? ScanPath(fullpath) : ScanFile(fullpath);
}
}
void CFX_FolderFontInfo::ScanFile(const ByteString& path) {
std::unique_ptr<FILE, FxFileCloser> pFile(fopen(path.c_str(), "rb"));
if (!pFile)
return;
fseek(pFile.get(), 0, SEEK_END);
uint32_t filesize = ftell(pFile.get());
uint8_t buffer[16];
fseek(pFile.get(), 0, SEEK_SET);
size_t readCnt = fread(buffer, 12, 1, pFile.get());
if (readCnt != 1)
return;
if (FXSYS_UINT32_GET_MSBFIRST(buffer) != kTableTTCF) {
ReportFace(path, pFile.get(), filesize, 0);
return;
}
uint32_t nFaces = FXSYS_UINT32_GET_MSBFIRST(buffer + 8);
FX_SAFE_SIZE_T safe_face_bytes = nFaces;
safe_face_bytes *= 4;
if (!safe_face_bytes.IsValid())
return;
const size_t face_bytes = safe_face_bytes.ValueOrDie();
std::unique_ptr<uint8_t, FxFreeDeleter> offsets(
FX_Alloc(uint8_t, face_bytes));
readCnt = fread(offsets.get(), 1, face_bytes, pFile.get());
if (readCnt != face_bytes)
return;
auto offsets_span = pdfium::make_span(offsets.get(), face_bytes);
for (uint32_t i = 0; i < nFaces; i++) {
ReportFace(path, pFile.get(), filesize,
FXSYS_UINT32_GET_MSBFIRST(&offsets_span[i * 4]));
}
}
void CFX_FolderFontInfo::ReportFace(const ByteString& path,
FILE* pFile,
uint32_t filesize,
uint32_t offset) {
char buffer[16];
if (fseek(pFile, offset, SEEK_SET) < 0 || !fread(buffer, 12, 1, pFile))
return;
uint32_t nTables = FXSYS_UINT16_GET_MSBFIRST(buffer + 4);
ByteString tables = ReadStringFromFile(pFile, nTables * 16);
if (tables.IsEmpty())
return;
ByteString names =
LoadTableFromTT(pFile, tables.raw_str(), nTables, 0x6e616d65, filesize);
if (names.IsEmpty())
return;
ByteString facename = GetNameFromTT(names.raw_span(), 1);
if (facename.IsEmpty())
return;
ByteString style = GetNameFromTT(names.raw_span(), 2);
if (style != "Regular")
facename += " " + style;
if (pdfium::Contains(m_FontList, facename))
return;
auto pInfo =
std::make_unique<FontFaceInfo>(path, facename, tables, offset, filesize);
ByteString os2 =
LoadTableFromTT(pFile, tables.raw_str(), nTables, 0x4f532f32, filesize);
if (os2.GetLength() >= 86) {
const uint8_t* p = os2.raw_str() + 78;
uint32_t codepages = FXSYS_UINT32_GET_MSBFIRST(p);
if (codepages & (1U << 17)) {
m_pMapper->AddInstalledFont(facename, FX_CHARSET_ShiftJIS);
pInfo->m_Charsets |= CHARSET_FLAG_SHIFTJIS;
}
if (codepages & (1U << 18)) {
m_pMapper->AddInstalledFont(facename, FX_CHARSET_ChineseSimplified);
pInfo->m_Charsets |= CHARSET_FLAG_GB;
}
if (codepages & (1U << 20)) {
m_pMapper->AddInstalledFont(facename, FX_CHARSET_ChineseTraditional);
pInfo->m_Charsets |= CHARSET_FLAG_BIG5;
}
if ((codepages & (1U << 19)) || (codepages & (1U << 21))) {
m_pMapper->AddInstalledFont(facename, FX_CHARSET_Hangul);
pInfo->m_Charsets |= CHARSET_FLAG_KOREAN;
}
if (codepages & (1U << 31)) {
m_pMapper->AddInstalledFont(facename, FX_CHARSET_Symbol);
pInfo->m_Charsets |= CHARSET_FLAG_SYMBOL;
}
}
m_pMapper->AddInstalledFont(facename, FX_CHARSET_ANSI);
pInfo->m_Charsets |= CHARSET_FLAG_ANSI;
pInfo->m_Styles = 0;
if (style.Contains("Bold"))
pInfo->m_Styles |= FXFONT_FORCE_BOLD;
if (style.Contains("Italic") || style.Contains("Oblique"))
pInfo->m_Styles |= FXFONT_ITALIC;
if (facename.Contains("Serif"))
pInfo->m_Styles |= FXFONT_SERIF;
m_FontList[facename] = std::move(pInfo);
}
void* CFX_FolderFontInfo::GetSubstFont(const ByteString& face) {
for (size_t iBaseFont = 0; iBaseFont < pdfium::size(Base14Substs);
iBaseFont++) {
if (face == Base14Substs[iBaseFont].m_pName)
return GetFont(Base14Substs[iBaseFont].m_pSubstName);
}
return nullptr;
}
void* CFX_FolderFontInfo::FindFont(int weight,
bool bItalic,
int charset,
int pitch_family,
const char* family,
bool bMatchName) {
FontFaceInfo* pFind = nullptr;
if (charset == FX_CHARSET_ANSI && FontFamilyIsFixedPitch(pitch_family))
return GetFont("Courier New");
ByteStringView bsFamily(family);
uint32_t charset_flag = GetCharset(charset);
int32_t iBestSimilar = 0;
for (const auto& it : m_FontList) {
const ByteString& bsName = it.first;
FontFaceInfo* pFont = it.second.get();
if (!(pFont->m_Charsets & charset_flag) && charset != FX_CHARSET_Default)
continue;
if (bMatchName && !FindFamilyNameMatch(bsFamily, bsName))
continue;
int32_t iSimilarValue =
GetSimilarValue(weight, bItalic, pitch_family, pFont->m_Styles,
bMatchName, bsFamily.GetLength(), bsName.GetLength());
if (iSimilarValue > iBestSimilar) {
iBestSimilar = iSimilarValue;
pFind = pFont;
}
}
return pFind;
}
void* CFX_FolderFontInfo::MapFont(int weight,
bool bItalic,
int charset,
int pitch_family,
const char* family) {
return nullptr;
}
void* CFX_FolderFontInfo::GetFont(const char* face) {
auto it = m_FontList.find(face);
return it != m_FontList.end() ? it->second.get() : nullptr;
}
uint32_t CFX_FolderFontInfo::GetFontData(void* hFont,
uint32_t table,
pdfium::span<uint8_t> buffer) {
if (!hFont)
return 0;
const FontFaceInfo* pFont = static_cast<FontFaceInfo*>(hFont);
uint32_t datasize = 0;
uint32_t offset = 0;
if (table == 0) {
datasize = pFont->m_FontOffset ? 0 : pFont->m_FileSize;
} else if (table == kTableTTCF) {
datasize = pFont->m_FontOffset ? pFont->m_FileSize : 0;
} else {
uint32_t nTables = pFont->m_FontTables.GetLength() / 16;
for (uint32_t i = 0; i < nTables; i++) {
const uint8_t* p = pFont->m_FontTables.raw_str() + i * 16;
if (FXSYS_UINT32_GET_MSBFIRST(p) == table) {
offset = FXSYS_UINT32_GET_MSBFIRST(p + 8);
datasize = FXSYS_UINT32_GET_MSBFIRST(p + 12);
}
}
}
if (!datasize || buffer.size() < datasize)
return datasize;
std::unique_ptr<FILE, FxFileCloser> pFile(
fopen(pFont->m_FilePath.c_str(), "rb"));
if (!pFile)
return 0;
if (fseek(pFile.get(), offset, SEEK_SET) < 0 ||
fread(buffer.data(), datasize, 1, pFile.get()) != 1) {
return 0;
}
return datasize;
}
void CFX_FolderFontInfo::DeleteFont(void* hFont) {}
bool CFX_FolderFontInfo::GetFaceName(void* hFont, ByteString* name) {
if (!hFont)
return false;
*name = static_cast<FontFaceInfo*>(hFont)->m_FaceName;
return true;
}
bool CFX_FolderFontInfo::GetFontCharset(void* hFont, int* charset) {
return false;
}
CFX_FolderFontInfo::FontFaceInfo::FontFaceInfo(ByteString filePath,
ByteString faceName,
ByteString fontTables,
uint32_t fontOffset,
uint32_t fileSize)
: m_FilePath(filePath),
m_FaceName(faceName),
m_FontTables(fontTables),
m_FontOffset(fontOffset),
m_FileSize(fileSize) {}