blob: 36413f826a6896c1015ae044c8af0661bd451370 [file] [log] [blame] [edit]
// Copyright 2016 The PDFium Authors
// 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/fpdfapi/font/cpdf_font.h"
#include <algorithm>
#include <memory>
#include <utility>
#include <vector>
#include "build/build_config.h"
#include "constants/font_encodings.h"
#include "core/fpdfapi/font/cpdf_cidfont.h"
#include "core/fpdfapi/font/cpdf_fontencoding.h"
#include "core/fpdfapi/font/cpdf_fontglobals.h"
#include "core/fpdfapi/font/cpdf_tounicodemap.h"
#include "core/fpdfapi/font/cpdf_truetypefont.h"
#include "core/fpdfapi/font/cpdf_type1font.h"
#include "core/fpdfapi/font/cpdf_type3font.h"
#include "core/fpdfapi/parser/cpdf_array.h"
#include "core/fpdfapi/parser/cpdf_dictionary.h"
#include "core/fpdfapi/parser/cpdf_document.h"
#include "core/fpdfapi/parser/cpdf_name.h"
#include "core/fpdfapi/parser/cpdf_stream.h"
#include "core/fpdfapi/parser/cpdf_stream_acc.h"
#include "core/fxcrt/fx_codepage.h"
#include "core/fxcrt/fx_safe_types.h"
#include "core/fxcrt/stl_util.h"
#include "core/fxge/cfx_fontmapper.h"
#include "core/fxge/cfx_substfont.h"
#include "core/fxge/freetype/fx_freetype.h"
#include "core/fxge/fx_font.h"
#include "third_party/base/check.h"
#include "third_party/base/numerics/safe_conversions.h"
namespace {
constexpr size_t kChineseFontNameSize = 4;
const uint8_t kChineseFontNames[][kChineseFontNameSize] = {
{0xCB, 0xCE, 0xCC, 0xE5},
{0xBF, 0xAC, 0xCC, 0xE5},
{0xBA, 0xDA, 0xCC, 0xE5},
{0xB7, 0xC2, 0xCB, 0xCE},
{0xD0, 0xC2, 0xCB, 0xCE}};
} // namespace
CPDF_Font::CPDF_Font(CPDF_Document* pDocument,
RetainPtr<CPDF_Dictionary> pFontDict)
: m_pDocument(pDocument),
m_pFontDict(std::move(pFontDict)),
m_BaseFontName(m_pFontDict->GetByteStringFor("BaseFont")) {}
CPDF_Font::~CPDF_Font() {
if (m_pFontFile)
m_pDocument->MaybePurgeFontFileStreamAcc(std::move(m_pFontFile));
}
bool CPDF_Font::IsType1Font() const {
return false;
}
bool CPDF_Font::IsTrueTypeFont() const {
return false;
}
bool CPDF_Font::IsType3Font() const {
return false;
}
bool CPDF_Font::IsCIDFont() const {
return false;
}
const CPDF_Type1Font* CPDF_Font::AsType1Font() const {
return nullptr;
}
CPDF_Type1Font* CPDF_Font::AsType1Font() {
return nullptr;
}
const CPDF_TrueTypeFont* CPDF_Font::AsTrueTypeFont() const {
return nullptr;
}
CPDF_TrueTypeFont* CPDF_Font::AsTrueTypeFont() {
return nullptr;
}
const CPDF_Type3Font* CPDF_Font::AsType3Font() const {
return nullptr;
}
CPDF_Type3Font* CPDF_Font::AsType3Font() {
return nullptr;
}
const CPDF_CIDFont* CPDF_Font::AsCIDFont() const {
return nullptr;
}
CPDF_CIDFont* CPDF_Font::AsCIDFont() {
return nullptr;
}
size_t CPDF_Font::CountChar(ByteStringView pString) const {
return pString.GetLength();
}
#if BUILDFLAG(IS_APPLE)
int CPDF_Font::GlyphFromCharCodeExt(uint32_t charcode) {
return GlyphFromCharCode(charcode, nullptr);
}
#endif
void CPDF_Font::WillBeDestroyed() {}
bool CPDF_Font::IsVertWriting() const {
const CPDF_CIDFont* pCIDFont = AsCIDFont();
return pCIDFont ? pCIDFont->IsVertWriting() : m_Font.IsVertical();
}
int CPDF_Font::AppendChar(char* buf, uint32_t charcode) const {
*buf = static_cast<char>(charcode);
return 1;
}
void CPDF_Font::AppendChar(ByteString* str, uint32_t charcode) const {
char buf[4];
int len = AppendChar(buf, charcode);
*str += ByteStringView(buf, len);
}
WideString CPDF_Font::UnicodeFromCharCode(uint32_t charcode) const {
if (!m_bToUnicodeLoaded)
LoadUnicodeMap();
return m_pToUnicodeMap ? m_pToUnicodeMap->Lookup(charcode) : WideString();
}
uint32_t CPDF_Font::CharCodeFromUnicode(wchar_t unicode) const {
if (!m_bToUnicodeLoaded)
LoadUnicodeMap();
return m_pToUnicodeMap ? m_pToUnicodeMap->ReverseLookup(unicode) : 0;
}
bool CPDF_Font::HasFontWidths() const {
return true;
}
void CPDF_Font::LoadFontDescriptor(const CPDF_Dictionary* pFontDesc) {
m_Flags = pFontDesc->GetIntegerFor("Flags", FXFONT_NONSYMBOLIC);
int ItalicAngle = 0;
bool bExistItalicAngle = false;
if (pFontDesc->KeyExist("ItalicAngle")) {
ItalicAngle = pFontDesc->GetIntegerFor("ItalicAngle");
bExistItalicAngle = true;
}
if (ItalicAngle < 0) {
m_Flags |= FXFONT_ITALIC;
m_ItalicAngle = ItalicAngle;
}
bool bExistStemV = false;
if (pFontDesc->KeyExist("StemV")) {
m_StemV = pFontDesc->GetIntegerFor("StemV");
bExistStemV = true;
}
bool bExistAscent = false;
if (pFontDesc->KeyExist("Ascent")) {
m_Ascent = pFontDesc->GetIntegerFor("Ascent");
bExistAscent = true;
}
bool bExistDescent = false;
if (pFontDesc->KeyExist("Descent")) {
m_Descent = pFontDesc->GetIntegerFor("Descent");
bExistDescent = true;
}
bool bExistCapHeight = false;
if (pFontDesc->KeyExist("CapHeight"))
bExistCapHeight = true;
if (bExistItalicAngle && bExistAscent && bExistCapHeight && bExistDescent &&
bExistStemV) {
m_Flags |= FXFONT_USEEXTERNATTR;
}
if (m_Descent > 10)
m_Descent = -m_Descent;
RetainPtr<const CPDF_Array> pBBox = pFontDesc->GetArrayFor("FontBBox");
if (pBBox) {
m_FontBBox.left = pBBox->GetIntegerAt(0);
m_FontBBox.bottom = pBBox->GetIntegerAt(1);
m_FontBBox.right = pBBox->GetIntegerAt(2);
m_FontBBox.top = pBBox->GetIntegerAt(3);
}
RetainPtr<const CPDF_Stream> pFontFile = pFontDesc->GetStreamFor("FontFile");
if (!pFontFile)
pFontFile = pFontDesc->GetStreamFor("FontFile2");
if (!pFontFile)
pFontFile = pFontDesc->GetStreamFor("FontFile3");
if (!pFontFile)
return;
const uint64_t key = pFontFile->KeyForCache();
m_pFontFile = m_pDocument->GetFontFileStreamAcc(std::move(pFontFile));
if (!m_pFontFile)
return;
if (!m_Font.LoadEmbedded(m_pFontFile->GetSpan(), IsVertWriting(), key))
m_pDocument->MaybePurgeFontFileStreamAcc(std::move(m_pFontFile));
}
void CPDF_Font::CheckFontMetrics() {
if (m_FontBBox.top == 0 && m_FontBBox.bottom == 0 && m_FontBBox.left == 0 &&
m_FontBBox.right == 0) {
FXFT_FaceRec* face = m_Font.GetFaceRec();
if (face) {
m_FontBBox.left = TT2PDF(FXFT_Get_Face_xMin(face), face);
m_FontBBox.bottom = TT2PDF(FXFT_Get_Face_yMin(face), face);
m_FontBBox.right = TT2PDF(FXFT_Get_Face_xMax(face), face);
m_FontBBox.top = TT2PDF(FXFT_Get_Face_yMax(face), face);
m_Ascent = TT2PDF(FXFT_Get_Face_Ascender(face), face);
m_Descent = TT2PDF(FXFT_Get_Face_Descender(face), face);
} else {
bool bFirst = true;
for (int i = 0; i < 256; i++) {
FX_RECT rect = GetCharBBox(i);
if (rect.left == rect.right) {
continue;
}
if (bFirst) {
m_FontBBox = rect;
bFirst = false;
} else {
m_FontBBox.left = std::min(m_FontBBox.left, rect.left);
m_FontBBox.top = std::max(m_FontBBox.top, rect.top);
m_FontBBox.right = std::max(m_FontBBox.right, rect.right);
m_FontBBox.bottom = std::min(m_FontBBox.bottom, rect.bottom);
}
}
}
}
if (m_Ascent == 0 && m_Descent == 0) {
FX_RECT rect = GetCharBBox('A');
m_Ascent = rect.bottom == rect.top ? m_FontBBox.top : rect.top;
rect = GetCharBBox('g');
m_Descent = rect.bottom == rect.top ? m_FontBBox.bottom : rect.bottom;
}
}
void CPDF_Font::LoadUnicodeMap() const {
m_bToUnicodeLoaded = true;
RetainPtr<const CPDF_Stream> pStream = m_pFontDict->GetStreamFor("ToUnicode");
if (!pStream)
return;
m_pToUnicodeMap = std::make_unique<CPDF_ToUnicodeMap>(std::move(pStream));
}
int CPDF_Font::GetStringWidth(ByteStringView pString) {
size_t offset = 0;
int width = 0;
while (offset < pString.GetLength())
width += GetCharWidthF(GetNextChar(pString, &offset));
return width;
}
// static
RetainPtr<CPDF_Font> CPDF_Font::GetStockFont(CPDF_Document* pDoc,
ByteStringView name) {
ByteString fontname(name);
absl::optional<CFX_FontMapper::StandardFont> font_id =
CFX_FontMapper::GetStandardFontName(&fontname);
if (!font_id.has_value())
return nullptr;
auto* pFontGlobals = CPDF_FontGlobals::GetInstance();
RetainPtr<CPDF_Font> pFont = pFontGlobals->Find(pDoc, font_id.value());
if (pFont)
return pFont;
auto pDict = pDoc->New<CPDF_Dictionary>();
pDict->SetNewFor<CPDF_Name>("Type", "Font");
pDict->SetNewFor<CPDF_Name>("Subtype", "Type1");
pDict->SetNewFor<CPDF_Name>("BaseFont", fontname);
pDict->SetNewFor<CPDF_Name>("Encoding",
pdfium::font_encodings::kWinAnsiEncoding);
pFont = CPDF_Font::Create(nullptr, std::move(pDict), nullptr);
pFontGlobals->Set(pDoc, font_id.value(), pFont);
return pFont;
}
// static
RetainPtr<CPDF_Font> CPDF_Font::Create(CPDF_Document* pDoc,
RetainPtr<CPDF_Dictionary> pFontDict,
FormFactoryIface* pFactory) {
ByteString type = pFontDict->GetByteStringFor("Subtype");
RetainPtr<CPDF_Font> pFont;
if (type == "TrueType") {
ByteString tag = pFontDict->GetByteStringFor("BaseFont").First(4);
for (size_t i = 0; i < std::size(kChineseFontNames); ++i) {
if (tag == ByteString(kChineseFontNames[i], kChineseFontNameSize)) {
RetainPtr<const CPDF_Dictionary> pFontDesc =
pFontDict->GetDictFor("FontDescriptor");
if (!pFontDesc || !pFontDesc->KeyExist("FontFile2"))
pFont = pdfium::MakeRetain<CPDF_CIDFont>(pDoc, std::move(pFontDict));
break;
}
}
if (!pFont)
pFont = pdfium::MakeRetain<CPDF_TrueTypeFont>(pDoc, std::move(pFontDict));
} else if (type == "Type3") {
pFont = pdfium::MakeRetain<CPDF_Type3Font>(pDoc, std::move(pFontDict),
pFactory);
} else if (type == "Type0") {
pFont = pdfium::MakeRetain<CPDF_CIDFont>(pDoc, std::move(pFontDict));
} else {
pFont = pdfium::MakeRetain<CPDF_Type1Font>(pDoc, std::move(pFontDict));
}
if (!pFont->Load())
return nullptr;
return pFont;
}
uint32_t CPDF_Font::GetNextChar(ByteStringView pString, size_t* pOffset) const {
if (pString.IsEmpty())
return 0;
size_t& offset = *pOffset;
return offset < pString.GetLength() ? pString[offset++] : pString.Back();
}
bool CPDF_Font::IsStandardFont() const {
if (!IsType1Font())
return false;
if (m_pFontFile)
return false;
return AsType1Font()->IsBase14Font();
}
absl::optional<FX_Charset> CPDF_Font::GetSubstFontCharset() const {
CFX_SubstFont* pFont = m_Font.GetSubstFont();
if (!pFont)
return absl::nullopt;
return pFont->m_Charset;
}
// static
const char* CPDF_Font::GetAdobeCharName(
FontEncoding base_encoding,
const std::vector<ByteString>& charnames,
uint32_t charcode) {
if (charcode >= 256)
return nullptr;
if (!charnames.empty() && !charnames[charcode].IsEmpty())
return charnames[charcode].c_str();
const char* name = nullptr;
if (base_encoding != FontEncoding::kBuiltin)
name = CharNameFromPredefinedCharSet(base_encoding, charcode);
if (!name)
return nullptr;
DCHECK(name[0]);
return name;
}
uint32_t CPDF_Font::FallbackFontFromCharcode(uint32_t charcode) {
if (m_FontFallbacks.empty()) {
m_FontFallbacks.push_back(std::make_unique<CFX_Font>());
FX_SAFE_INT32 safeWeight = m_StemV;
safeWeight *= 5;
m_FontFallbacks[0]->LoadSubst("Arial", IsTrueTypeFont(), m_Flags,
safeWeight.ValueOrDefault(FXFONT_FW_NORMAL),
m_ItalicAngle, FX_CodePage::kDefANSI,
IsVertWriting());
}
return 0;
}
int CPDF_Font::FallbackGlyphFromCharcode(int fallbackFont, uint32_t charcode) {
if (!fxcrt::IndexInBounds(m_FontFallbacks, fallbackFont))
return -1;
WideString str = UnicodeFromCharCode(charcode);
uint32_t unicode = !str.IsEmpty() ? str[0] : charcode;
int glyph =
FT_Get_Char_Index(m_FontFallbacks[fallbackFont]->GetFaceRec(), unicode);
if (glyph == 0)
return -1;
return glyph;
}
CFX_Font* CPDF_Font::GetFontFallback(int position) {
if (position < 0 || static_cast<size_t>(position) >= m_FontFallbacks.size())
return nullptr;
return m_FontFallbacks[position].get();
}
// static
int CPDF_Font::TT2PDF(FT_Pos m, FXFT_FaceRec* face) {
int upm = FXFT_Get_Face_UnitsPerEM(face);
if (upm == 0)
return pdfium::base::saturated_cast<int>(m);
const double dm = (m * 1000.0 + upm / 2) / upm;
return pdfium::base::saturated_cast<int>(dm);
}
// static
bool CPDF_Font::UseTTCharmap(FXFT_FaceRec* face,
int platform_id,
int encoding_id) {
for (int i = 0; i < face->num_charmaps; i++) {
if (FXFT_Get_Charmap_PlatformID(face->charmaps[i]) == platform_id &&
FXFT_Get_Charmap_EncodingID(face->charmaps[i]) == encoding_id) {
FT_Set_Charmap(face, face->charmaps[i]);
return true;
}
}
return false;
}
int CPDF_Font::GetFontWeight() const {
FX_SAFE_INT32 safeStemV(m_StemV);
if (m_StemV < 140)
safeStemV *= 5;
else
safeStemV = safeStemV * 4 + 140;
return safeStemV.ValueOrDefault(FXFONT_FW_NORMAL);
}