blob: ae168f4b759d6a00be6634a63b445a5aec22fe10 [file] [log] [blame] [edit]
// Copyright 2014 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/fxge/win32/cfx_psrenderer.h"
#include <math.h>
#include <string.h>
#include <algorithm>
#include <array>
#include <memory>
#include <string>
#include <utility>
#include "core/fxcrt/bytestring.h"
#include "core/fxcrt/fx_extension.h"
#include "core/fxcrt/fx_memory.h"
#include "core/fxcrt/fx_memory_wrappers.h"
#include "core/fxcrt/fx_safe_types.h"
#include "core/fxcrt/fx_stream.h"
#include "core/fxcrt/span_util.h"
#include "core/fxge/cfx_fillrenderoptions.h"
#include "core/fxge/cfx_font.h"
#include "core/fxge/cfx_fontcache.h"
#include "core/fxge/cfx_gemodule.h"
#include "core/fxge/cfx_glyphcache.h"
#include "core/fxge/cfx_path.h"
#include "core/fxge/cfx_renderdevice.h"
#include "core/fxge/dib/cfx_dibextractor.h"
#include "core/fxge/dib/cfx_dibitmap.h"
#include "core/fxge/dib/fx_dib.h"
#include "core/fxge/freetype/fx_freetype.h"
#include "core/fxge/text_char_pos.h"
#include "core/fxge/win32/cfx_psfonttracker.h"
#include "third_party/base/check_op.h"
#include "third_party/base/numerics/safe_conversions.h"
namespace {
bool CanEmbed(CFX_Font* font) {
FT_UShort fstype = FT_Get_FSType_Flags(font->GetFaceRec());
return (fstype & (FT_FSTYPE_RESTRICTED_LICENSE_EMBEDDING |
FT_FSTYPE_BITMAP_EMBEDDING_ONLY)) == 0;
}
absl::optional<ByteString> GenerateType42SfntData(
const ByteString& psname,
pdfium::span<const uint8_t> font_data) {
if (font_data.empty())
return absl::nullopt;
// Per Type 42 font spec.
constexpr size_t kMaxSfntStringSize = 65535;
if (font_data.size() > kMaxSfntStringSize) {
// TODO(thestig): Fonts that are too big need to be written out in sections.
return absl::nullopt;
}
// Each byte is written as 2 ASCIIHex characters, so really 64 chars per line.
constexpr size_t kMaxBytesPerLine = 32;
fxcrt::ostringstream output;
output << "/" << psname << "_sfnts [\n<\n";
size_t bytes_per_line = 0;
char buf[2];
for (uint8_t datum : font_data) {
FXSYS_IntToTwoHexChars(datum, buf);
output << buf[0];
output << buf[1];
bytes_per_line++;
if (bytes_per_line == kMaxBytesPerLine) {
output << "\n";
bytes_per_line = 0;
}
}
// Pad with ASCIIHex NUL character per Type 42 font spec if needed.
if (!FX_IsOdd(font_data.size()))
output << "00";
output << "\n>\n] def\n";
return ByteString(output);
}
// The value to use with GenerateType42FontDictionary() below, and the max
// number of entries supported for non-CID fonts.
// Also used to avoid buggy fonts by writing out at least this many entries,
// per note in Poppler's Type 42 generation code.
constexpr size_t kGlyphsPerDescendantFont = 256;
ByteString GenerateType42FontDictionary(const ByteString& psname,
const FX_RECT& bbox,
size_t num_glyphs,
size_t glyphs_per_descendant_font) {
DCHECK_LE(glyphs_per_descendant_font, kGlyphsPerDescendantFont);
CHECK_GT(glyphs_per_descendant_font, 0u);
const size_t descendant_font_count =
(num_glyphs + glyphs_per_descendant_font - 1) /
glyphs_per_descendant_font;
fxcrt::ostringstream output;
for (size_t i = 0; i < descendant_font_count; ++i) {
output << "8 dict begin\n";
output << "/FontType 42 def\n";
output << "/FontMatrix [1 0 0 1 0 0] def\n";
output << "/FontName /" << psname << "_" << i << " def\n";
output << "/Encoding " << glyphs_per_descendant_font << " array\n";
for (size_t j = 0, pos = i * glyphs_per_descendant_font;
j < glyphs_per_descendant_font; ++j, ++pos) {
if (pos >= num_glyphs)
break;
output << ByteString::Format("dup %d /c%02x put\n", j, j);
}
output << "readonly def\n";
// Note: `bbox` is LTRB, while /FontBBox is LBRT. Writing it out as LTRB
// gets the correct values.
output << "/FontBBox [" << bbox.left << " " << bbox.top << " " << bbox.right
<< " " << bbox.bottom << "] def\n";
output << "/PaintType 0 def\n";
output << "/CharStrings " << glyphs_per_descendant_font + 1
<< " dict dup begin\n";
output << "/.notdef 0 def\n";
for (size_t j = 0, pos = i * glyphs_per_descendant_font;
j < glyphs_per_descendant_font; ++j, ++pos) {
if (pos >= num_glyphs)
break;
output << ByteString::Format("/c%02x %d def\n", j, pos);
}
output << "end readonly def\n";
output << "/sfnts " << psname << "_sfnts def\n";
output << "FontName currentdict end definefont pop\n";
}
output << "6 dict begin\n";
output << "/FontName /" << psname << " def\n";
output << "/FontType 0 def\n";
output << "/FontMatrix [1 0 0 1 0 0] def\n";
output << "/FMapType 2 def\n";
output << "/Encoding [\n";
for (size_t i = 0; i < descendant_font_count; ++i)
output << i << "\n";
output << "] def\n";
output << "/FDepVector [\n";
for (size_t i = 0; i < descendant_font_count; ++i)
output << "/" << psname << "_" << i << " findfont\n";
output << "] def\n";
output << "FontName currentdict end definefont pop\n";
output << "%%EndResource\n";
return ByteString(output);
}
ByteString GenerateType42FontData(const CFX_Font* font) {
const FXFT_FaceRec* font_face_rec = font->GetFaceRec();
if (!font_face_rec)
return ByteString();
const ByteString psname = font->GetPsName();
DCHECK(!psname.IsEmpty());
absl::optional<ByteString> sfnt_data =
GenerateType42SfntData(psname, font->GetFontSpan());
if (!sfnt_data.has_value())
return ByteString();
ByteString output = "%%BeginResource: font ";
output += psname;
output += "\n";
output += sfnt_data.value();
output += GenerateType42FontDictionary(psname, font->GetRawBBox().value(),
font_face_rec->num_glyphs,
kGlyphsPerDescendantFont);
return output;
}
} // namespace
struct CFX_PSRenderer::Glyph {
Glyph(CFX_Font* font, uint32_t glyph_index)
: font(font), glyph_index(glyph_index) {}
Glyph(const Glyph& other) = delete;
Glyph& operator=(const Glyph&) = delete;
~Glyph() = default;
UnownedPtr<CFX_Font> const font;
const uint32_t glyph_index;
absl::optional<std::array<float, 4>> adjust_matrix;
};
CFX_PSRenderer::FaxCompressResult::FaxCompressResult() = default;
CFX_PSRenderer::FaxCompressResult::FaxCompressResult(
FaxCompressResult&&) noexcept = default;
CFX_PSRenderer::FaxCompressResult& CFX_PSRenderer::FaxCompressResult::operator=(
FaxCompressResult&&) noexcept = default;
CFX_PSRenderer::FaxCompressResult::~FaxCompressResult() = default;
CFX_PSRenderer::PSCompressResult::PSCompressResult() = default;
CFX_PSRenderer::PSCompressResult::PSCompressResult(
PSCompressResult&&) noexcept = default;
CFX_PSRenderer::PSCompressResult& CFX_PSRenderer::PSCompressResult::operator=(
PSCompressResult&&) noexcept = default;
CFX_PSRenderer::PSCompressResult::~PSCompressResult() = default;
CFX_PSRenderer::CFX_PSRenderer(CFX_PSFontTracker* font_tracker,
const EncoderIface* encoder_iface)
: m_pFontTracker(font_tracker), m_pEncoderIface(encoder_iface) {
DCHECK(m_pFontTracker);
}
CFX_PSRenderer::~CFX_PSRenderer() {
EndRendering();
}
void CFX_PSRenderer::Init(const RetainPtr<IFX_RetainableWriteStream>& pStream,
RenderingLevel level,
int width,
int height) {
DCHECK(pStream);
m_Level = level;
m_pStream = pStream;
m_ClipBox.left = 0;
m_ClipBox.top = 0;
m_ClipBox.right = width;
m_ClipBox.bottom = height;
}
void CFX_PSRenderer::StartRendering() {
if (m_bInited)
return;
static const char kInitStr[] =
"\nsave\n/im/initmatrix load def\n"
"/n/newpath load def/m/moveto load def/l/lineto load def/c/curveto load "
"def/h/closepath load def\n"
"/f/fill load def/F/eofill load def/s/stroke load def/W/clip load "
"def/W*/eoclip load def\n"
"/rg/setrgbcolor load def/k/setcmykcolor load def\n"
"/J/setlinecap load def/j/setlinejoin load def/w/setlinewidth load "
"def/M/setmiterlimit load def/d/setdash load def\n"
"/q/gsave load def/Q/grestore load def/iM/imagemask load def\n"
"/Tj/show load def/Ff/findfont load def/Fs/scalefont load def/Sf/setfont "
"load def\n"
"/cm/concat load def/Cm/currentmatrix load def/mx/matrix load "
"def/sm/setmatrix load def\n";
WriteString(kInitStr);
m_bInited = true;
}
void CFX_PSRenderer::EndRendering() {
if (!m_bInited)
return;
WriteString("\nrestore\n");
m_bInited = false;
// Flush `m_PreambleOutput` if it is not empty.
std::streamoff preamble_pos = m_PreambleOutput.tellp();
if (preamble_pos > 0) {
m_pStream->WriteBlock(
{reinterpret_cast<const uint8_t*>(m_PreambleOutput.str().c_str()),
pdfium::base::checked_cast<size_t>(preamble_pos)});
m_PreambleOutput.str("");
}
// Flush `m_Output`. It's never empty because of the WriteString() call above.
m_pStream->WriteBlock(
{reinterpret_cast<const uint8_t*>(m_Output.str().c_str()),
pdfium::base::checked_cast<size_t>(std::streamoff(m_Output.tellp()))});
m_Output.str("");
}
void CFX_PSRenderer::SaveState() {
StartRendering();
WriteString("q\n");
m_ClipBoxStack.push_back(m_ClipBox);
}
void CFX_PSRenderer::RestoreState(bool bKeepSaved) {
StartRendering();
WriteString("Q\n");
if (bKeepSaved)
WriteString("q\n");
m_bColorSet = false;
m_bGraphStateSet = false;
if (m_ClipBoxStack.empty())
return;
m_ClipBox = m_ClipBoxStack.back();
if (!bKeepSaved)
m_ClipBoxStack.pop_back();
}
void CFX_PSRenderer::OutputPath(const CFX_Path& path,
const CFX_Matrix* pObject2Device) {
fxcrt::ostringstream buf;
size_t size = path.GetPoints().size();
for (size_t i = 0; i < size; i++) {
CFX_Path::Point::Type type = path.GetType(i);
bool closing = path.IsClosingFigure(i);
CFX_PointF pos = path.GetPoint(i);
if (pObject2Device)
pos = pObject2Device->Transform(pos);
buf << pos.x << " " << pos.y;
switch (type) {
case CFX_Path::Point::Type::kMove:
buf << " m ";
break;
case CFX_Path::Point::Type::kLine:
buf << " l ";
if (closing)
buf << "h ";
break;
case CFX_Path::Point::Type::kBezier: {
CFX_PointF pos1 = path.GetPoint(i + 1);
CFX_PointF pos2 = path.GetPoint(i + 2);
if (pObject2Device) {
pos1 = pObject2Device->Transform(pos1);
pos2 = pObject2Device->Transform(pos2);
}
buf << " " << pos1.x << " " << pos1.y << " " << pos2.x << " " << pos2.y
<< " c";
if (closing)
buf << " h";
buf << "\n";
i += 2;
break;
}
}
}
WriteStream(buf);
}
void CFX_PSRenderer::SetClip_PathFill(
const CFX_Path& path,
const CFX_Matrix* pObject2Device,
const CFX_FillRenderOptions& fill_options) {
StartRendering();
OutputPath(path, pObject2Device);
CFX_FloatRect rect = path.GetBoundingBox();
if (pObject2Device)
rect = pObject2Device->TransformRect(rect);
m_ClipBox.left = static_cast<int>(rect.left);
m_ClipBox.right = static_cast<int>(rect.left + rect.right);
m_ClipBox.top = static_cast<int>(rect.top + rect.bottom);
m_ClipBox.bottom = static_cast<int>(rect.bottom);
WriteString("W");
if (fill_options.fill_type != CFX_FillRenderOptions::FillType::kWinding)
WriteString("*");
WriteString(" n\n");
}
void CFX_PSRenderer::SetClip_PathStroke(const CFX_Path& path,
const CFX_Matrix* pObject2Device,
const CFX_GraphStateData* pGraphState) {
StartRendering();
SetGraphState(pGraphState);
fxcrt::ostringstream buf;
buf << "mx Cm [" << pObject2Device->a << " " << pObject2Device->b << " "
<< pObject2Device->c << " " << pObject2Device->d << " "
<< pObject2Device->e << " " << pObject2Device->f << "]cm ";
WriteStream(buf);
OutputPath(path, nullptr);
CFX_FloatRect rect = path.GetBoundingBoxForStrokePath(
pGraphState->m_LineWidth, pGraphState->m_MiterLimit);
m_ClipBox.Intersect(pObject2Device->TransformRect(rect).GetOuterRect());
WriteString("strokepath W n sm\n");
}
bool CFX_PSRenderer::DrawPath(const CFX_Path& path,
const CFX_Matrix* pObject2Device,
const CFX_GraphStateData* pGraphState,
uint32_t fill_color,
uint32_t stroke_color,
const CFX_FillRenderOptions& fill_options) {
StartRendering();
int fill_alpha = FXARGB_A(fill_color);
int stroke_alpha = FXARGB_A(stroke_color);
if (fill_alpha && fill_alpha < 255)
return false;
if (stroke_alpha && stroke_alpha < 255)
return false;
if (fill_alpha == 0 && stroke_alpha == 0)
return false;
if (stroke_alpha) {
SetGraphState(pGraphState);
if (pObject2Device) {
fxcrt::ostringstream buf;
buf << "mx Cm [" << pObject2Device->a << " " << pObject2Device->b << " "
<< pObject2Device->c << " " << pObject2Device->d << " "
<< pObject2Device->e << " " << pObject2Device->f << "]cm ";
WriteStream(buf);
}
}
OutputPath(path, stroke_alpha ? nullptr : pObject2Device);
if (fill_options.fill_type != CFX_FillRenderOptions::FillType::kNoFill &&
fill_alpha) {
SetColor(fill_color);
if (fill_options.fill_type == CFX_FillRenderOptions::FillType::kWinding) {
if (stroke_alpha)
WriteString("q f Q ");
else
WriteString("f");
} else if (fill_options.fill_type ==
CFX_FillRenderOptions::FillType::kEvenOdd) {
if (stroke_alpha)
WriteString("q F Q ");
else
WriteString("F");
}
}
if (stroke_alpha) {
SetColor(stroke_color);
WriteString("s");
if (pObject2Device)
WriteString(" sm");
}
WriteString("\n");
return true;
}
void CFX_PSRenderer::SetGraphState(const CFX_GraphStateData* pGraphState) {
fxcrt::ostringstream buf;
if (!m_bGraphStateSet ||
m_CurGraphState.m_LineCap != pGraphState->m_LineCap) {
buf << static_cast<int>(pGraphState->m_LineCap) << " J\n";
}
if (!m_bGraphStateSet ||
m_CurGraphState.m_DashArray != pGraphState->m_DashArray) {
buf << "[";
for (const auto& dash : pGraphState->m_DashArray)
buf << dash << " ";
buf << "]" << pGraphState->m_DashPhase << " d\n";
}
if (!m_bGraphStateSet ||
m_CurGraphState.m_LineJoin != pGraphState->m_LineJoin) {
buf << static_cast<int>(pGraphState->m_LineJoin) << " j\n";
}
if (!m_bGraphStateSet ||
m_CurGraphState.m_LineWidth != pGraphState->m_LineWidth) {
buf << pGraphState->m_LineWidth << " w\n";
}
if (!m_bGraphStateSet ||
m_CurGraphState.m_MiterLimit != pGraphState->m_MiterLimit) {
buf << pGraphState->m_MiterLimit << " M\n";
}
m_CurGraphState = *pGraphState;
m_bGraphStateSet = true;
WriteStream(buf);
}
bool CFX_PSRenderer::SetDIBits(const RetainPtr<CFX_DIBBase>& pSource,
uint32_t color,
int left,
int top) {
StartRendering();
CFX_Matrix matrix = CFX_RenderDevice::GetFlipMatrix(
pSource->GetWidth(), pSource->GetHeight(), left, top);
return DrawDIBits(pSource, color, matrix, FXDIB_ResampleOptions());
}
bool CFX_PSRenderer::StretchDIBits(const RetainPtr<CFX_DIBBase>& pSource,
uint32_t color,
int dest_left,
int dest_top,
int dest_width,
int dest_height,
const FXDIB_ResampleOptions& options) {
StartRendering();
CFX_Matrix matrix = CFX_RenderDevice::GetFlipMatrix(dest_width, dest_height,
dest_left, dest_top);
return DrawDIBits(pSource, color, matrix, options);
}
bool CFX_PSRenderer::DrawDIBits(const RetainPtr<CFX_DIBBase>& pSource,
uint32_t color,
const CFX_Matrix& matrix,
const FXDIB_ResampleOptions& options) {
StartRendering();
if ((matrix.a == 0 && matrix.b == 0) || (matrix.c == 0 && matrix.d == 0))
return true;
if (pSource->IsAlphaFormat())
return false;
int alpha = FXARGB_A(color);
if (pSource->IsMaskFormat() && (alpha < 255 || pSource->GetBPP() != 1))
return false;
WriteString("q\n");
fxcrt::ostringstream buf;
buf << "[" << matrix.a << " " << matrix.b << " " << matrix.c << " "
<< matrix.d << " " << matrix.e << " " << matrix.f << "]cm ";
const int width = pSource->GetWidth();
const int height = pSource->GetHeight();
buf << width << " " << height;
if (pSource->GetBPP() == 1 && !pSource->HasPalette()) {
FaxCompressResult compress_result = FaxCompressData(pSource);
if (compress_result.data.empty())
return false;
if (pSource->IsMaskFormat()) {
SetColor(color);
m_bColorSet = false;
buf << " true[";
} else {
buf << " 1[";
}
buf << width << " 0 0 -" << height << " 0 " << height
<< "]currentfile/ASCII85Decode filter ";
if (compress_result.compressed) {
buf << "<</K -1/EndOfBlock false/Columns " << width << "/Rows " << height
<< ">>/CCITTFaxDecode filter ";
}
if (pSource->IsMaskFormat())
buf << "iM\n";
else
buf << "false 1 colorimage\n";
WriteStream(buf);
WritePSBinary(compress_result.data);
} else {
CFX_DIBExtractor source_extractor(pSource);
RetainPtr<CFX_DIBBase> pConverted = source_extractor.GetBitmap();
if (!pConverted)
return false;
switch (pSource->GetFormat()) {
case FXDIB_Format::k1bppRgb:
case FXDIB_Format::kRgb32:
pConverted = pConverted->ConvertTo(FXDIB_Format::kRgb);
break;
case FXDIB_Format::k8bppRgb:
if (pSource->HasPalette())
pConverted = pConverted->ConvertTo(FXDIB_Format::kRgb);
break;
default:
break;
}
if (!pConverted) {
WriteString("\nQ\n");
return false;
}
int bpp = pConverted->GetBPP() / 8;
uint8_t* output_buf = nullptr;
size_t output_size = 0;
bool output_buf_is_owned = true;
absl::optional<PSCompressResult> compress_result;
ByteString filter;
if ((m_Level.value() == RenderingLevel::kLevel2 || options.bLossy) &&
m_pEncoderIface->pJpegEncodeFunc(pConverted, &output_buf,
&output_size)) {
filter = "/DCTDecode filter ";
} else {
int src_pitch = width * bpp;
output_size = height * src_pitch;
output_buf = FX_Alloc(uint8_t, output_size);
for (int row = 0; row < height; row++) {
const uint8_t* src_scan = pConverted->GetScanline(row).data();
uint8_t* dest_scan = output_buf + row * src_pitch;
if (bpp == 3) {
for (int col = 0; col < width; col++) {
*dest_scan++ = src_scan[2];
*dest_scan++ = src_scan[1];
*dest_scan++ = *src_scan;
src_scan += 3;
}
} else {
memcpy(dest_scan, src_scan, src_pitch);
}
}
compress_result = PSCompressData({output_buf, output_size});
if (compress_result.has_value()) {
FX_Free(output_buf);
output_buf_is_owned = false;
output_buf = compress_result.value().data.data();
output_size = compress_result.value().data.size();
filter = compress_result.value().filter;
}
}
buf << " 8[";
buf << width << " 0 0 -" << height << " 0 " << height << "]";
buf << "currentfile/ASCII85Decode filter ";
if (!filter.IsEmpty())
buf << filter;
buf << "false " << bpp;
buf << " colorimage\n";
WriteStream(buf);
WritePSBinary({output_buf, output_size});
if (output_buf_is_owned)
FX_Free(output_buf);
}
WriteString("\nQ\n");
return true;
}
void CFX_PSRenderer::SetColor(uint32_t color) {
if (m_bColorSet && m_LastColor == color)
return;
fxcrt::ostringstream buf;
buf << FXARGB_R(color) / 255.0 << " " << FXARGB_G(color) / 255.0 << " "
<< FXARGB_B(color) / 255.0 << " rg\n";
m_bColorSet = true;
m_LastColor = color;
WriteStream(buf);
}
void CFX_PSRenderer::FindPSFontGlyph(CFX_GlyphCache* pGlyphCache,
CFX_Font* pFont,
const TextCharPos& charpos,
int* ps_fontnum,
int* ps_glyphindex) {
for (size_t i = 0; i < m_PSFontList.size(); ++i) {
const Glyph& glyph = *m_PSFontList[i];
if (glyph.font == pFont && glyph.glyph_index == charpos.m_GlyphIndex &&
glyph.adjust_matrix.has_value() == charpos.m_bGlyphAdjust) {
bool found;
if (glyph.adjust_matrix.has_value()) {
constexpr float kEpsilon = 0.01f;
const auto& adjust_matrix = glyph.adjust_matrix.value();
found = fabs(adjust_matrix[0] - charpos.m_AdjustMatrix[0]) < kEpsilon &&
fabs(adjust_matrix[1] - charpos.m_AdjustMatrix[1]) < kEpsilon &&
fabs(adjust_matrix[2] - charpos.m_AdjustMatrix[2]) < kEpsilon &&
fabs(adjust_matrix[3] - charpos.m_AdjustMatrix[3]) < kEpsilon;
} else {
found = true;
}
if (found) {
*ps_fontnum = pdfium::base::checked_cast<int>(i / 256);
*ps_glyphindex = i % 256;
return;
}
}
}
m_PSFontList.push_back(std::make_unique<Glyph>(pFont, charpos.m_GlyphIndex));
*ps_fontnum =
pdfium::base::checked_cast<int>((m_PSFontList.size() - 1) / 256);
*ps_glyphindex = (m_PSFontList.size() - 1) % 256;
if (*ps_glyphindex == 0) {
fxcrt::ostringstream buf;
buf << "8 dict begin/FontType 3 def/FontMatrix[1 0 0 1 0 0]def\n"
"/FontBBox[0 0 0 0]def/Encoding 256 array def 0 1 255{Encoding "
"exch/.notdef put}for\n"
"/CharProcs 1 dict def CharProcs begin/.notdef {} def end\n"
"/BuildGlyph{1 0 -10 -10 10 10 setcachedevice exch/CharProcs get "
"exch 2 copy known not{pop/.notdef}if get exec}bind def\n"
"/BuildChar{1 index/Encoding get exch get 1 index/BuildGlyph get "
"exec}bind def\n"
"currentdict end\n";
buf << "/X" << *ps_fontnum << " exch definefont pop\n";
WriteStream(buf);
}
if (charpos.m_bGlyphAdjust) {
m_PSFontList.back()->adjust_matrix = std::array<float, 4>{
charpos.m_AdjustMatrix[0], charpos.m_AdjustMatrix[1],
charpos.m_AdjustMatrix[2], charpos.m_AdjustMatrix[3]};
}
CFX_Matrix matrix;
if (charpos.m_bGlyphAdjust) {
matrix =
CFX_Matrix(charpos.m_AdjustMatrix[0], charpos.m_AdjustMatrix[1],
charpos.m_AdjustMatrix[2], charpos.m_AdjustMatrix[3], 0, 0);
}
const CFX_Path* pPath = pGlyphCache->LoadGlyphPath(
pFont, charpos.m_GlyphIndex, charpos.m_FontCharWidth);
if (!pPath)
return;
CFX_Path TransformedPath(*pPath);
if (charpos.m_bGlyphAdjust)
TransformedPath.Transform(matrix);
fxcrt::ostringstream buf;
buf << "/X" << *ps_fontnum << " Ff/CharProcs get begin/" << *ps_glyphindex
<< "{n ";
for (size_t p = 0; p < TransformedPath.GetPoints().size(); p++) {
CFX_PointF point = TransformedPath.GetPoint(p);
switch (TransformedPath.GetType(p)) {
case CFX_Path::Point::Type::kMove: {
buf << point.x << " " << point.y << " m\n";
break;
}
case CFX_Path::Point::Type::kLine: {
buf << point.x << " " << point.y << " l\n";
break;
}
case CFX_Path::Point::Type::kBezier: {
CFX_PointF point1 = TransformedPath.GetPoint(p + 1);
CFX_PointF point2 = TransformedPath.GetPoint(p + 2);
buf << point.x << " " << point.y << " " << point1.x << " " << point1.y
<< " " << point2.x << " " << point2.y << " c\n";
p += 2;
break;
}
}
}
buf << "f}bind def end\n";
buf << "/X" << *ps_fontnum << " Ff/Encoding get " << *ps_glyphindex << "/"
<< *ps_glyphindex << " put\n";
WriteStream(buf);
}
void CFX_PSRenderer::DrawTextAsType3Font(int char_count,
const TextCharPos* char_pos,
CFX_Font* font,
float font_size,
fxcrt::ostringstream& buf) {
CFX_FontCache* pCache = CFX_GEModule::Get()->GetFontCache();
RetainPtr<CFX_GlyphCache> pGlyphCache = pCache->GetGlyphCache(font);
int last_fontnum = -1;
for (int i = 0; i < char_count; i++) {
int ps_fontnum;
int ps_glyphindex;
FindPSFontGlyph(pGlyphCache.Get(), font, char_pos[i], &ps_fontnum,
&ps_glyphindex);
if (last_fontnum != ps_fontnum) {
buf << "/X" << ps_fontnum << " Ff " << font_size << " Fs Sf ";
last_fontnum = ps_fontnum;
}
buf << char_pos[i].m_Origin.x << " " << char_pos[i].m_Origin.y << " m";
ByteString hex = ByteString::Format("<%02X>", ps_glyphindex);
buf << hex.AsStringView() << "Tj\n";
}
}
bool CFX_PSRenderer::DrawTextAsType42Font(int char_count,
const TextCharPos* char_pos,
CFX_Font* font,
float font_size,
fxcrt::ostringstream& buf) {
if (m_Level != RenderingLevel::kLevel3Type42 || !CanEmbed(font))
return false;
if (font->GetFontType() != CFX_Font::FontType::kCIDTrueType)
return false;
bool is_existing_font = m_pFontTracker->SeenFontObject(font);
if (!is_existing_font) {
ByteString font_data = GenerateType42FontData(font);
if (font_data.IsEmpty())
return false;
m_pFontTracker->AddFontObject(font);
WritePreambleString(font_data.AsStringView());
}
buf << "/" << font->GetPsName() << " " << font_size << " selectfont\n";
for (int i = 0; i < char_count; ++i) {
buf << char_pos[i].m_Origin.x << " " << char_pos[i].m_Origin.y << " m";
uint8_t hi = char_pos[i].m_GlyphIndex / 256;
uint8_t lo = char_pos[i].m_GlyphIndex % 256;
ByteString hex = ByteString::Format("<%02X%02X>", hi, lo);
buf << hex.AsStringView() << "Tj\n";
}
return true;
}
bool CFX_PSRenderer::DrawText(int nChars,
const TextCharPos* pCharPos,
CFX_Font* pFont,
const CFX_Matrix& mtObject2Device,
float font_size,
uint32_t color) {
// Check object to device matrix first, since it can scale the font size.
if ((mtObject2Device.a == 0 && mtObject2Device.b == 0) ||
(mtObject2Device.c == 0 && mtObject2Device.d == 0)) {
return true;
}
// Do not send near zero font sizes to printers. See crbug.com/767343.
float scale =
std::min(mtObject2Device.GetXUnit(), mtObject2Device.GetYUnit());
static constexpr float kEpsilon = 0.01f;
if (fabsf(font_size * scale) < kEpsilon)
return true;
StartRendering();
int alpha = FXARGB_A(color);
if (alpha < 255)
return false;
SetColor(color);
fxcrt::ostringstream buf;
buf << "q[" << mtObject2Device.a << " " << mtObject2Device.b << " "
<< mtObject2Device.c << " " << mtObject2Device.d << " "
<< mtObject2Device.e << " " << mtObject2Device.f << "]cm\n";
if (!DrawTextAsType42Font(nChars, pCharPos, pFont, font_size, buf)) {
DrawTextAsType3Font(nChars, pCharPos, pFont, font_size, buf);
}
buf << "Q\n";
WriteStream(buf);
return true;
}
CFX_PSRenderer::FaxCompressResult CFX_PSRenderer::FaxCompressData(
RetainPtr<CFX_DIBBase> src) const {
DCHECK_EQ(1, src->GetBPP());
FaxCompressResult result;
const int width = src->GetWidth();
const int height = src->GetHeight();
const int pitch = src->GetPitch();
DCHECK_GE(width, pitch);
FX_SAFE_UINT32 safe_pixel_count = width;
safe_pixel_count *= height;
if (!safe_pixel_count.IsValid())
return result;
if (safe_pixel_count.ValueOrDie() > 128) {
result.data = m_pEncoderIface->pFaxEncodeFunc(std::move(src));
result.compressed = true;
return result;
}
FX_SAFE_UINT32 safe_size = pitch;
safe_size *= height;
result.data.resize(safe_size.ValueOrDie());
auto dest_span = pdfium::make_span(result.data);
for (int row = 0; row < height; row++) {
pdfium::span<const uint8_t> src_scan = src->GetScanline(row);
fxcrt::spancpy(dest_span.subspan(row * pitch, pitch), src_scan);
}
return result;
}
absl::optional<CFX_PSRenderer::PSCompressResult> CFX_PSRenderer::PSCompressData(
pdfium::span<const uint8_t> src_span) const {
if (src_span.size() < 1024)
return absl::nullopt;
DataVector<uint8_t> (*encode_func)(pdfium::span<const uint8_t> src_span);
ByteString filter;
if (m_Level.value() == RenderingLevel::kLevel3 ||
m_Level.value() == RenderingLevel::kLevel3Type42) {
encode_func = m_pEncoderIface->pFlateEncodeFunc;
filter = "/FlateDecode filter ";
} else {
encode_func = m_pEncoderIface->pRunLengthEncodeFunc;
filter = "/RunLengthDecode filter ";
}
DataVector<uint8_t> decode_result = encode_func(src_span);
if (decode_result.size() == 0 || decode_result.size() >= src_span.size())
return absl::nullopt;
PSCompressResult result;
result.data = std::move(decode_result);
result.filter = filter;
return result;
}
void CFX_PSRenderer::WritePreambleString(ByteStringView str) {
m_PreambleOutput << str;
}
void CFX_PSRenderer::WritePSBinary(pdfium::span<const uint8_t> data) {
DataVector<uint8_t> encoded_data = m_pEncoderIface->pA85EncodeFunc(data);
pdfium::span<const uint8_t> result =
encoded_data.empty() ? data : encoded_data;
m_Output.write(reinterpret_cast<const char*>(result.data()), result.size());
}
void CFX_PSRenderer::WriteStream(fxcrt::ostringstream& stream) {
std::streamoff output_pos = stream.tellp();
if (output_pos > 0) {
m_Output.write(stream.str().c_str(),
pdfium::base::checked_cast<size_t>(output_pos));
}
}
void CFX_PSRenderer::WriteString(ByteStringView str) {
m_Output << str;
}
// static
absl::optional<ByteString> CFX_PSRenderer::GenerateType42SfntDataForTesting(
const ByteString& psname,
pdfium::span<const uint8_t> font_data) {
return GenerateType42SfntData(psname, font_data);
}
// static
ByteString CFX_PSRenderer::GenerateType42FontDictionaryForTesting(
const ByteString& psname,
const FX_RECT& bbox,
size_t num_glyphs,
size_t glyphs_per_descendant_font) {
return GenerateType42FontDictionary(psname, bbox, num_glyphs,
glyphs_per_descendant_font);
}