summaryrefslogtreecommitdiff
path: root/core/fxge/cfx_facecache.cpp
diff options
context:
space:
mode:
authorDan Sinclair <dsinclair@chromium.org>2017-07-10 15:14:26 -0400
committerChromium commit bot <commit-bot@chromium.org>2017-07-10 19:28:59 +0000
commit92e2276a8be492fd2be8e44a5d62e8a5879644d8 (patch)
tree0945f5edda0fbfb461ca1cae89a20adb583242e4 /core/fxge/cfx_facecache.cpp
parent1437643bfaca635d52f4cb9ec41e3075cf893f79 (diff)
downloadpdfium-92e2276a8be492fd2be8e44a5d62e8a5879644d8.tar.xz
Move core/fxge/ge to core/fxge.
This brings the cpp and h files together and removes the redundant ge/ path. Change-Id: I36594b8ae719d362768ba4c2e4ce173e287363eb Reviewed-on: https://pdfium-review.googlesource.com/7452 Commit-Queue: dsinclair <dsinclair@chromium.org> Reviewed-by: Tom Sepez <tsepez@chromium.org>
Diffstat (limited to 'core/fxge/cfx_facecache.cpp')
-rw-r--r--core/fxge/cfx_facecache.cpp401
1 files changed, 401 insertions, 0 deletions
diff --git a/core/fxge/cfx_facecache.cpp b/core/fxge/cfx_facecache.cpp
new file mode 100644
index 0000000000..eac28074fc
--- /dev/null
+++ b/core/fxge/cfx_facecache.cpp
@@ -0,0 +1,401 @@
+// 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_facecache.h"
+
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <utility>
+
+#include "core/fxcrt/fx_codepage.h"
+#include "core/fxge/cfx_fontmgr.h"
+#include "core/fxge/cfx_gemodule.h"
+#include "core/fxge/cfx_pathdata.h"
+#include "core/fxge/cfx_substfont.h"
+#include "core/fxge/fx_freetype.h"
+#include "core/fxge/fx_text_int.h"
+#include "third_party/base/numerics/safe_math.h"
+#include "third_party/base/ptr_util.h"
+
+#if defined _SKIA_SUPPORT_ || _SKIA_SUPPORT_PATHS_
+#include "third_party/skia/include/core/SkStream.h"
+#include "third_party/skia/include/core/SkTypeface.h"
+
+#if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
+#include "third_party/skia/include/ports/SkFontMgr.h"
+#include "third_party/skia/include/ports/SkFontMgr_empty.h"
+#endif
+#endif
+
+namespace {
+
+constexpr uint32_t kInvalidGlyphIndex = static_cast<uint32_t>(-1);
+
+constexpr int kMinPixel = 0;
+constexpr int kMaxPixel = 255;
+
+constexpr int kMaxGlyphDimension = 2048;
+
+void ContrastAdjust(uint8_t* pDataIn,
+ uint8_t* pDataOut,
+ int nWidth,
+ int nHeight,
+ int nSrcRowBytes,
+ int nDstRowBytes) {
+ int max = kMinPixel;
+ int min = kMaxPixel;
+ for (int row = 0; row < nHeight; row++) {
+ uint8_t* pRow = pDataIn + row * nSrcRowBytes;
+ for (int col = 0; col < nWidth; col++) {
+ int val = pRow[col];
+ max = std::max(val, max);
+ min = std::min(val, min);
+ }
+ }
+ int diff = max - min;
+ if (diff == kMinPixel || diff == kMaxPixel) {
+ int rowbytes = std::min(abs(nSrcRowBytes), nDstRowBytes);
+ for (int row = 0; row < nHeight; row++) {
+ memcpy(pDataOut + row * nDstRowBytes, pDataIn + row * nSrcRowBytes,
+ rowbytes);
+ }
+ return;
+ }
+ float rate = 255.f / diff;
+ for (int row = 0; row < nHeight; row++) {
+ uint8_t* pSrcRow = pDataIn + row * nSrcRowBytes;
+ uint8_t* pDstRow = pDataOut + row * nDstRowBytes;
+ for (int col = 0; col < nWidth; col++) {
+ int val = static_cast<int>((pSrcRow[col] - min) * rate + 0.5);
+ pDstRow[col] =
+ static_cast<uint8_t>(pdfium::clamp(val, kMinPixel, kMaxPixel));
+ }
+ }
+}
+
+} // namespace
+
+CFX_FaceCache::CFX_FaceCache(FXFT_Face face)
+ : m_Face(face)
+#if defined _SKIA_SUPPORT_ || _SKIA_SUPPORT_PATHS_
+ ,
+ m_pTypeface(nullptr)
+#endif
+{
+}
+
+CFX_FaceCache::~CFX_FaceCache() {}
+
+std::unique_ptr<CFX_GlyphBitmap> CFX_FaceCache::RenderGlyph(
+ const CFX_Font* pFont,
+ uint32_t glyph_index,
+ bool bFontStyle,
+ const CFX_Matrix* pMatrix,
+ int dest_width,
+ int anti_alias) {
+ if (!m_Face)
+ return nullptr;
+
+ FXFT_Matrix ft_matrix;
+ ft_matrix.xx = (signed long)(pMatrix->a / 64 * 65536);
+ ft_matrix.xy = (signed long)(pMatrix->c / 64 * 65536);
+ ft_matrix.yx = (signed long)(pMatrix->b / 64 * 65536);
+ ft_matrix.yy = (signed long)(pMatrix->d / 64 * 65536);
+ bool bUseCJKSubFont = false;
+ const CFX_SubstFont* pSubstFont = pFont->GetSubstFont();
+ if (pSubstFont) {
+ bUseCJKSubFont = pSubstFont->m_bSubstCJK && bFontStyle;
+ int skew = 0;
+ if (bUseCJKSubFont)
+ skew = pSubstFont->m_bItalicCJK ? -15 : 0;
+ else
+ skew = pSubstFont->m_ItalicAngle;
+ if (skew) {
+ // |skew| is nonpositive so |-skew| is used as the index. We need to make
+ // sure |skew| != INT_MIN since -INT_MIN is undefined.
+ if (skew <= 0 && skew != std::numeric_limits<int>::min() &&
+ static_cast<size_t>(-skew) < CFX_Font::kAngleSkewArraySize) {
+ skew = -CFX_Font::s_AngleSkew[-skew];
+ } else {
+ skew = -58;
+ }
+ if (pFont->IsVertical())
+ ft_matrix.yx += ft_matrix.yy * skew / 100;
+ else
+ ft_matrix.xy -= ft_matrix.xx * skew / 100;
+ }
+ if (pSubstFont->m_SubstFlags & FXFONT_SUBST_MM) {
+ pFont->AdjustMMParams(glyph_index, dest_width,
+ pFont->GetSubstFont()->m_Weight);
+ }
+ }
+ ScopedFontTransform scoped_transform(m_Face, &ft_matrix);
+ int load_flags = (m_Face->face_flags & FT_FACE_FLAG_SFNT)
+ ? FXFT_LOAD_NO_BITMAP
+ : (FXFT_LOAD_NO_BITMAP | FT_LOAD_NO_HINTING);
+ int error = FXFT_Load_Glyph(m_Face, glyph_index, load_flags);
+ if (error) {
+ // if an error is returned, try to reload glyphs without hinting.
+ if (load_flags & FT_LOAD_NO_HINTING || load_flags & FT_LOAD_NO_SCALE)
+ return nullptr;
+
+ load_flags |= FT_LOAD_NO_HINTING;
+ error = FXFT_Load_Glyph(m_Face, glyph_index, load_flags);
+
+ if (error)
+ return nullptr;
+ }
+ int weight = 0;
+ if (bUseCJKSubFont)
+ weight = pSubstFont->m_WeightCJK;
+ else
+ weight = pSubstFont ? pSubstFont->m_Weight : 0;
+ if (pSubstFont && !(pSubstFont->m_SubstFlags & FXFONT_SUBST_MM) &&
+ weight > 400) {
+ uint32_t index = (weight - 400) / 10;
+ if (index >= CFX_Font::kWeightPowArraySize)
+ return nullptr;
+ pdfium::base::CheckedNumeric<signed long> level = 0;
+ if (pSubstFont->m_Charset == FX_CHARSET_ShiftJIS)
+ level = CFX_Font::s_WeightPow_SHIFTJIS[index] * 2;
+ else
+ level = CFX_Font::s_WeightPow_11[index];
+
+ level = level *
+ (abs(static_cast<int>(ft_matrix.xx)) +
+ abs(static_cast<int>(ft_matrix.xy))) /
+ 36655;
+ FXFT_Outline_Embolden(FXFT_Get_Glyph_Outline(m_Face),
+ level.ValueOrDefault(0));
+ }
+ FXFT_Library_SetLcdFilter(CFX_GEModule::Get()->GetFontMgr()->GetFTLibrary(),
+ FT_LCD_FILTER_DEFAULT);
+ error = FXFT_Render_Glyph(m_Face, anti_alias);
+ if (error)
+ return nullptr;
+ int bmwidth = FXFT_Get_Bitmap_Width(FXFT_Get_Glyph_Bitmap(m_Face));
+ int bmheight = FXFT_Get_Bitmap_Rows(FXFT_Get_Glyph_Bitmap(m_Face));
+ if (bmwidth > kMaxGlyphDimension || bmheight > kMaxGlyphDimension)
+ return nullptr;
+ int dib_width = bmwidth;
+ auto pGlyphBitmap = pdfium::MakeUnique<CFX_GlyphBitmap>();
+ pGlyphBitmap->m_pBitmap->Create(
+ dib_width, bmheight,
+ anti_alias == FXFT_RENDER_MODE_MONO ? FXDIB_1bppMask : FXDIB_8bppMask);
+ pGlyphBitmap->m_Left = FXFT_Get_Glyph_BitmapLeft(m_Face);
+ pGlyphBitmap->m_Top = FXFT_Get_Glyph_BitmapTop(m_Face);
+ int dest_pitch = pGlyphBitmap->m_pBitmap->GetPitch();
+ int src_pitch = FXFT_Get_Bitmap_Pitch(FXFT_Get_Glyph_Bitmap(m_Face));
+ uint8_t* pDestBuf = pGlyphBitmap->m_pBitmap->GetBuffer();
+ uint8_t* pSrcBuf =
+ (uint8_t*)FXFT_Get_Bitmap_Buffer(FXFT_Get_Glyph_Bitmap(m_Face));
+ if (anti_alias != FXFT_RENDER_MODE_MONO &&
+ FXFT_Get_Bitmap_PixelMode(FXFT_Get_Glyph_Bitmap(m_Face)) ==
+ FXFT_PIXEL_MODE_MONO) {
+ int bytes = anti_alias == FXFT_RENDER_MODE_LCD ? 3 : 1;
+ for (int i = 0; i < bmheight; i++) {
+ for (int n = 0; n < bmwidth; n++) {
+ uint8_t data =
+ (pSrcBuf[i * src_pitch + n / 8] & (0x80 >> (n % 8))) ? 255 : 0;
+ for (int b = 0; b < bytes; b++)
+ pDestBuf[i * dest_pitch + n * bytes + b] = data;
+ }
+ }
+ } else {
+ memset(pDestBuf, 0, dest_pitch * bmheight);
+ if (anti_alias == FXFT_RENDER_MODE_MONO &&
+ FXFT_Get_Bitmap_PixelMode(FXFT_Get_Glyph_Bitmap(m_Face)) ==
+ FXFT_PIXEL_MODE_MONO) {
+ int rowbytes = abs(src_pitch) > dest_pitch ? dest_pitch : abs(src_pitch);
+ for (int row = 0; row < bmheight; row++) {
+ memcpy(pDestBuf + row * dest_pitch, pSrcBuf + row * src_pitch,
+ rowbytes);
+ }
+ } else {
+ ContrastAdjust(pSrcBuf, pDestBuf, bmwidth, bmheight, src_pitch,
+ dest_pitch);
+ }
+ }
+ return pGlyphBitmap;
+}
+
+const CFX_PathData* CFX_FaceCache::LoadGlyphPath(const CFX_Font* pFont,
+ uint32_t glyph_index,
+ int dest_width) {
+ if (!m_Face || glyph_index == kInvalidGlyphIndex || dest_width < 0)
+ return nullptr;
+
+ uint32_t key = glyph_index;
+ auto* pSubstFont = pFont->GetSubstFont();
+ if (pSubstFont) {
+ if (pSubstFont->m_Weight < 0 || pSubstFont->m_ItalicAngle < 0)
+ return nullptr;
+ uint32_t weight = static_cast<uint32_t>(pSubstFont->m_Weight);
+ uint32_t angle = static_cast<uint32_t>(pSubstFont->m_ItalicAngle);
+ uint32_t key_modifier = (weight / 16) << 15;
+ key_modifier += (angle / 2) << 21;
+ key_modifier += (static_cast<uint32_t>(dest_width) / 16) << 25;
+ if (pFont->IsVertical())
+ key_modifier += 1U << 31;
+ key += key_modifier;
+ }
+ auto it = m_PathMap.find(key);
+ if (it != m_PathMap.end())
+ return it->second.get();
+
+ CFX_PathData* pGlyphPath = pFont->LoadGlyphPathImpl(glyph_index, dest_width);
+ m_PathMap[key] = std::unique_ptr<CFX_PathData>(pGlyphPath);
+ return pGlyphPath;
+}
+
+const CFX_GlyphBitmap* CFX_FaceCache::LoadGlyphBitmap(const CFX_Font* pFont,
+ uint32_t glyph_index,
+ bool bFontStyle,
+ const CFX_Matrix* pMatrix,
+ int dest_width,
+ int anti_alias,
+ int& text_flags) {
+ if (glyph_index == kInvalidGlyphIndex)
+ return nullptr;
+
+ CFX_UniqueKeyGen keygen;
+ int nMatrixA = static_cast<int>(pMatrix->a * 10000);
+ int nMatrixB = static_cast<int>(pMatrix->b * 10000);
+ int nMatrixC = static_cast<int>(pMatrix->c * 10000);
+ int nMatrixD = static_cast<int>(pMatrix->d * 10000);
+#if _FXM_PLATFORM_ != _FXM_PLATFORM_APPLE_
+ if (pFont->GetSubstFont()) {
+ keygen.Generate(9, nMatrixA, nMatrixB, nMatrixC, nMatrixD, dest_width,
+ anti_alias, pFont->GetSubstFont()->m_Weight,
+ pFont->GetSubstFont()->m_ItalicAngle, pFont->IsVertical());
+ } else {
+ keygen.Generate(6, nMatrixA, nMatrixB, nMatrixC, nMatrixD, dest_width,
+ anti_alias);
+ }
+#else
+ if (text_flags & FXTEXT_NO_NATIVETEXT) {
+ if (pFont->GetSubstFont()) {
+ keygen.Generate(9, nMatrixA, nMatrixB, nMatrixC, nMatrixD, dest_width,
+ anti_alias, pFont->GetSubstFont()->m_Weight,
+ pFont->GetSubstFont()->m_ItalicAngle,
+ pFont->IsVertical());
+ } else {
+ keygen.Generate(6, nMatrixA, nMatrixB, nMatrixC, nMatrixD, dest_width,
+ anti_alias);
+ }
+ } else {
+ if (pFont->GetSubstFont()) {
+ keygen.Generate(10, nMatrixA, nMatrixB, nMatrixC, nMatrixD, dest_width,
+ anti_alias, pFont->GetSubstFont()->m_Weight,
+ pFont->GetSubstFont()->m_ItalicAngle, pFont->IsVertical(),
+ 3);
+ } else {
+ keygen.Generate(7, nMatrixA, nMatrixB, nMatrixC, nMatrixD, dest_width,
+ anti_alias, 3);
+ }
+ }
+#endif
+ CFX_ByteString FaceGlyphsKey(keygen.m_Key, keygen.m_KeyLen);
+#if _FXM_PLATFORM_ != _FXM_PLATFORM_APPLE_ || defined _SKIA_SUPPORT_ || \
+ defined _SKIA_SUPPORT_PATHS_
+ return LookUpGlyphBitmap(pFont, pMatrix, FaceGlyphsKey, glyph_index,
+ bFontStyle, dest_width, anti_alias);
+#else
+ if (text_flags & FXTEXT_NO_NATIVETEXT) {
+ return LookUpGlyphBitmap(pFont, pMatrix, FaceGlyphsKey, glyph_index,
+ bFontStyle, dest_width, anti_alias);
+ }
+ std::unique_ptr<CFX_GlyphBitmap> pGlyphBitmap;
+ auto it = m_SizeMap.find(FaceGlyphsKey);
+ if (it != m_SizeMap.end()) {
+ CFX_SizeGlyphCache* pSizeCache = it->second.get();
+ auto it2 = pSizeCache->m_GlyphMap.find(glyph_index);
+ if (it2 != pSizeCache->m_GlyphMap.end())
+ return it2->second.get();
+
+ pGlyphBitmap = RenderGlyph_Nativetext(pFont, glyph_index, pMatrix,
+ dest_width, anti_alias);
+ if (pGlyphBitmap) {
+ CFX_GlyphBitmap* pResult = pGlyphBitmap.get();
+ pSizeCache->m_GlyphMap[glyph_index] = std::move(pGlyphBitmap);
+ return pResult;
+ }
+ } else {
+ pGlyphBitmap = RenderGlyph_Nativetext(pFont, glyph_index, pMatrix,
+ dest_width, anti_alias);
+ if (pGlyphBitmap) {
+ auto pNewCache = pdfium::MakeUnique<CFX_SizeGlyphCache>();
+ CFX_SizeGlyphCache* pSizeCache = pNewCache.get();
+ m_SizeMap[FaceGlyphsKey] = std::move(pNewCache);
+ CFX_GlyphBitmap* pResult = pGlyphBitmap.get();
+ pSizeCache->m_GlyphMap[glyph_index] = std::move(pGlyphBitmap);
+ return pResult;
+ }
+ }
+ if (pFont->GetSubstFont()) {
+ keygen.Generate(9, nMatrixA, nMatrixB, nMatrixC, nMatrixD, dest_width,
+ anti_alias, pFont->GetSubstFont()->m_Weight,
+ pFont->GetSubstFont()->m_ItalicAngle, pFont->IsVertical());
+ } else {
+ keygen.Generate(6, nMatrixA, nMatrixB, nMatrixC, nMatrixD, dest_width,
+ anti_alias);
+ }
+ CFX_ByteString FaceGlyphsKey2(keygen.m_Key, keygen.m_KeyLen);
+ text_flags |= FXTEXT_NO_NATIVETEXT;
+ return LookUpGlyphBitmap(pFont, pMatrix, FaceGlyphsKey2, glyph_index,
+ bFontStyle, dest_width, anti_alias);
+#endif
+}
+
+#if defined _SKIA_SUPPORT_ || defined _SKIA_SUPPORT_PATHS_
+CFX_TypeFace* CFX_FaceCache::GetDeviceCache(const CFX_Font* pFont) {
+ if (!m_pTypeface) {
+ m_pTypeface = SkTypeface::MakeFromStream(
+ new SkMemoryStream(pFont->GetFontData(), pFont->GetSize()));
+ }
+#if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
+ if (!m_pTypeface) {
+ sk_sp<SkFontMgr> customMgr(SkFontMgr_New_Custom_Empty());
+ m_pTypeface.reset(customMgr->createFromStream(
+ new SkMemoryStream(pFont->GetFontData(), pFont->GetSize())));
+ }
+#endif
+ return m_pTypeface.get();
+}
+#endif
+
+#if _FXM_PLATFORM_ != _FXM_PLATFORM_APPLE_
+void CFX_FaceCache::InitPlatform() {}
+#endif
+
+CFX_GlyphBitmap* CFX_FaceCache::LookUpGlyphBitmap(
+ const CFX_Font* pFont,
+ const CFX_Matrix* pMatrix,
+ const CFX_ByteString& FaceGlyphsKey,
+ uint32_t glyph_index,
+ bool bFontStyle,
+ int dest_width,
+ int anti_alias) {
+ CFX_SizeGlyphCache* pSizeCache;
+ auto it = m_SizeMap.find(FaceGlyphsKey);
+ if (it == m_SizeMap.end()) {
+ auto pNewCache = pdfium::MakeUnique<CFX_SizeGlyphCache>();
+ pSizeCache = pNewCache.get();
+ m_SizeMap[FaceGlyphsKey] = std::move(pNewCache);
+ } else {
+ pSizeCache = it->second.get();
+ }
+ auto it2 = pSizeCache->m_GlyphMap.find(glyph_index);
+ if (it2 != pSizeCache->m_GlyphMap.end())
+ return it2->second.get();
+
+ std::unique_ptr<CFX_GlyphBitmap> pGlyphBitmap = RenderGlyph(
+ pFont, glyph_index, bFontStyle, pMatrix, dest_width, anti_alias);
+ CFX_GlyphBitmap* pResult = pGlyphBitmap.get();
+ pSizeCache->m_GlyphMap[glyph_index] = std::move(pGlyphBitmap);
+ return pResult;
+}