summaryrefslogtreecommitdiff
path: root/core/fpdfapi/page
diff options
context:
space:
mode:
authortsepez <tsepez@chromium.org>2016-10-13 11:29:04 -0700
committerCommit bot <commit-bot@chromium.org>2016-10-13 11:29:04 -0700
commit271d9c0a85b50208baa8789ba6b245956317f719 (patch)
tree5202284e527cd2bdcd7bcd22495018c9fbff1fd5 /core/fpdfapi/page
parentaeb44f8c4675141e170329d5093b251fbfad8023 (diff)
downloadpdfium-271d9c0a85b50208baa8789ba6b245956317f719.tar.xz
Put CPDF_StreamContentParser into its own .cpp/.h files
No functional changes. Make many of its methods private. Review-Url: https://codereview.chromium.org/2415943003
Diffstat (limited to 'core/fpdfapi/page')
-rw-r--r--core/fpdfapi/page/cpdf_streamcontentparser.cpp1561
-rw-r--r--core/fpdfapi/page/cpdf_streamcontentparser.h225
-rw-r--r--core/fpdfapi/page/fpdf_page_parser.cpp1525
-rw-r--r--core/fpdfapi/page/pageint.h195
4 files changed, 1787 insertions, 1719 deletions
diff --git a/core/fpdfapi/page/cpdf_streamcontentparser.cpp b/core/fpdfapi/page/cpdf_streamcontentparser.cpp
new file mode 100644
index 0000000000..60c9b527a3
--- /dev/null
+++ b/core/fpdfapi/page/cpdf_streamcontentparser.cpp
@@ -0,0 +1,1561 @@
+// 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/fpdfapi/page/cpdf_streamcontentparser.h"
+
+#include "core/fpdfapi/font/cpdf_font.h"
+#include "core/fpdfapi/font/cpdf_type3font.h"
+#include "core/fpdfapi/page/cpdf_allstates.h"
+#include "core/fpdfapi/page/cpdf_docpagedata.h"
+#include "core/fpdfapi/page/cpdf_form.h"
+#include "core/fpdfapi/page/cpdf_formobject.h"
+#include "core/fpdfapi/page/cpdf_image.h"
+#include "core/fpdfapi/page/cpdf_imageobject.h"
+#include "core/fpdfapi/page/cpdf_meshstream.h"
+#include "core/fpdfapi/page/cpdf_pageobject.h"
+#include "core/fpdfapi/page/cpdf_pathobject.h"
+#include "core/fpdfapi/page/cpdf_shadingobject.h"
+#include "core/fpdfapi/page/cpdf_shadingpattern.h"
+#include "core/fpdfapi/page/cpdf_textobject.h"
+#include "core/fpdfapi/page/pageint.h"
+#include "core/fpdfapi/parser/cpdf_array.h"
+#include "core/fpdfapi/parser/cpdf_document.h"
+#include "core/fpdfapi/parser/cpdf_name.h"
+#include "core/fpdfapi/parser/cpdf_number.h"
+#include "core/fpdfapi/parser/fpdf_parser_decode.h"
+#include "core/fxcrt/fx_safe_types.h"
+#include "third_party/base/ptr_util.h"
+
+namespace {
+
+const int kMaxFormLevel = 30;
+
+const int kSingleCoordinatePair = 1;
+const int kTensorCoordinatePairs = 16;
+const int kCoonsCoordinatePairs = 12;
+const int kSingleColorPerPatch = 1;
+const int kQuadColorsPerPatch = 4;
+
+const char kPathOperatorSubpath = 'm';
+const char kPathOperatorLine = 'l';
+const char kPathOperatorCubicBezier1 = 'c';
+const char kPathOperatorCubicBezier2 = 'v';
+const char kPathOperatorCubicBezier3 = 'y';
+const char kPathOperatorClosePath = 'h';
+const char kPathOperatorRectangle[] = "re";
+
+class CPDF_StreamParserAutoClearer {
+ public:
+ CPDF_StreamParserAutoClearer(CPDF_StreamParser** scoped_variable,
+ CPDF_StreamParser* new_parser)
+ : scoped_variable_(scoped_variable) {
+ *scoped_variable_ = new_parser;
+ }
+ ~CPDF_StreamParserAutoClearer() { *scoped_variable_ = nullptr; }
+
+ private:
+ CPDF_StreamParser** scoped_variable_;
+};
+
+CFX_FloatRect GetShadingBBox(CPDF_ShadingPattern* pShading,
+ const CFX_Matrix& matrix) {
+ ShadingType type = pShading->GetShadingType();
+ CPDF_Stream* pStream = ToStream(pShading->GetShadingObject());
+ CPDF_ColorSpace* pCS = pShading->GetCS();
+ if (!pStream || !pCS)
+ return CFX_FloatRect(0, 0, 0, 0);
+
+ CPDF_MeshStream stream(type, pShading->GetFuncs(), pStream, pCS);
+ if (!stream.Load())
+ return CFX_FloatRect(0, 0, 0, 0);
+
+ CFX_FloatRect rect;
+ bool bStarted = false;
+ bool bGouraud = type == kFreeFormGouraudTriangleMeshShading ||
+ type == kLatticeFormGouraudTriangleMeshShading;
+
+ int point_count = kSingleCoordinatePair;
+ if (type == kTensorProductPatchMeshShading)
+ point_count = kTensorCoordinatePairs;
+ else if (type == kCoonsPatchMeshShading)
+ point_count = kCoonsCoordinatePairs;
+
+ int color_count = kSingleColorPerPatch;
+ if (type == kCoonsPatchMeshShading || type == kTensorProductPatchMeshShading)
+ color_count = kQuadColorsPerPatch;
+
+ while (!stream.BitStream()->IsEOF()) {
+ uint32_t flag = 0;
+ if (type != kLatticeFormGouraudTriangleMeshShading)
+ flag = stream.GetFlag();
+
+ if (!bGouraud && flag) {
+ point_count -= 4;
+ color_count -= 2;
+ }
+
+ for (int i = 0; i < point_count; i++) {
+ FX_FLOAT x;
+ FX_FLOAT y;
+ stream.GetCoords(x, y);
+ if (bStarted) {
+ rect.UpdateRect(x, y);
+ } else {
+ rect.InitRect(x, y);
+ bStarted = true;
+ }
+ }
+ FX_SAFE_UINT32 nBits = stream.Components();
+ nBits *= stream.ComponentBits();
+ nBits *= color_count;
+ if (!nBits.IsValid())
+ break;
+
+ stream.BitStream()->SkipBits(nBits.ValueOrDie());
+ if (bGouraud)
+ stream.BitStream()->ByteAlign();
+ }
+ rect.Transform(&matrix);
+ return rect;
+}
+
+} // namespace
+
+CPDF_StreamContentParser::CPDF_StreamContentParser(
+ CPDF_Document* pDocument,
+ CPDF_Dictionary* pPageResources,
+ CPDF_Dictionary* pParentResources,
+ const CFX_Matrix* pmtContentToUser,
+ CPDF_PageObjectHolder* pObjHolder,
+ CPDF_Dictionary* pResources,
+ CFX_FloatRect* pBBox,
+ CPDF_AllStates* pStates,
+ int level)
+ : m_pDocument(pDocument),
+ m_pPageResources(pPageResources),
+ m_pParentResources(pParentResources),
+ m_pResources(pResources),
+ m_pObjectHolder(pObjHolder),
+ m_Level(level),
+ m_ParamStartPos(0),
+ m_ParamCount(0),
+ m_pCurStates(new CPDF_AllStates),
+ m_pLastTextObject(nullptr),
+ m_DefFontSize(0),
+ m_pPathPoints(nullptr),
+ m_PathPointCount(0),
+ m_PathAllocSize(0),
+ m_PathCurrentX(0.0f),
+ m_PathCurrentY(0.0f),
+ m_PathClipType(0),
+ m_pLastImage(nullptr),
+ m_pLastImageDict(nullptr),
+ m_pLastCloneImageDict(nullptr),
+ m_bColored(false),
+ m_bResourceMissing(false) {
+ if (pmtContentToUser)
+ m_mtContentToUser = *pmtContentToUser;
+ if (!m_pResources)
+ m_pResources = m_pParentResources;
+ if (!m_pResources)
+ m_pResources = m_pPageResources;
+ if (pBBox)
+ m_BBox = *pBBox;
+ if (pStates) {
+ m_pCurStates->Copy(*pStates);
+ } else {
+ m_pCurStates->m_GeneralState.Emplace();
+ m_pCurStates->m_GraphState.Emplace();
+ m_pCurStates->m_TextState.Emplace();
+ m_pCurStates->m_ColorState.Emplace();
+ }
+ for (size_t i = 0; i < FX_ArraySize(m_Type3Data); ++i) {
+ m_Type3Data[i] = 0.0;
+ }
+}
+
+CPDF_StreamContentParser::~CPDF_StreamContentParser() {
+ ClearAllParams();
+ FX_Free(m_pPathPoints);
+ if (m_pLastImageDict) {
+ m_pLastImageDict->Release();
+ }
+ if (m_pLastCloneImageDict) {
+ m_pLastCloneImageDict->Release();
+ }
+}
+
+int CPDF_StreamContentParser::GetNextParamPos() {
+ if (m_ParamCount == kParamBufSize) {
+ m_ParamStartPos++;
+ if (m_ParamStartPos == kParamBufSize) {
+ m_ParamStartPos = 0;
+ }
+ if (m_ParamBuf[m_ParamStartPos].m_Type == 0) {
+ if (CPDF_Object* pObject = m_ParamBuf[m_ParamStartPos].m_pObject)
+ pObject->Release();
+ }
+ return m_ParamStartPos;
+ }
+ int index = m_ParamStartPos + m_ParamCount;
+ if (index >= kParamBufSize) {
+ index -= kParamBufSize;
+ }
+ m_ParamCount++;
+ return index;
+}
+
+void CPDF_StreamContentParser::AddNameParam(const FX_CHAR* name, int len) {
+ CFX_ByteStringC bsName(name, len);
+ ContentParam& param = m_ParamBuf[GetNextParamPos()];
+ if (len > 32) {
+ param.m_Type = ContentParam::OBJECT;
+ param.m_pObject = new CPDF_Name(
+ m_pDocument->GetByteStringPool()->Intern(PDF_NameDecode(bsName)));
+ } else {
+ param.m_Type = ContentParam::NAME;
+ if (bsName.Find('#') == -1) {
+ FXSYS_memcpy(param.m_Name.m_Buffer, name, len);
+ param.m_Name.m_Len = len;
+ } else {
+ CFX_ByteString str = PDF_NameDecode(bsName);
+ FXSYS_memcpy(param.m_Name.m_Buffer, str.c_str(), str.GetLength());
+ param.m_Name.m_Len = str.GetLength();
+ }
+ }
+}
+
+void CPDF_StreamContentParser::AddNumberParam(const FX_CHAR* str, int len) {
+ ContentParam& param = m_ParamBuf[GetNextParamPos()];
+ param.m_Type = ContentParam::NUMBER;
+ param.m_Number.m_bInteger =
+ FX_atonum(CFX_ByteStringC(str, len), &param.m_Number.m_Integer);
+}
+
+void CPDF_StreamContentParser::AddObjectParam(CPDF_Object* pObj) {
+ ContentParam& param = m_ParamBuf[GetNextParamPos()];
+ param.m_Type = ContentParam::OBJECT;
+ param.m_pObject = pObj;
+}
+
+void CPDF_StreamContentParser::ClearAllParams() {
+ uint32_t index = m_ParamStartPos;
+ for (uint32_t i = 0; i < m_ParamCount; i++) {
+ if (m_ParamBuf[index].m_Type == 0) {
+ if (CPDF_Object* pObject = m_ParamBuf[index].m_pObject)
+ pObject->Release();
+ }
+ index++;
+ if (index == kParamBufSize) {
+ index = 0;
+ }
+ }
+ m_ParamStartPos = 0;
+ m_ParamCount = 0;
+}
+
+CPDF_Object* CPDF_StreamContentParser::GetObject(uint32_t index) {
+ if (index >= m_ParamCount) {
+ return nullptr;
+ }
+ int real_index = m_ParamStartPos + m_ParamCount - index - 1;
+ if (real_index >= kParamBufSize) {
+ real_index -= kParamBufSize;
+ }
+ ContentParam& param = m_ParamBuf[real_index];
+ if (param.m_Type == ContentParam::NUMBER) {
+ CPDF_Number* pNumber = param.m_Number.m_bInteger
+ ? new CPDF_Number(param.m_Number.m_Integer)
+ : new CPDF_Number(param.m_Number.m_Float);
+
+ param.m_Type = ContentParam::OBJECT;
+ param.m_pObject = pNumber;
+ return pNumber;
+ }
+ if (param.m_Type == ContentParam::NAME) {
+ CPDF_Name* pName = new CPDF_Name(m_pDocument->GetByteStringPool()->Intern(
+ CFX_ByteString(param.m_Name.m_Buffer, param.m_Name.m_Len)));
+ param.m_Type = ContentParam::OBJECT;
+ param.m_pObject = pName;
+ return pName;
+ }
+ if (param.m_Type == ContentParam::OBJECT) {
+ return param.m_pObject;
+ }
+ ASSERT(FALSE);
+ return nullptr;
+}
+
+CFX_ByteString CPDF_StreamContentParser::GetString(uint32_t index) {
+ if (index >= m_ParamCount) {
+ return CFX_ByteString();
+ }
+ int real_index = m_ParamStartPos + m_ParamCount - index - 1;
+ if (real_index >= kParamBufSize) {
+ real_index -= kParamBufSize;
+ }
+ ContentParam& param = m_ParamBuf[real_index];
+ if (param.m_Type == ContentParam::NAME) {
+ return CFX_ByteString(param.m_Name.m_Buffer, param.m_Name.m_Len);
+ }
+ if (param.m_Type == 0 && param.m_pObject) {
+ return param.m_pObject->GetString();
+ }
+ return CFX_ByteString();
+}
+
+FX_FLOAT CPDF_StreamContentParser::GetNumber(uint32_t index) {
+ if (index >= m_ParamCount) {
+ return 0;
+ }
+ int real_index = m_ParamStartPos + m_ParamCount - index - 1;
+ if (real_index >= kParamBufSize) {
+ real_index -= kParamBufSize;
+ }
+ ContentParam& param = m_ParamBuf[real_index];
+ if (param.m_Type == ContentParam::NUMBER) {
+ return param.m_Number.m_bInteger ? (FX_FLOAT)param.m_Number.m_Integer
+ : param.m_Number.m_Float;
+ }
+ if (param.m_Type == 0 && param.m_pObject) {
+ return param.m_pObject->GetNumber();
+ }
+ return 0;
+}
+
+void CPDF_StreamContentParser::SetGraphicStates(CPDF_PageObject* pObj,
+ bool bColor,
+ bool bText,
+ bool bGraph) {
+ pObj->m_GeneralState = m_pCurStates->m_GeneralState;
+ pObj->m_ClipPath = m_pCurStates->m_ClipPath;
+ pObj->m_ContentMark = m_CurContentMark;
+ if (bColor) {
+ pObj->m_ColorState = m_pCurStates->m_ColorState;
+ }
+ if (bGraph) {
+ pObj->m_GraphState = m_pCurStates->m_GraphState;
+ }
+ if (bText) {
+ pObj->m_TextState = m_pCurStates->m_TextState;
+ }
+}
+
+// static
+CPDF_StreamContentParser::OpCodes
+CPDF_StreamContentParser::InitializeOpCodes() {
+ return OpCodes({
+ {FXBSTR_ID('"', 0, 0, 0),
+ &CPDF_StreamContentParser::Handle_NextLineShowText_Space},
+ {FXBSTR_ID('\'', 0, 0, 0),
+ &CPDF_StreamContentParser::Handle_NextLineShowText},
+ {FXBSTR_ID('B', 0, 0, 0),
+ &CPDF_StreamContentParser::Handle_FillStrokePath},
+ {FXBSTR_ID('B', '*', 0, 0),
+ &CPDF_StreamContentParser::Handle_EOFillStrokePath},
+ {FXBSTR_ID('B', 'D', 'C', 0),
+ &CPDF_StreamContentParser::Handle_BeginMarkedContent_Dictionary},
+ {FXBSTR_ID('B', 'I', 0, 0), &CPDF_StreamContentParser::Handle_BeginImage},
+ {FXBSTR_ID('B', 'M', 'C', 0),
+ &CPDF_StreamContentParser::Handle_BeginMarkedContent},
+ {FXBSTR_ID('B', 'T', 0, 0), &CPDF_StreamContentParser::Handle_BeginText},
+ {FXBSTR_ID('C', 'S', 0, 0),
+ &CPDF_StreamContentParser::Handle_SetColorSpace_Stroke},
+ {FXBSTR_ID('D', 'P', 0, 0),
+ &CPDF_StreamContentParser::Handle_MarkPlace_Dictionary},
+ {FXBSTR_ID('D', 'o', 0, 0),
+ &CPDF_StreamContentParser::Handle_ExecuteXObject},
+ {FXBSTR_ID('E', 'I', 0, 0), &CPDF_StreamContentParser::Handle_EndImage},
+ {FXBSTR_ID('E', 'M', 'C', 0),
+ &CPDF_StreamContentParser::Handle_EndMarkedContent},
+ {FXBSTR_ID('E', 'T', 0, 0), &CPDF_StreamContentParser::Handle_EndText},
+ {FXBSTR_ID('F', 0, 0, 0), &CPDF_StreamContentParser::Handle_FillPathOld},
+ {FXBSTR_ID('G', 0, 0, 0),
+ &CPDF_StreamContentParser::Handle_SetGray_Stroke},
+ {FXBSTR_ID('I', 'D', 0, 0),
+ &CPDF_StreamContentParser::Handle_BeginImageData},
+ {FXBSTR_ID('J', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineCap},
+ {FXBSTR_ID('K', 0, 0, 0),
+ &CPDF_StreamContentParser::Handle_SetCMYKColor_Stroke},
+ {FXBSTR_ID('M', 0, 0, 0),
+ &CPDF_StreamContentParser::Handle_SetMiterLimit},
+ {FXBSTR_ID('M', 'P', 0, 0), &CPDF_StreamContentParser::Handle_MarkPlace},
+ {FXBSTR_ID('Q', 0, 0, 0),
+ &CPDF_StreamContentParser::Handle_RestoreGraphState},
+ {FXBSTR_ID('R', 'G', 0, 0),
+ &CPDF_StreamContentParser::Handle_SetRGBColor_Stroke},
+ {FXBSTR_ID('S', 0, 0, 0), &CPDF_StreamContentParser::Handle_StrokePath},
+ {FXBSTR_ID('S', 'C', 0, 0),
+ &CPDF_StreamContentParser::Handle_SetColor_Stroke},
+ {FXBSTR_ID('S', 'C', 'N', 0),
+ &CPDF_StreamContentParser::Handle_SetColorPS_Stroke},
+ {FXBSTR_ID('T', '*', 0, 0),
+ &CPDF_StreamContentParser::Handle_MoveToNextLine},
+ {FXBSTR_ID('T', 'D', 0, 0),
+ &CPDF_StreamContentParser::Handle_MoveTextPoint_SetLeading},
+ {FXBSTR_ID('T', 'J', 0, 0),
+ &CPDF_StreamContentParser::Handle_ShowText_Positioning},
+ {FXBSTR_ID('T', 'L', 0, 0),
+ &CPDF_StreamContentParser::Handle_SetTextLeading},
+ {FXBSTR_ID('T', 'c', 0, 0),
+ &CPDF_StreamContentParser::Handle_SetCharSpace},
+ {FXBSTR_ID('T', 'd', 0, 0),
+ &CPDF_StreamContentParser::Handle_MoveTextPoint},
+ {FXBSTR_ID('T', 'f', 0, 0), &CPDF_StreamContentParser::Handle_SetFont},
+ {FXBSTR_ID('T', 'j', 0, 0), &CPDF_StreamContentParser::Handle_ShowText},
+ {FXBSTR_ID('T', 'm', 0, 0),
+ &CPDF_StreamContentParser::Handle_SetTextMatrix},
+ {FXBSTR_ID('T', 'r', 0, 0),
+ &CPDF_StreamContentParser::Handle_SetTextRenderMode},
+ {FXBSTR_ID('T', 's', 0, 0),
+ &CPDF_StreamContentParser::Handle_SetTextRise},
+ {FXBSTR_ID('T', 'w', 0, 0),
+ &CPDF_StreamContentParser::Handle_SetWordSpace},
+ {FXBSTR_ID('T', 'z', 0, 0),
+ &CPDF_StreamContentParser::Handle_SetHorzScale},
+ {FXBSTR_ID('W', 0, 0, 0), &CPDF_StreamContentParser::Handle_Clip},
+ {FXBSTR_ID('W', '*', 0, 0), &CPDF_StreamContentParser::Handle_EOClip},
+ {FXBSTR_ID('b', 0, 0, 0),
+ &CPDF_StreamContentParser::Handle_CloseFillStrokePath},
+ {FXBSTR_ID('b', '*', 0, 0),
+ &CPDF_StreamContentParser::Handle_CloseEOFillStrokePath},
+ {FXBSTR_ID('c', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_123},
+ {FXBSTR_ID('c', 'm', 0, 0),
+ &CPDF_StreamContentParser::Handle_ConcatMatrix},
+ {FXBSTR_ID('c', 's', 0, 0),
+ &CPDF_StreamContentParser::Handle_SetColorSpace_Fill},
+ {FXBSTR_ID('d', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetDash},
+ {FXBSTR_ID('d', '0', 0, 0),
+ &CPDF_StreamContentParser::Handle_SetCharWidth},
+ {FXBSTR_ID('d', '1', 0, 0),
+ &CPDF_StreamContentParser::Handle_SetCachedDevice},
+ {FXBSTR_ID('f', 0, 0, 0), &CPDF_StreamContentParser::Handle_FillPath},
+ {FXBSTR_ID('f', '*', 0, 0), &CPDF_StreamContentParser::Handle_EOFillPath},
+ {FXBSTR_ID('g', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetGray_Fill},
+ {FXBSTR_ID('g', 's', 0, 0),
+ &CPDF_StreamContentParser::Handle_SetExtendGraphState},
+ {FXBSTR_ID('h', 0, 0, 0), &CPDF_StreamContentParser::Handle_ClosePath},
+ {FXBSTR_ID('i', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetFlat},
+ {FXBSTR_ID('j', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineJoin},
+ {FXBSTR_ID('k', 0, 0, 0),
+ &CPDF_StreamContentParser::Handle_SetCMYKColor_Fill},
+ {FXBSTR_ID('l', 0, 0, 0), &CPDF_StreamContentParser::Handle_LineTo},
+ {FXBSTR_ID('m', 0, 0, 0), &CPDF_StreamContentParser::Handle_MoveTo},
+ {FXBSTR_ID('n', 0, 0, 0), &CPDF_StreamContentParser::Handle_EndPath},
+ {FXBSTR_ID('q', 0, 0, 0),
+ &CPDF_StreamContentParser::Handle_SaveGraphState},
+ {FXBSTR_ID('r', 'e', 0, 0), &CPDF_StreamContentParser::Handle_Rectangle},
+ {FXBSTR_ID('r', 'g', 0, 0),
+ &CPDF_StreamContentParser::Handle_SetRGBColor_Fill},
+ {FXBSTR_ID('r', 'i', 0, 0),
+ &CPDF_StreamContentParser::Handle_SetRenderIntent},
+ {FXBSTR_ID('s', 0, 0, 0),
+ &CPDF_StreamContentParser::Handle_CloseStrokePath},
+ {FXBSTR_ID('s', 'c', 0, 0),
+ &CPDF_StreamContentParser::Handle_SetColor_Fill},
+ {FXBSTR_ID('s', 'c', 'n', 0),
+ &CPDF_StreamContentParser::Handle_SetColorPS_Fill},
+ {FXBSTR_ID('s', 'h', 0, 0), &CPDF_StreamContentParser::Handle_ShadeFill},
+ {FXBSTR_ID('v', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_23},
+ {FXBSTR_ID('w', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineWidth},
+ {FXBSTR_ID('y', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_13},
+ });
+}
+
+void CPDF_StreamContentParser::OnOperator(const FX_CHAR* op) {
+ int i = 0;
+ uint32_t opid = 0;
+ while (i < 4 && op[i]) {
+ opid = (opid << 8) + op[i];
+ i++;
+ }
+ while (i < 4) {
+ opid <<= 8;
+ i++;
+ }
+
+ static const OpCodes s_OpCodes = InitializeOpCodes();
+
+ auto it = s_OpCodes.find(opid);
+ if (it != s_OpCodes.end())
+ (this->*it->second)();
+}
+
+void CPDF_StreamContentParser::Handle_CloseFillStrokePath() {
+ Handle_ClosePath();
+ AddPathObject(FXFILL_WINDING, true);
+}
+
+void CPDF_StreamContentParser::Handle_FillStrokePath() {
+ AddPathObject(FXFILL_WINDING, true);
+}
+
+void CPDF_StreamContentParser::Handle_CloseEOFillStrokePath() {
+ AddPathPoint(m_PathStartX, m_PathStartY, FXPT_LINETO | FXPT_CLOSEFIGURE);
+ AddPathObject(FXFILL_ALTERNATE, true);
+}
+
+void CPDF_StreamContentParser::Handle_EOFillStrokePath() {
+ AddPathObject(FXFILL_ALTERNATE, true);
+}
+
+void CPDF_StreamContentParser::Handle_BeginMarkedContent_Dictionary() {
+ CFX_ByteString tag = GetString(1);
+ CPDF_Object* pProperty = GetObject(0);
+ if (!pProperty) {
+ return;
+ }
+ bool bDirect = true;
+ if (pProperty->IsName()) {
+ pProperty = FindResourceObj("Properties", pProperty->GetString());
+ if (!pProperty)
+ return;
+ bDirect = false;
+ }
+ if (CPDF_Dictionary* pDict = pProperty->AsDictionary()) {
+ m_CurContentMark.AddMark(tag, pDict, bDirect);
+ }
+}
+
+void CPDF_StreamContentParser::Handle_BeginImage() {
+ FX_FILESIZE savePos = m_pSyntax->GetPos();
+ CPDF_Dictionary* pDict =
+ new CPDF_Dictionary(m_pDocument->GetByteStringPool());
+ while (1) {
+ CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
+ if (type == CPDF_StreamParser::Keyword) {
+ CFX_ByteString bsKeyword(m_pSyntax->GetWordBuf(),
+ m_pSyntax->GetWordSize());
+ if (bsKeyword != "ID") {
+ m_pSyntax->SetPos(savePos);
+ pDict->Release();
+ return;
+ }
+ }
+ if (type != CPDF_StreamParser::Name) {
+ break;
+ }
+ CFX_ByteString key((const FX_CHAR*)m_pSyntax->GetWordBuf() + 1,
+ m_pSyntax->GetWordSize() - 1);
+ std::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> pObj(
+ m_pSyntax->ReadNextObject(false, 0));
+ if (!key.IsEmpty()) {
+ uint32_t dwObjNum = pObj ? pObj->GetObjNum() : 0;
+ if (dwObjNum)
+ pDict->SetReferenceFor(key, m_pDocument, dwObjNum);
+ else
+ pDict->SetFor(key, pObj.release());
+ }
+ }
+ PDF_ReplaceAbbr(pDict);
+ CPDF_Object* pCSObj = nullptr;
+ if (pDict->KeyExist("ColorSpace")) {
+ pCSObj = pDict->GetDirectObjectFor("ColorSpace");
+ if (pCSObj->IsName()) {
+ CFX_ByteString name = pCSObj->GetString();
+ if (name != "DeviceRGB" && name != "DeviceGray" && name != "DeviceCMYK") {
+ pCSObj = FindResourceObj("ColorSpace", name);
+ if (pCSObj && pCSObj->IsInline()) {
+ pCSObj = pCSObj->Clone();
+ pDict->SetFor("ColorSpace", pCSObj);
+ }
+ }
+ }
+ }
+ pDict->SetNameFor("Subtype", "Image");
+ UniqueStream pStream(m_pSyntax->ReadInlineStream(m_pDocument, pDict, pCSObj));
+ bool bGaveDictAway = !!pStream;
+ while (1) {
+ CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
+ if (type == CPDF_StreamParser::EndOfData) {
+ break;
+ }
+ if (type != CPDF_StreamParser::Keyword) {
+ continue;
+ }
+ if (m_pSyntax->GetWordSize() == 2 && m_pSyntax->GetWordBuf()[0] == 'E' &&
+ m_pSyntax->GetWordBuf()[1] == 'I') {
+ break;
+ }
+ }
+ CPDF_ImageObject* pImgObj = AddImage(std::move(pStream));
+ if (!pImgObj && !bGaveDictAway)
+ pDict->Release();
+}
+
+void CPDF_StreamContentParser::Handle_BeginMarkedContent() {
+ m_CurContentMark.AddMark(GetString(0), nullptr, FALSE);
+}
+
+void CPDF_StreamContentParser::Handle_BeginText() {
+ m_pCurStates->m_TextMatrix.Set(1.0f, 0, 0, 1.0f, 0, 0);
+ OnChangeTextMatrix();
+ m_pCurStates->m_TextX = 0;
+ m_pCurStates->m_TextY = 0;
+ m_pCurStates->m_TextLineX = 0;
+ m_pCurStates->m_TextLineY = 0;
+}
+
+void CPDF_StreamContentParser::Handle_CurveTo_123() {
+ AddPathPoint(GetNumber(5), GetNumber(4), FXPT_BEZIERTO);
+ AddPathPoint(GetNumber(3), GetNumber(2), FXPT_BEZIERTO);
+ AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
+}
+
+void CPDF_StreamContentParser::Handle_ConcatMatrix() {
+ CFX_Matrix new_matrix(GetNumber(5), GetNumber(4), GetNumber(3), GetNumber(2),
+ GetNumber(1), GetNumber(0));
+ new_matrix.Concat(m_pCurStates->m_CTM);
+ m_pCurStates->m_CTM = new_matrix;
+ OnChangeTextMatrix();
+}
+
+void CPDF_StreamContentParser::Handle_SetColorSpace_Fill() {
+ CPDF_ColorSpace* pCS = FindColorSpace(GetString(0));
+ if (!pCS)
+ return;
+
+ m_pCurStates->m_ColorState.GetMutableFillColor()->SetColorSpace(pCS);
+}
+
+void CPDF_StreamContentParser::Handle_SetColorSpace_Stroke() {
+ CPDF_ColorSpace* pCS = FindColorSpace(GetString(0));
+ if (!pCS)
+ return;
+
+ m_pCurStates->m_ColorState.GetMutableStrokeColor()->SetColorSpace(pCS);
+}
+
+void CPDF_StreamContentParser::Handle_SetDash() {
+ CPDF_Array* pArray = ToArray(GetObject(1));
+ if (!pArray)
+ return;
+
+ m_pCurStates->SetLineDash(pArray, GetNumber(0), 1.0f);
+}
+
+void CPDF_StreamContentParser::Handle_SetCharWidth() {
+ m_Type3Data[0] = GetNumber(1);
+ m_Type3Data[1] = GetNumber(0);
+ m_bColored = true;
+}
+
+void CPDF_StreamContentParser::Handle_SetCachedDevice() {
+ for (int i = 0; i < 6; i++) {
+ m_Type3Data[i] = GetNumber(5 - i);
+ }
+ m_bColored = false;
+}
+
+void CPDF_StreamContentParser::Handle_ExecuteXObject() {
+ CFX_ByteString name = GetString(0);
+ if (name == m_LastImageName && m_pLastImage && m_pLastImage->GetStream() &&
+ m_pLastImage->GetStream()->GetObjNum()) {
+ AddImage(m_pLastImage);
+ return;
+ }
+
+ CPDF_Stream* pXObject = ToStream(FindResourceObj("XObject", name));
+ if (!pXObject) {
+ m_bResourceMissing = true;
+ return;
+ }
+
+ CFX_ByteString type;
+ if (pXObject->GetDict())
+ type = pXObject->GetDict()->GetStringFor("Subtype");
+
+ if (type == "Image") {
+ CPDF_ImageObject* pObj = AddImage(pXObject->GetObjNum());
+ m_LastImageName = name;
+ m_pLastImage = pObj->GetImage();
+ if (!m_pObjectHolder->HasImageMask())
+ m_pObjectHolder->SetHasImageMask(m_pLastImage->IsMask());
+ } else if (type == "Form") {
+ AddForm(pXObject);
+ }
+}
+
+void CPDF_StreamContentParser::AddForm(CPDF_Stream* pStream) {
+ std::unique_ptr<CPDF_FormObject> pFormObj(new CPDF_FormObject);
+ pFormObj->m_pForm.reset(
+ new CPDF_Form(m_pDocument, m_pPageResources, pStream, m_pResources));
+ pFormObj->m_FormMatrix = m_pCurStates->m_CTM;
+ pFormObj->m_FormMatrix.Concat(m_mtContentToUser);
+ CPDF_AllStates status;
+ status.m_GeneralState = m_pCurStates->m_GeneralState;
+ status.m_GraphState = m_pCurStates->m_GraphState;
+ status.m_ColorState = m_pCurStates->m_ColorState;
+ status.m_TextState = m_pCurStates->m_TextState;
+ pFormObj->m_pForm->ParseContent(&status, nullptr, nullptr, m_Level + 1);
+ if (!m_pObjectHolder->BackgroundAlphaNeeded() &&
+ pFormObj->m_pForm->BackgroundAlphaNeeded()) {
+ m_pObjectHolder->SetBackgroundAlphaNeeded(TRUE);
+ }
+ pFormObj->CalcBoundingBox();
+ SetGraphicStates(pFormObj.get(), true, true, true);
+ m_pObjectHolder->GetPageObjectList()->push_back(std::move(pFormObj));
+}
+
+CPDF_ImageObject* CPDF_StreamContentParser::AddImage(UniqueStream pStream) {
+ if (!pStream)
+ return nullptr;
+
+ auto pImageObj = pdfium::MakeUnique<CPDF_ImageObject>();
+ pImageObj->SetOwnedImage(
+ pdfium::MakeUnique<CPDF_Image>(m_pDocument, pStream.release(), true));
+
+ return AddImageObject(std::move(pImageObj));
+}
+
+CPDF_ImageObject* CPDF_StreamContentParser::AddImage(uint32_t streamObjNum) {
+ CPDF_Stream* pStream = ToStream(m_pDocument->GetIndirectObject(streamObjNum));
+ if (!pStream)
+ return nullptr;
+
+ auto pImageObj = pdfium::MakeUnique<CPDF_ImageObject>();
+ pImageObj->SetUnownedImage(m_pDocument->LoadImageF(pStream));
+ return AddImageObject(std::move(pImageObj));
+}
+
+CPDF_ImageObject* CPDF_StreamContentParser::AddImage(CPDF_Image* pImage) {
+ if (!pImage)
+ return nullptr;
+
+ auto pImageObj = pdfium::MakeUnique<CPDF_ImageObject>();
+ pImageObj->SetUnownedImage(
+ m_pDocument->GetPageData()->GetImage(pImage->GetStream()));
+
+ return AddImageObject(std::move(pImageObj));
+}
+
+CPDF_ImageObject* CPDF_StreamContentParser::AddImageObject(
+ std::unique_ptr<CPDF_ImageObject> pImageObj) {
+ SetGraphicStates(pImageObj.get(), pImageObj->GetImage()->IsMask(), false,
+ false);
+
+ CFX_Matrix ImageMatrix = m_pCurStates->m_CTM;
+ ImageMatrix.Concat(m_mtContentToUser);
+ pImageObj->m_Matrix = ImageMatrix;
+ pImageObj->CalcBoundingBox();
+
+ CPDF_ImageObject* pRet = pImageObj.get();
+ m_pObjectHolder->GetPageObjectList()->push_back(std::move(pImageObj));
+ return pRet;
+}
+
+void CPDF_StreamContentParser::Handle_MarkPlace_Dictionary() {}
+
+void CPDF_StreamContentParser::Handle_EndImage() {}
+
+void CPDF_StreamContentParser::Handle_EndMarkedContent() {
+ if (m_CurContentMark)
+ m_CurContentMark.DeleteLastMark();
+}
+
+void CPDF_StreamContentParser::Handle_EndText() {
+ if (m_ClipTextList.empty())
+ return;
+
+ if (TextRenderingModeIsClipMode(m_pCurStates->m_TextState.GetTextMode()))
+ m_pCurStates->m_ClipPath.AppendTexts(&m_ClipTextList);
+
+ m_ClipTextList.clear();
+}
+
+void CPDF_StreamContentParser::Handle_FillPath() {
+ AddPathObject(FXFILL_WINDING, false);
+}
+
+void CPDF_StreamContentParser::Handle_FillPathOld() {
+ AddPathObject(FXFILL_WINDING, false);
+}
+
+void CPDF_StreamContentParser::Handle_EOFillPath() {
+ AddPathObject(FXFILL_ALTERNATE, false);
+}
+
+void CPDF_StreamContentParser::Handle_SetGray_Fill() {
+ FX_FLOAT value = GetNumber(0);
+ CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
+ m_pCurStates->m_ColorState.SetFillColor(pCS, &value, 1);
+}
+
+void CPDF_StreamContentParser::Handle_SetGray_Stroke() {
+ FX_FLOAT value = GetNumber(0);
+ CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
+ m_pCurStates->m_ColorState.SetStrokeColor(pCS, &value, 1);
+}
+
+void CPDF_StreamContentParser::Handle_SetExtendGraphState() {
+ CFX_ByteString name = GetString(0);
+ CPDF_Dictionary* pGS = ToDictionary(FindResourceObj("ExtGState", name));
+ if (!pGS) {
+ m_bResourceMissing = true;
+ return;
+ }
+ m_pCurStates->ProcessExtGS(pGS, this);
+}
+
+void CPDF_StreamContentParser::Handle_ClosePath() {
+ if (m_PathPointCount == 0) {
+ return;
+ }
+ if (m_PathStartX != m_PathCurrentX || m_PathStartY != m_PathCurrentY) {
+ AddPathPoint(m_PathStartX, m_PathStartY, FXPT_LINETO | FXPT_CLOSEFIGURE);
+ } else if (m_pPathPoints[m_PathPointCount - 1].m_Flag != FXPT_MOVETO) {
+ m_pPathPoints[m_PathPointCount - 1].m_Flag |= FXPT_CLOSEFIGURE;
+ }
+}
+
+void CPDF_StreamContentParser::Handle_SetFlat() {
+ m_pCurStates->m_GeneralState.SetFlatness(GetNumber(0));
+}
+
+void CPDF_StreamContentParser::Handle_BeginImageData() {}
+
+void CPDF_StreamContentParser::Handle_SetLineJoin() {
+ m_pCurStates->m_GraphState.SetLineJoin(
+ static_cast<CFX_GraphStateData::LineJoin>(GetInteger(0)));
+}
+
+void CPDF_StreamContentParser::Handle_SetLineCap() {
+ m_pCurStates->m_GraphState.SetLineCap(
+ static_cast<CFX_GraphStateData::LineCap>(GetInteger(0)));
+}
+
+void CPDF_StreamContentParser::Handle_SetCMYKColor_Fill() {
+ if (m_ParamCount != 4)
+ return;
+
+ FX_FLOAT values[4];
+ for (int i = 0; i < 4; i++) {
+ values[i] = GetNumber(3 - i);
+ }
+ CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
+ m_pCurStates->m_ColorState.SetFillColor(pCS, values, 4);
+}
+
+void CPDF_StreamContentParser::Handle_SetCMYKColor_Stroke() {
+ if (m_ParamCount != 4)
+ return;
+
+ FX_FLOAT values[4];
+ for (int i = 0; i < 4; i++) {
+ values[i] = GetNumber(3 - i);
+ }
+ CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
+ m_pCurStates->m_ColorState.SetStrokeColor(pCS, values, 4);
+}
+
+void CPDF_StreamContentParser::Handle_LineTo() {
+ if (m_ParamCount != 2)
+ return;
+
+ AddPathPoint(GetNumber(1), GetNumber(0), FXPT_LINETO);
+}
+
+void CPDF_StreamContentParser::Handle_MoveTo() {
+ if (m_ParamCount != 2)
+ return;
+
+ AddPathPoint(GetNumber(1), GetNumber(0), FXPT_MOVETO);
+ ParsePathObject();
+}
+
+void CPDF_StreamContentParser::Handle_SetMiterLimit() {
+ m_pCurStates->m_GraphState.SetMiterLimit(GetNumber(0));
+}
+
+void CPDF_StreamContentParser::Handle_MarkPlace() {}
+
+void CPDF_StreamContentParser::Handle_EndPath() {
+ AddPathObject(0, false);
+}
+
+void CPDF_StreamContentParser::Handle_SaveGraphState() {
+ std::unique_ptr<CPDF_AllStates> pStates(new CPDF_AllStates);
+ pStates->Copy(*m_pCurStates);
+ m_StateStack.push_back(std::move(pStates));
+}
+
+void CPDF_StreamContentParser::Handle_RestoreGraphState() {
+ if (m_StateStack.empty())
+ return;
+ std::unique_ptr<CPDF_AllStates> pStates = std::move(m_StateStack.back());
+ m_StateStack.pop_back();
+ m_pCurStates->Copy(*pStates);
+}
+
+void CPDF_StreamContentParser::Handle_Rectangle() {
+ FX_FLOAT x = GetNumber(3), y = GetNumber(2);
+ FX_FLOAT w = GetNumber(1), h = GetNumber(0);
+ AddPathRect(x, y, w, h);
+}
+
+void CPDF_StreamContentParser::AddPathRect(FX_FLOAT x,
+ FX_FLOAT y,
+ FX_FLOAT w,
+ FX_FLOAT h) {
+ AddPathPoint(x, y, FXPT_MOVETO);
+ AddPathPoint(x + w, y, FXPT_LINETO);
+ AddPathPoint(x + w, y + h, FXPT_LINETO);
+ AddPathPoint(x, y + h, FXPT_LINETO);
+ AddPathPoint(x, y, FXPT_LINETO | FXPT_CLOSEFIGURE);
+}
+
+void CPDF_StreamContentParser::Handle_SetRGBColor_Fill() {
+ if (m_ParamCount != 3)
+ return;
+
+ FX_FLOAT values[3];
+ for (int i = 0; i < 3; i++) {
+ values[i] = GetNumber(2 - i);
+ }
+ CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
+ m_pCurStates->m_ColorState.SetFillColor(pCS, values, 3);
+}
+
+void CPDF_StreamContentParser::Handle_SetRGBColor_Stroke() {
+ if (m_ParamCount != 3)
+ return;
+
+ FX_FLOAT values[3];
+ for (int i = 0; i < 3; i++) {
+ values[i] = GetNumber(2 - i);
+ }
+ CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
+ m_pCurStates->m_ColorState.SetStrokeColor(pCS, values, 3);
+}
+
+void CPDF_StreamContentParser::Handle_SetRenderIntent() {}
+
+void CPDF_StreamContentParser::Handle_CloseStrokePath() {
+ Handle_ClosePath();
+ AddPathObject(0, true);
+}
+
+void CPDF_StreamContentParser::Handle_StrokePath() {
+ AddPathObject(0, true);
+}
+
+void CPDF_StreamContentParser::Handle_SetColor_Fill() {
+ FX_FLOAT values[4];
+ int nargs = m_ParamCount;
+ if (nargs > 4) {
+ nargs = 4;
+ }
+ for (int i = 0; i < nargs; i++) {
+ values[i] = GetNumber(nargs - i - 1);
+ }
+ m_pCurStates->m_ColorState.SetFillColor(nullptr, values, nargs);
+}
+
+void CPDF_StreamContentParser::Handle_SetColor_Stroke() {
+ FX_FLOAT values[4];
+ int nargs = m_ParamCount;
+ if (nargs > 4) {
+ nargs = 4;
+ }
+ for (int i = 0; i < nargs; i++) {
+ values[i] = GetNumber(nargs - i - 1);
+ }
+ m_pCurStates->m_ColorState.SetStrokeColor(nullptr, values, nargs);
+}
+
+void CPDF_StreamContentParser::Handle_SetColorPS_Fill() {
+ CPDF_Object* pLastParam = GetObject(0);
+ if (!pLastParam) {
+ return;
+ }
+ uint32_t nargs = m_ParamCount;
+ uint32_t nvalues = nargs;
+ if (pLastParam->IsName())
+ nvalues--;
+ FX_FLOAT* values = nullptr;
+ if (nvalues) {
+ values = FX_Alloc(FX_FLOAT, nvalues);
+ for (uint32_t i = 0; i < nvalues; i++) {
+ values[i] = GetNumber(nargs - i - 1);
+ }
+ }
+ if (nvalues != nargs) {
+ CPDF_Pattern* pPattern = FindPattern(GetString(0), false);
+ if (pPattern) {
+ m_pCurStates->m_ColorState.SetFillPattern(pPattern, values, nvalues);
+ }
+ } else {
+ m_pCurStates->m_ColorState.SetFillColor(nullptr, values, nvalues);
+ }
+ FX_Free(values);
+}
+
+void CPDF_StreamContentParser::Handle_SetColorPS_Stroke() {
+ CPDF_Object* pLastParam = GetObject(0);
+ if (!pLastParam) {
+ return;
+ }
+ int nargs = m_ParamCount;
+ int nvalues = nargs;
+ if (pLastParam->IsName())
+ nvalues--;
+
+ FX_FLOAT* values = nullptr;
+ if (nvalues) {
+ values = FX_Alloc(FX_FLOAT, nvalues);
+ for (int i = 0; i < nvalues; i++) {
+ values[i] = GetNumber(nargs - i - 1);
+ }
+ }
+ if (nvalues != nargs) {
+ CPDF_Pattern* pPattern = FindPattern(GetString(0), false);
+ if (pPattern) {
+ m_pCurStates->m_ColorState.SetStrokePattern(pPattern, values, nvalues);
+ }
+ } else {
+ m_pCurStates->m_ColorState.SetStrokeColor(nullptr, values, nvalues);
+ }
+ FX_Free(values);
+}
+
+void CPDF_StreamContentParser::Handle_ShadeFill() {
+ CPDF_Pattern* pPattern = FindPattern(GetString(0), true);
+ if (!pPattern)
+ return;
+
+ CPDF_ShadingPattern* pShading = pPattern->AsShadingPattern();
+ if (!pShading)
+ return;
+
+ if (!pShading->IsShadingObject() || !pShading->Load())
+ return;
+
+ std::unique_ptr<CPDF_ShadingObject> pObj(new CPDF_ShadingObject);
+ pObj->m_pShading = pShading;
+ SetGraphicStates(pObj.get(), false, false, false);
+ pObj->m_Matrix = m_pCurStates->m_CTM;
+ pObj->m_Matrix.Concat(m_mtContentToUser);
+ CFX_FloatRect bbox =
+ pObj->m_ClipPath ? pObj->m_ClipPath.GetClipBox() : m_BBox;
+ if (pShading->IsMeshShading())
+ bbox.Intersect(GetShadingBBox(pShading, pObj->m_Matrix));
+ pObj->m_Left = bbox.left;
+ pObj->m_Right = bbox.right;
+ pObj->m_Top = bbox.top;
+ pObj->m_Bottom = bbox.bottom;
+ m_pObjectHolder->GetPageObjectList()->push_back(std::move(pObj));
+}
+
+void CPDF_StreamContentParser::Handle_SetCharSpace() {
+ m_pCurStates->m_TextState.SetCharSpace(GetNumber(0));
+}
+
+void CPDF_StreamContentParser::Handle_MoveTextPoint() {
+ m_pCurStates->m_TextLineX += GetNumber(1);
+ m_pCurStates->m_TextLineY += GetNumber(0);
+ m_pCurStates->m_TextX = m_pCurStates->m_TextLineX;
+ m_pCurStates->m_TextY = m_pCurStates->m_TextLineY;
+}
+
+void CPDF_StreamContentParser::Handle_MoveTextPoint_SetLeading() {
+ Handle_MoveTextPoint();
+ m_pCurStates->m_TextLeading = -GetNumber(0);
+}
+
+void CPDF_StreamContentParser::Handle_SetFont() {
+ FX_FLOAT fs = GetNumber(0);
+ if (fs == 0) {
+ fs = m_DefFontSize;
+ }
+ m_pCurStates->m_TextState.SetFontSize(fs);
+ CPDF_Font* pFont = FindFont(GetString(1));
+ if (pFont) {
+ m_pCurStates->m_TextState.SetFont(pFont);
+ }
+}
+
+CPDF_Object* CPDF_StreamContentParser::FindResourceObj(
+ const CFX_ByteString& type,
+ const CFX_ByteString& name) {
+ if (!m_pResources)
+ return nullptr;
+ CPDF_Dictionary* pDict = m_pResources->GetDictFor(type);
+ if (pDict)
+ return pDict->GetDirectObjectFor(name);
+ if (m_pResources == m_pPageResources || !m_pPageResources)
+ return nullptr;
+
+ CPDF_Dictionary* pPageDict = m_pPageResources->GetDictFor(type);
+ return pPageDict ? pPageDict->GetDirectObjectFor(name) : nullptr;
+}
+
+CPDF_Font* CPDF_StreamContentParser::FindFont(const CFX_ByteString& name) {
+ CPDF_Dictionary* pFontDict = ToDictionary(FindResourceObj("Font", name));
+ if (!pFontDict) {
+ m_bResourceMissing = true;
+ return CPDF_Font::GetStockFont(m_pDocument, "Helvetica");
+ }
+
+ CPDF_Font* pFont = m_pDocument->LoadFont(pFontDict);
+ if (pFont && pFont->IsType3Font()) {
+ pFont->AsType3Font()->SetPageResources(m_pResources);
+ pFont->AsType3Font()->CheckType3FontMetrics();
+ }
+ return pFont;
+}
+
+CPDF_ColorSpace* CPDF_StreamContentParser::FindColorSpace(
+ const CFX_ByteString& name) {
+ if (name == "Pattern") {
+ return CPDF_ColorSpace::GetStockCS(PDFCS_PATTERN);
+ }
+ if (name == "DeviceGray" || name == "DeviceCMYK" || name == "DeviceRGB") {
+ CFX_ByteString defname = "Default";
+ defname += name.Mid(7);
+ CPDF_Object* pDefObj = FindResourceObj("ColorSpace", defname);
+ if (!pDefObj) {
+ if (name == "DeviceGray") {
+ return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
+ }
+ if (name == "DeviceRGB") {
+ return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
+ }
+ return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
+ }
+ return m_pDocument->LoadColorSpace(pDefObj);
+ }
+ CPDF_Object* pCSObj = FindResourceObj("ColorSpace", name);
+ if (!pCSObj) {
+ m_bResourceMissing = true;
+ return nullptr;
+ }
+ return m_pDocument->LoadColorSpace(pCSObj);
+}
+
+CPDF_Pattern* CPDF_StreamContentParser::FindPattern(const CFX_ByteString& name,
+ bool bShading) {
+ CPDF_Object* pPattern =
+ FindResourceObj(bShading ? "Shading" : "Pattern", name);
+ if (!pPattern || (!pPattern->IsDictionary() && !pPattern->IsStream())) {
+ m_bResourceMissing = true;
+ return nullptr;
+ }
+ return m_pDocument->LoadPattern(pPattern, bShading,
+ m_pCurStates->m_ParentMatrix);
+}
+
+void CPDF_StreamContentParser::ConvertTextSpace(FX_FLOAT& x, FX_FLOAT& y) {
+ m_pCurStates->m_TextMatrix.Transform(x, y, x, y);
+ ConvertUserSpace(x, y);
+}
+
+void CPDF_StreamContentParser::ConvertUserSpace(FX_FLOAT& x, FX_FLOAT& y) {
+ m_pCurStates->m_CTM.Transform(x, y, x, y);
+ m_mtContentToUser.Transform(x, y, x, y);
+}
+
+void CPDF_StreamContentParser::AddTextObject(CFX_ByteString* pStrs,
+ FX_FLOAT fInitKerning,
+ FX_FLOAT* pKerning,
+ int nsegs) {
+ CPDF_Font* pFont = m_pCurStates->m_TextState.GetFont();
+ if (!pFont) {
+ return;
+ }
+ if (fInitKerning != 0) {
+ if (!pFont->IsVertWriting()) {
+ m_pCurStates->m_TextX -=
+ (fInitKerning * m_pCurStates->m_TextState.GetFontSize()) / 1000;
+ } else {
+ m_pCurStates->m_TextY -=
+ (fInitKerning * m_pCurStates->m_TextState.GetFontSize()) / 1000;
+ }
+ }
+ if (nsegs == 0) {
+ return;
+ }
+ const TextRenderingMode text_mode =
+ pFont->IsType3Font() ? TextRenderingMode::MODE_FILL
+ : m_pCurStates->m_TextState.GetTextMode();
+ {
+ std::unique_ptr<CPDF_TextObject> pText(new CPDF_TextObject);
+ m_pLastTextObject = pText.get();
+ SetGraphicStates(m_pLastTextObject, true, true, true);
+ if (TextRenderingModeIsStrokeMode(text_mode)) {
+ FX_FLOAT* pCTM = pText->m_TextState.GetMutableCTM();
+ pCTM[0] = m_pCurStates->m_CTM.a;
+ pCTM[1] = m_pCurStates->m_CTM.c;
+ pCTM[2] = m_pCurStates->m_CTM.b;
+ pCTM[3] = m_pCurStates->m_CTM.d;
+ }
+ pText->SetSegments(pStrs, pKerning, nsegs);
+ pText->m_PosX = m_pCurStates->m_TextX;
+ pText->m_PosY = m_pCurStates->m_TextY + m_pCurStates->m_TextRise;
+ ConvertTextSpace(pText->m_PosX, pText->m_PosY);
+ FX_FLOAT x_advance;
+ FX_FLOAT y_advance;
+ pText->CalcPositionData(&x_advance, &y_advance,
+ m_pCurStates->m_TextHorzScale);
+ m_pCurStates->m_TextX += x_advance;
+ m_pCurStates->m_TextY += y_advance;
+ if (TextRenderingModeIsClipMode(text_mode)) {
+ m_ClipTextList.push_back(
+ std::unique_ptr<CPDF_TextObject>(pText->Clone()));
+ }
+ m_pObjectHolder->GetPageObjectList()->push_back(std::move(pText));
+ }
+ if (pKerning && pKerning[nsegs - 1] != 0) {
+ if (!pFont->IsVertWriting()) {
+ m_pCurStates->m_TextX -=
+ (pKerning[nsegs - 1] * m_pCurStates->m_TextState.GetFontSize()) /
+ 1000;
+ } else {
+ m_pCurStates->m_TextY -=
+ (pKerning[nsegs - 1] * m_pCurStates->m_TextState.GetFontSize()) /
+ 1000;
+ }
+ }
+}
+
+void CPDF_StreamContentParser::Handle_ShowText() {
+ CFX_ByteString str = GetString(0);
+ if (str.IsEmpty()) {
+ return;
+ }
+ AddTextObject(&str, 0, nullptr, 1);
+}
+
+void CPDF_StreamContentParser::Handle_ShowText_Positioning() {
+ CPDF_Array* pArray = ToArray(GetObject(0));
+ if (!pArray)
+ return;
+
+ size_t n = pArray->GetCount();
+ size_t nsegs = 0;
+ for (size_t i = 0; i < n; i++) {
+ if (pArray->GetDirectObjectAt(i)->IsString())
+ nsegs++;
+ }
+ if (nsegs == 0) {
+ for (size_t i = 0; i < n; i++) {
+ m_pCurStates->m_TextX -=
+ (pArray->GetNumberAt(i) * m_pCurStates->m_TextState.GetFontSize()) /
+ 1000;
+ }
+ return;
+ }
+ CFX_ByteString* pStrs = new CFX_ByteString[nsegs];
+ FX_FLOAT* pKerning = FX_Alloc(FX_FLOAT, nsegs);
+ size_t iSegment = 0;
+ FX_FLOAT fInitKerning = 0;
+ for (size_t i = 0; i < n; i++) {
+ CPDF_Object* pObj = pArray->GetDirectObjectAt(i);
+ if (pObj->IsString()) {
+ CFX_ByteString str = pObj->GetString();
+ if (str.IsEmpty()) {
+ continue;
+ }
+ pStrs[iSegment] = str;
+ pKerning[iSegment++] = 0;
+ } else {
+ FX_FLOAT num = pObj ? pObj->GetNumber() : 0;
+ if (iSegment == 0) {
+ fInitKerning += num;
+ } else {
+ pKerning[iSegment - 1] += num;
+ }
+ }
+ }
+ AddTextObject(pStrs, fInitKerning, pKerning, iSegment);
+ delete[] pStrs;
+ FX_Free(pKerning);
+}
+
+void CPDF_StreamContentParser::Handle_SetTextLeading() {
+ m_pCurStates->m_TextLeading = GetNumber(0);
+}
+
+void CPDF_StreamContentParser::Handle_SetTextMatrix() {
+ m_pCurStates->m_TextMatrix.Set(GetNumber(5), GetNumber(4), GetNumber(3),
+ GetNumber(2), GetNumber(1), GetNumber(0));
+ OnChangeTextMatrix();
+ m_pCurStates->m_TextX = 0;
+ m_pCurStates->m_TextY = 0;
+ m_pCurStates->m_TextLineX = 0;
+ m_pCurStates->m_TextLineY = 0;
+}
+
+void CPDF_StreamContentParser::OnChangeTextMatrix() {
+ CFX_Matrix text_matrix(m_pCurStates->m_TextHorzScale, 0.0f, 0.0f, 1.0f, 0.0f,
+ 0.0f);
+ text_matrix.Concat(m_pCurStates->m_TextMatrix);
+ text_matrix.Concat(m_pCurStates->m_CTM);
+ text_matrix.Concat(m_mtContentToUser);
+ FX_FLOAT* pTextMatrix = m_pCurStates->m_TextState.GetMutableMatrix();
+ pTextMatrix[0] = text_matrix.a;
+ pTextMatrix[1] = text_matrix.c;
+ pTextMatrix[2] = text_matrix.b;
+ pTextMatrix[3] = text_matrix.d;
+}
+
+void CPDF_StreamContentParser::Handle_SetTextRenderMode() {
+ TextRenderingMode mode;
+ if (SetTextRenderingModeFromInt(GetInteger(0), &mode))
+ m_pCurStates->m_TextState.SetTextMode(mode);
+}
+
+void CPDF_StreamContentParser::Handle_SetTextRise() {
+ m_pCurStates->m_TextRise = GetNumber(0);
+}
+
+void CPDF_StreamContentParser::Handle_SetWordSpace() {
+ m_pCurStates->m_TextState.SetWordSpace(GetNumber(0));
+}
+
+void CPDF_StreamContentParser::Handle_SetHorzScale() {
+ if (m_ParamCount != 1) {
+ return;
+ }
+ m_pCurStates->m_TextHorzScale = GetNumber(0) / 100;
+ OnChangeTextMatrix();
+}
+
+void CPDF_StreamContentParser::Handle_MoveToNextLine() {
+ m_pCurStates->m_TextLineY -= m_pCurStates->m_TextLeading;
+ m_pCurStates->m_TextX = m_pCurStates->m_TextLineX;
+ m_pCurStates->m_TextY = m_pCurStates->m_TextLineY;
+}
+
+void CPDF_StreamContentParser::Handle_CurveTo_23() {
+ AddPathPoint(m_PathCurrentX, m_PathCurrentY, FXPT_BEZIERTO);
+ AddPathPoint(GetNumber(3), GetNumber(2), FXPT_BEZIERTO);
+ AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
+}
+
+void CPDF_StreamContentParser::Handle_SetLineWidth() {
+ m_pCurStates->m_GraphState.SetLineWidth(GetNumber(0));
+}
+
+void CPDF_StreamContentParser::Handle_Clip() {
+ m_PathClipType = FXFILL_WINDING;
+}
+
+void CPDF_StreamContentParser::Handle_EOClip() {
+ m_PathClipType = FXFILL_ALTERNATE;
+}
+
+void CPDF_StreamContentParser::Handle_CurveTo_13() {
+ AddPathPoint(GetNumber(3), GetNumber(2), FXPT_BEZIERTO);
+ AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
+ AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
+}
+
+void CPDF_StreamContentParser::Handle_NextLineShowText() {
+ Handle_MoveToNextLine();
+ Handle_ShowText();
+}
+
+void CPDF_StreamContentParser::Handle_NextLineShowText_Space() {
+ m_pCurStates->m_TextState.SetWordSpace(GetNumber(2));
+ m_pCurStates->m_TextState.SetCharSpace(GetNumber(1));
+ Handle_NextLineShowText();
+}
+
+void CPDF_StreamContentParser::Handle_Invalid() {}
+
+void CPDF_StreamContentParser::AddPathPoint(FX_FLOAT x, FX_FLOAT y, int flag) {
+ m_PathCurrentX = x;
+ m_PathCurrentY = y;
+ if (flag == FXPT_MOVETO) {
+ m_PathStartX = x;
+ m_PathStartY = y;
+ if (m_PathPointCount &&
+ m_pPathPoints[m_PathPointCount - 1].m_Flag == FXPT_MOVETO) {
+ m_pPathPoints[m_PathPointCount - 1].m_PointX = x;
+ m_pPathPoints[m_PathPointCount - 1].m_PointY = y;
+ return;
+ }
+ } else if (m_PathPointCount == 0) {
+ return;
+ }
+ m_PathPointCount++;
+ if (m_PathPointCount > m_PathAllocSize) {
+ int newsize = m_PathPointCount + 256;
+ FX_PATHPOINT* pNewPoints = FX_Alloc(FX_PATHPOINT, newsize);
+ if (m_PathAllocSize) {
+ FXSYS_memcpy(pNewPoints, m_pPathPoints,
+ m_PathAllocSize * sizeof(FX_PATHPOINT));
+ FX_Free(m_pPathPoints);
+ }
+ m_pPathPoints = pNewPoints;
+ m_PathAllocSize = newsize;
+ }
+ m_pPathPoints[m_PathPointCount - 1].m_Flag = flag;
+ m_pPathPoints[m_PathPointCount - 1].m_PointX = x;
+ m_pPathPoints[m_PathPointCount - 1].m_PointY = y;
+}
+
+void CPDF_StreamContentParser::AddPathObject(int FillType, bool bStroke) {
+ int PathPointCount = m_PathPointCount;
+ uint8_t PathClipType = m_PathClipType;
+ m_PathPointCount = 0;
+ m_PathClipType = 0;
+ if (PathPointCount <= 1) {
+ if (PathPointCount && PathClipType) {
+ CPDF_Path path;
+ path.AppendRect(0, 0, 0, 0);
+ m_pCurStates->m_ClipPath.AppendPath(path, FXFILL_WINDING, TRUE);
+ }
+ return;
+ }
+ if (PathPointCount &&
+ m_pPathPoints[PathPointCount - 1].m_Flag == FXPT_MOVETO) {
+ PathPointCount--;
+ }
+ CPDF_Path Path;
+ Path.SetPointCount(PathPointCount);
+ FXSYS_memcpy(Path.GetMutablePoints(), m_pPathPoints,
+ sizeof(FX_PATHPOINT) * PathPointCount);
+ CFX_Matrix matrix = m_pCurStates->m_CTM;
+ matrix.Concat(m_mtContentToUser);
+ if (bStroke || FillType) {
+ std::unique_ptr<CPDF_PathObject> pPathObj(new CPDF_PathObject);
+ pPathObj->m_bStroke = bStroke;
+ pPathObj->m_FillType = FillType;
+ pPathObj->m_Path = Path;
+ pPathObj->m_Matrix = matrix;
+ SetGraphicStates(pPathObj.get(), true, false, true);
+ pPathObj->CalcBoundingBox();
+ m_pObjectHolder->GetPageObjectList()->push_back(std::move(pPathObj));
+ }
+ if (PathClipType) {
+ if (!matrix.IsIdentity()) {
+ Path.Transform(&matrix);
+ matrix.SetIdentity();
+ }
+ m_pCurStates->m_ClipPath.AppendPath(Path, PathClipType, TRUE);
+ }
+}
+
+uint32_t CPDF_StreamContentParser::Parse(const uint8_t* pData,
+ uint32_t dwSize,
+ uint32_t max_cost) {
+ if (m_Level > kMaxFormLevel)
+ return dwSize;
+
+ uint32_t InitObjCount = m_pObjectHolder->GetPageObjectList()->size();
+ CPDF_StreamParser syntax(pData, dwSize, m_pDocument->GetByteStringPool());
+ CPDF_StreamParserAutoClearer auto_clearer(&m_pSyntax, &syntax);
+ while (1) {
+ uint32_t cost = m_pObjectHolder->GetPageObjectList()->size() - InitObjCount;
+ if (max_cost && cost >= max_cost) {
+ break;
+ }
+ switch (syntax.ParseNextElement()) {
+ case CPDF_StreamParser::EndOfData:
+ return m_pSyntax->GetPos();
+ case CPDF_StreamParser::Keyword:
+ OnOperator((char*)syntax.GetWordBuf());
+ ClearAllParams();
+ break;
+ case CPDF_StreamParser::Number:
+ AddNumberParam((char*)syntax.GetWordBuf(), syntax.GetWordSize());
+ break;
+ case CPDF_StreamParser::Name:
+ AddNameParam((const FX_CHAR*)syntax.GetWordBuf() + 1,
+ syntax.GetWordSize() - 1);
+ break;
+ default:
+ AddObjectParam(syntax.GetObject());
+ }
+ }
+ return m_pSyntax->GetPos();
+}
+
+void CPDF_StreamContentParser::ParsePathObject() {
+ FX_FLOAT params[6] = {};
+ int nParams = 0;
+ int last_pos = m_pSyntax->GetPos();
+ while (1) {
+ CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
+ FX_BOOL bProcessed = TRUE;
+ switch (type) {
+ case CPDF_StreamParser::EndOfData:
+ return;
+ case CPDF_StreamParser::Keyword: {
+ int len = m_pSyntax->GetWordSize();
+ if (len == 1) {
+ switch (m_pSyntax->GetWordBuf()[0]) {
+ case kPathOperatorSubpath:
+ AddPathPoint(params[0], params[1], FXPT_MOVETO);
+ nParams = 0;
+ break;
+ case kPathOperatorLine:
+ AddPathPoint(params[0], params[1], FXPT_LINETO);
+ nParams = 0;
+ break;
+ case kPathOperatorCubicBezier1:
+ AddPathPoint(params[0], params[1], FXPT_BEZIERTO);
+ AddPathPoint(params[2], params[3], FXPT_BEZIERTO);
+ AddPathPoint(params[4], params[5], FXPT_BEZIERTO);
+ nParams = 0;
+ break;
+ case kPathOperatorCubicBezier2:
+ AddPathPoint(m_PathCurrentX, m_PathCurrentY, FXPT_BEZIERTO);
+ AddPathPoint(params[0], params[1], FXPT_BEZIERTO);
+ AddPathPoint(params[2], params[3], FXPT_BEZIERTO);
+ nParams = 0;
+ break;
+ case kPathOperatorCubicBezier3:
+ AddPathPoint(params[0], params[1], FXPT_BEZIERTO);
+ AddPathPoint(params[2], params[3], FXPT_BEZIERTO);
+ AddPathPoint(params[2], params[3], FXPT_BEZIERTO);
+ nParams = 0;
+ break;
+ case kPathOperatorClosePath:
+ Handle_ClosePath();
+ nParams = 0;
+ break;
+ default:
+ bProcessed = FALSE;
+ break;
+ }
+ } else if (len == 2) {
+ if (m_pSyntax->GetWordBuf()[0] == kPathOperatorRectangle[0] &&
+ m_pSyntax->GetWordBuf()[1] == kPathOperatorRectangle[1]) {
+ AddPathRect(params[0], params[1], params[2], params[3]);
+ nParams = 0;
+ } else {
+ bProcessed = FALSE;
+ }
+ } else {
+ bProcessed = FALSE;
+ }
+ if (bProcessed) {
+ last_pos = m_pSyntax->GetPos();
+ }
+ break;
+ }
+ case CPDF_StreamParser::Number: {
+ if (nParams == 6)
+ break;
+
+ int value;
+ bool bInteger = FX_atonum(
+ CFX_ByteStringC(m_pSyntax->GetWordBuf(), m_pSyntax->GetWordSize()),
+ &value);
+ params[nParams++] = bInteger ? (FX_FLOAT)value : *(FX_FLOAT*)&value;
+ break;
+ }
+ default:
+ bProcessed = FALSE;
+ }
+ if (!bProcessed) {
+ m_pSyntax->SetPos(last_pos);
+ return;
+ }
+ }
+}
diff --git a/core/fpdfapi/page/cpdf_streamcontentparser.h b/core/fpdfapi/page/cpdf_streamcontentparser.h
new file mode 100644
index 0000000000..58008da96a
--- /dev/null
+++ b/core/fpdfapi/page/cpdf_streamcontentparser.h
@@ -0,0 +1,225 @@
+// 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
+
+#ifndef CORE_FPDFAPI_PAGE_CPDF_STREAMCONTENTPARSER_H_
+#define CORE_FPDFAPI_PAGE_CPDF_STREAMCONTENTPARSER_H_
+
+#include <memory>
+#include <unordered_map>
+#include <vector>
+
+#include "core/fpdfapi/page/cpdf_contentmark.h"
+#include "core/fpdfapi/parser/cpdf_stream.h"
+#include "core/fxcrt/fx_string.h"
+#include "core/fxge/cfx_pathdata.h"
+
+class CPDF_AllStates;
+class CPDF_Dictionary;
+class CPDF_Document;
+class CPDF_Font;
+class CPDF_Image;
+class CPDF_ImageObject;
+class CPDF_PageObject;
+class CPDF_PageObjectHolder;
+class CPDF_StreamParser;
+class CPDF_TextObject;
+class CPDF_ColorSpace;
+class CPDF_Pattern;
+
+class CPDF_StreamContentParser {
+ public:
+ CPDF_StreamContentParser(CPDF_Document* pDoc,
+ CPDF_Dictionary* pPageResources,
+ CPDF_Dictionary* pParentResources,
+ const CFX_Matrix* pmtContentToUser,
+ CPDF_PageObjectHolder* pObjectHolder,
+ CPDF_Dictionary* pResources,
+ CFX_FloatRect* pBBox,
+ CPDF_AllStates* pAllStates,
+ int level);
+ ~CPDF_StreamContentParser();
+
+ uint32_t Parse(const uint8_t* pData, uint32_t dwSize, uint32_t max_cost);
+ CPDF_PageObjectHolder* GetPageObjectHolder() const { return m_pObjectHolder; }
+ CPDF_AllStates* GetCurStates() const { return m_pCurStates.get(); }
+ bool IsColored() const { return m_bColored; }
+ const FX_FLOAT* GetType3Data() const { return m_Type3Data; }
+ CPDF_Font* FindFont(const CFX_ByteString& name);
+
+ private:
+ struct ContentParam {
+ enum Type { OBJECT = 0, NUMBER, NAME };
+ Type m_Type;
+ union {
+ struct {
+ bool m_bInteger;
+ union {
+ int m_Integer;
+ FX_FLOAT m_Float;
+ };
+ } m_Number;
+ CPDF_Object* m_pObject;
+ struct {
+ int m_Len;
+ char m_Buffer[32];
+ } m_Name;
+ };
+ };
+
+ static const int kParamBufSize = 16;
+
+ using OpCodes =
+ std::unordered_map<uint32_t, void (CPDF_StreamContentParser::*)()>;
+ static OpCodes InitializeOpCodes();
+
+ void AddNumberParam(const FX_CHAR* str, int len);
+ void AddObjectParam(CPDF_Object* pObj);
+ void AddNameParam(const FX_CHAR* name, int size);
+ int GetNextParamPos();
+ void ClearAllParams();
+ CPDF_Object* GetObject(uint32_t index);
+ CFX_ByteString GetString(uint32_t index);
+ FX_FLOAT GetNumber(uint32_t index);
+ int GetInteger(uint32_t index) { return (int32_t)(GetNumber(index)); }
+ void OnOperator(const FX_CHAR* op);
+ void AddTextObject(CFX_ByteString* pText,
+ FX_FLOAT fInitKerning,
+ FX_FLOAT* pKerning,
+ int count);
+
+ void ConvertUserSpace(FX_FLOAT& x, FX_FLOAT& y);
+ void ConvertTextSpace(FX_FLOAT& x, FX_FLOAT& y);
+ void OnChangeTextMatrix();
+ void ParsePathObject();
+ void AddPathPoint(FX_FLOAT x, FX_FLOAT y, int flag);
+ void AddPathRect(FX_FLOAT x, FX_FLOAT y, FX_FLOAT w, FX_FLOAT h);
+ void AddPathObject(int FillType, bool bStroke);
+ CPDF_ImageObject* AddImage(UniqueStream pStream);
+ CPDF_ImageObject* AddImage(uint32_t streamObjNum);
+ CPDF_ImageObject* AddImage(CPDF_Image* pImage);
+
+ void AddForm(CPDF_Stream* pStream);
+ void SetGraphicStates(CPDF_PageObject* pObj,
+ bool bColor,
+ bool bText,
+ bool bGraph);
+ CPDF_ColorSpace* FindColorSpace(const CFX_ByteString& name);
+ CPDF_Pattern* FindPattern(const CFX_ByteString& name, bool bShading);
+ CPDF_Object* FindResourceObj(const CFX_ByteString& type,
+ const CFX_ByteString& name);
+
+ // Takes ownership of |pImageObj|, returns unowned pointer to it.
+ CPDF_ImageObject* AddImageObject(std::unique_ptr<CPDF_ImageObject> pImageObj);
+
+ void Handle_CloseFillStrokePath();
+ void Handle_FillStrokePath();
+ void Handle_CloseEOFillStrokePath();
+ void Handle_EOFillStrokePath();
+ void Handle_BeginMarkedContent_Dictionary();
+ void Handle_BeginImage();
+ void Handle_BeginMarkedContent();
+ void Handle_BeginText();
+ void Handle_CurveTo_123();
+ void Handle_ConcatMatrix();
+ void Handle_SetColorSpace_Fill();
+ void Handle_SetColorSpace_Stroke();
+ void Handle_SetDash();
+ void Handle_SetCharWidth();
+ void Handle_SetCachedDevice();
+ void Handle_ExecuteXObject();
+ void Handle_MarkPlace_Dictionary();
+ void Handle_EndImage();
+ void Handle_EndMarkedContent();
+ void Handle_EndText();
+ void Handle_FillPath();
+ void Handle_FillPathOld();
+ void Handle_EOFillPath();
+ void Handle_SetGray_Fill();
+ void Handle_SetGray_Stroke();
+ void Handle_SetExtendGraphState();
+ void Handle_ClosePath();
+ void Handle_SetFlat();
+ void Handle_BeginImageData();
+ void Handle_SetLineJoin();
+ void Handle_SetLineCap();
+ void Handle_SetCMYKColor_Fill();
+ void Handle_SetCMYKColor_Stroke();
+ void Handle_LineTo();
+ void Handle_MoveTo();
+ void Handle_SetMiterLimit();
+ void Handle_MarkPlace();
+ void Handle_EndPath();
+ void Handle_SaveGraphState();
+ void Handle_RestoreGraphState();
+ void Handle_Rectangle();
+ void Handle_SetRGBColor_Fill();
+ void Handle_SetRGBColor_Stroke();
+ void Handle_SetRenderIntent();
+ void Handle_CloseStrokePath();
+ void Handle_StrokePath();
+ void Handle_SetColor_Fill();
+ void Handle_SetColor_Stroke();
+ void Handle_SetColorPS_Fill();
+ void Handle_SetColorPS_Stroke();
+ void Handle_ShadeFill();
+ void Handle_SetCharSpace();
+ void Handle_MoveTextPoint();
+ void Handle_MoveTextPoint_SetLeading();
+ void Handle_SetFont();
+ void Handle_ShowText();
+ void Handle_ShowText_Positioning();
+ void Handle_SetTextLeading();
+ void Handle_SetTextMatrix();
+ void Handle_SetTextRenderMode();
+ void Handle_SetTextRise();
+ void Handle_SetWordSpace();
+ void Handle_SetHorzScale();
+ void Handle_MoveToNextLine();
+ void Handle_CurveTo_23();
+ void Handle_SetLineWidth();
+ void Handle_Clip();
+ void Handle_EOClip();
+ void Handle_CurveTo_13();
+ void Handle_NextLineShowText();
+ void Handle_NextLineShowText_Space();
+ void Handle_Invalid();
+
+ CPDF_Document* const m_pDocument;
+ CPDF_Dictionary* m_pPageResources;
+ CPDF_Dictionary* m_pParentResources;
+ CPDF_Dictionary* m_pResources;
+ CPDF_PageObjectHolder* m_pObjectHolder;
+ int m_Level;
+ CFX_Matrix m_mtContentToUser;
+ CFX_FloatRect m_BBox;
+ ContentParam m_ParamBuf[kParamBufSize];
+ uint32_t m_ParamStartPos;
+ uint32_t m_ParamCount;
+ CPDF_StreamParser* m_pSyntax;
+ std::unique_ptr<CPDF_AllStates> m_pCurStates;
+ CPDF_ContentMark m_CurContentMark;
+ std::vector<std::unique_ptr<CPDF_TextObject>> m_ClipTextList;
+ CPDF_TextObject* m_pLastTextObject;
+ FX_FLOAT m_DefFontSize;
+ FX_PATHPOINT* m_pPathPoints;
+ int m_PathPointCount;
+ int m_PathAllocSize;
+ FX_FLOAT m_PathStartX;
+ FX_FLOAT m_PathStartY;
+ FX_FLOAT m_PathCurrentX;
+ FX_FLOAT m_PathCurrentY;
+ uint8_t m_PathClipType;
+ CFX_ByteString m_LastImageName;
+ CPDF_Image* m_pLastImage;
+ CPDF_Dictionary* m_pLastImageDict;
+ CPDF_Dictionary* m_pLastCloneImageDict;
+ bool m_bColored;
+ FX_FLOAT m_Type3Data[6];
+ bool m_bResourceMissing;
+ std::vector<std::unique_ptr<CPDF_AllStates>> m_StateStack;
+};
+
+#endif // CORE_FPDFAPI_PAGE_CPDF_STREAMCONTENTPARSER_H_
diff --git a/core/fpdfapi/page/fpdf_page_parser.cpp b/core/fpdfapi/page/fpdf_page_parser.cpp
index 5fdca908c8..b6f0bc605c 100644
--- a/core/fpdfapi/page/fpdf_page_parser.cpp
+++ b/core/fpdfapi/page/fpdf_page_parser.cpp
@@ -41,20 +41,6 @@
namespace {
-const int kSingleCoordinatePair = 1;
-const int kTensorCoordinatePairs = 16;
-const int kCoonsCoordinatePairs = 12;
-const int kSingleColorPerPatch = 1;
-const int kQuadColorsPerPatch = 4;
-
-const char kPathOperatorSubpath = 'm';
-const char kPathOperatorLine = 'l';
-const char kPathOperatorCubicBezier1 = 'c';
-const char kPathOperatorCubicBezier2 = 'v';
-const char kPathOperatorCubicBezier3 = 'y';
-const char kPathOperatorClosePath = 'h';
-const char kPathOperatorRectangle[] = "re";
-
struct PDF_AbbrPair {
const FX_CHAR* abbr;
const FX_CHAR* full_name;
@@ -81,19 +67,6 @@ struct AbbrReplacementOp {
CFX_ByteStringC replacement;
};
-class CPDF_StreamParserAutoClearer {
- public:
- CPDF_StreamParserAutoClearer(CPDF_StreamParser** scoped_variable,
- CPDF_StreamParser* new_parser)
- : scoped_variable_(scoped_variable) {
- *scoped_variable_ = new_parser;
- }
- ~CPDF_StreamParserAutoClearer() { *scoped_variable_ = nullptr; }
-
- private:
- CPDF_StreamParser** scoped_variable_;
-};
-
CFX_ByteStringC PDF_FindFullName(const PDF_AbbrPair* table,
size_t count,
const CFX_ByteStringC& abbr) {
@@ -104,68 +77,6 @@ CFX_ByteStringC PDF_FindFullName(const PDF_AbbrPair* table,
: CFX_ByteStringC();
}
-CFX_FloatRect GetShadingBBox(CPDF_ShadingPattern* pShading,
- const CFX_Matrix& matrix) {
- ShadingType type = pShading->GetShadingType();
- CPDF_Stream* pStream = ToStream(pShading->GetShadingObject());
- CPDF_ColorSpace* pCS = pShading->GetCS();
- if (!pStream || !pCS)
- return CFX_FloatRect(0, 0, 0, 0);
-
- CPDF_MeshStream stream(type, pShading->GetFuncs(), pStream, pCS);
- if (!stream.Load())
- return CFX_FloatRect(0, 0, 0, 0);
-
- CFX_FloatRect rect;
- bool bStarted = false;
- bool bGouraud = type == kFreeFormGouraudTriangleMeshShading ||
- type == kLatticeFormGouraudTriangleMeshShading;
-
- int point_count = kSingleCoordinatePair;
- if (type == kTensorProductPatchMeshShading)
- point_count = kTensorCoordinatePairs;
- else if (type == kCoonsPatchMeshShading)
- point_count = kCoonsCoordinatePairs;
-
- int color_count = kSingleColorPerPatch;
- if (type == kCoonsPatchMeshShading || type == kTensorProductPatchMeshShading)
- color_count = kQuadColorsPerPatch;
-
- while (!stream.BitStream()->IsEOF()) {
- uint32_t flag = 0;
- if (type != kLatticeFormGouraudTriangleMeshShading)
- flag = stream.GetFlag();
-
- if (!bGouraud && flag) {
- point_count -= 4;
- color_count -= 2;
- }
-
- for (int i = 0; i < point_count; i++) {
- FX_FLOAT x;
- FX_FLOAT y;
- stream.GetCoords(x, y);
- if (bStarted) {
- rect.UpdateRect(x, y);
- } else {
- rect.InitRect(x, y);
- bStarted = true;
- }
- }
- FX_SAFE_UINT32 nBits = stream.Components();
- nBits *= stream.ComponentBits();
- nBits *= color_count;
- if (!nBits.IsValid())
- break;
-
- stream.BitStream()->SkipBits(nBits.ValueOrDie());
- if (bGouraud)
- stream.BitStream()->ByteAlign();
- }
- rect.Transform(&matrix);
- return rect;
-}
-
} // namespace
CFX_ByteStringC PDF_FindKeyAbbreviationForTesting(const CFX_ByteStringC& abbr) {
@@ -179,1442 +90,6 @@ CFX_ByteStringC PDF_FindValueAbbreviationForTesting(
FX_ArraySize(PDF_InlineValueAbbr), abbr);
}
-CPDF_StreamContentParser::CPDF_StreamContentParser(
- CPDF_Document* pDocument,
- CPDF_Dictionary* pPageResources,
- CPDF_Dictionary* pParentResources,
- const CFX_Matrix* pmtContentToUser,
- CPDF_PageObjectHolder* pObjHolder,
- CPDF_Dictionary* pResources,
- CFX_FloatRect* pBBox,
- CPDF_AllStates* pStates,
- int level)
- : m_pDocument(pDocument),
- m_pPageResources(pPageResources),
- m_pParentResources(pParentResources),
- m_pResources(pResources),
- m_pObjectHolder(pObjHolder),
- m_Level(level),
- m_ParamStartPos(0),
- m_ParamCount(0),
- m_pCurStates(new CPDF_AllStates),
- m_pLastTextObject(nullptr),
- m_DefFontSize(0),
- m_pPathPoints(nullptr),
- m_PathPointCount(0),
- m_PathAllocSize(0),
- m_PathCurrentX(0.0f),
- m_PathCurrentY(0.0f),
- m_PathClipType(0),
- m_pLastImage(nullptr),
- m_pLastImageDict(nullptr),
- m_pLastCloneImageDict(nullptr),
- m_bColored(false),
- m_bResourceMissing(false) {
- if (pmtContentToUser)
- m_mtContentToUser = *pmtContentToUser;
- if (!m_pResources)
- m_pResources = m_pParentResources;
- if (!m_pResources)
- m_pResources = m_pPageResources;
- if (pBBox)
- m_BBox = *pBBox;
- if (pStates) {
- m_pCurStates->Copy(*pStates);
- } else {
- m_pCurStates->m_GeneralState.Emplace();
- m_pCurStates->m_GraphState.Emplace();
- m_pCurStates->m_TextState.Emplace();
- m_pCurStates->m_ColorState.Emplace();
- }
- for (size_t i = 0; i < FX_ArraySize(m_Type3Data); ++i) {
- m_Type3Data[i] = 0.0;
- }
-}
-
-CPDF_StreamContentParser::~CPDF_StreamContentParser() {
- ClearAllParams();
- FX_Free(m_pPathPoints);
- if (m_pLastImageDict) {
- m_pLastImageDict->Release();
- }
- if (m_pLastCloneImageDict) {
- m_pLastCloneImageDict->Release();
- }
-}
-
-int CPDF_StreamContentParser::GetNextParamPos() {
- if (m_ParamCount == PARAM_BUF_SIZE) {
- m_ParamStartPos++;
- if (m_ParamStartPos == PARAM_BUF_SIZE) {
- m_ParamStartPos = 0;
- }
- if (m_ParamBuf[m_ParamStartPos].m_Type == 0) {
- if (CPDF_Object* pObject = m_ParamBuf[m_ParamStartPos].m_pObject)
- pObject->Release();
- }
- return m_ParamStartPos;
- }
- int index = m_ParamStartPos + m_ParamCount;
- if (index >= PARAM_BUF_SIZE) {
- index -= PARAM_BUF_SIZE;
- }
- m_ParamCount++;
- return index;
-}
-
-void CPDF_StreamContentParser::AddNameParam(const FX_CHAR* name, int len) {
- CFX_ByteStringC bsName(name, len);
- ContentParam& param = m_ParamBuf[GetNextParamPos()];
- if (len > 32) {
- param.m_Type = ContentParam::OBJECT;
- param.m_pObject = new CPDF_Name(
- m_pDocument->GetByteStringPool()->Intern(PDF_NameDecode(bsName)));
- } else {
- param.m_Type = ContentParam::NAME;
- if (bsName.Find('#') == -1) {
- FXSYS_memcpy(param.m_Name.m_Buffer, name, len);
- param.m_Name.m_Len = len;
- } else {
- CFX_ByteString str = PDF_NameDecode(bsName);
- FXSYS_memcpy(param.m_Name.m_Buffer, str.c_str(), str.GetLength());
- param.m_Name.m_Len = str.GetLength();
- }
- }
-}
-
-void CPDF_StreamContentParser::AddNumberParam(const FX_CHAR* str, int len) {
- ContentParam& param = m_ParamBuf[GetNextParamPos()];
- param.m_Type = ContentParam::NUMBER;
- param.m_Number.m_bInteger =
- FX_atonum(CFX_ByteStringC(str, len), &param.m_Number.m_Integer);
-}
-
-void CPDF_StreamContentParser::AddObjectParam(CPDF_Object* pObj) {
- ContentParam& param = m_ParamBuf[GetNextParamPos()];
- param.m_Type = ContentParam::OBJECT;
- param.m_pObject = pObj;
-}
-
-void CPDF_StreamContentParser::ClearAllParams() {
- uint32_t index = m_ParamStartPos;
- for (uint32_t i = 0; i < m_ParamCount; i++) {
- if (m_ParamBuf[index].m_Type == 0) {
- if (CPDF_Object* pObject = m_ParamBuf[index].m_pObject)
- pObject->Release();
- }
- index++;
- if (index == PARAM_BUF_SIZE) {
- index = 0;
- }
- }
- m_ParamStartPos = 0;
- m_ParamCount = 0;
-}
-
-CPDF_Object* CPDF_StreamContentParser::GetObject(uint32_t index) {
- if (index >= m_ParamCount) {
- return nullptr;
- }
- int real_index = m_ParamStartPos + m_ParamCount - index - 1;
- if (real_index >= PARAM_BUF_SIZE) {
- real_index -= PARAM_BUF_SIZE;
- }
- ContentParam& param = m_ParamBuf[real_index];
- if (param.m_Type == ContentParam::NUMBER) {
- CPDF_Number* pNumber = param.m_Number.m_bInteger
- ? new CPDF_Number(param.m_Number.m_Integer)
- : new CPDF_Number(param.m_Number.m_Float);
-
- param.m_Type = ContentParam::OBJECT;
- param.m_pObject = pNumber;
- return pNumber;
- }
- if (param.m_Type == ContentParam::NAME) {
- CPDF_Name* pName = new CPDF_Name(m_pDocument->GetByteStringPool()->Intern(
- CFX_ByteString(param.m_Name.m_Buffer, param.m_Name.m_Len)));
- param.m_Type = ContentParam::OBJECT;
- param.m_pObject = pName;
- return pName;
- }
- if (param.m_Type == ContentParam::OBJECT) {
- return param.m_pObject;
- }
- ASSERT(FALSE);
- return nullptr;
-}
-
-CFX_ByteString CPDF_StreamContentParser::GetString(uint32_t index) {
- if (index >= m_ParamCount) {
- return CFX_ByteString();
- }
- int real_index = m_ParamStartPos + m_ParamCount - index - 1;
- if (real_index >= PARAM_BUF_SIZE) {
- real_index -= PARAM_BUF_SIZE;
- }
- ContentParam& param = m_ParamBuf[real_index];
- if (param.m_Type == ContentParam::NAME) {
- return CFX_ByteString(param.m_Name.m_Buffer, param.m_Name.m_Len);
- }
- if (param.m_Type == 0 && param.m_pObject) {
- return param.m_pObject->GetString();
- }
- return CFX_ByteString();
-}
-
-FX_FLOAT CPDF_StreamContentParser::GetNumber(uint32_t index) {
- if (index >= m_ParamCount) {
- return 0;
- }
- int real_index = m_ParamStartPos + m_ParamCount - index - 1;
- if (real_index >= PARAM_BUF_SIZE) {
- real_index -= PARAM_BUF_SIZE;
- }
- ContentParam& param = m_ParamBuf[real_index];
- if (param.m_Type == ContentParam::NUMBER) {
- return param.m_Number.m_bInteger ? (FX_FLOAT)param.m_Number.m_Integer
- : param.m_Number.m_Float;
- }
- if (param.m_Type == 0 && param.m_pObject) {
- return param.m_pObject->GetNumber();
- }
- return 0;
-}
-
-void CPDF_StreamContentParser::SetGraphicStates(CPDF_PageObject* pObj,
- bool bColor,
- bool bText,
- bool bGraph) {
- pObj->m_GeneralState = m_pCurStates->m_GeneralState;
- pObj->m_ClipPath = m_pCurStates->m_ClipPath;
- pObj->m_ContentMark = m_CurContentMark;
- if (bColor) {
- pObj->m_ColorState = m_pCurStates->m_ColorState;
- }
- if (bGraph) {
- pObj->m_GraphState = m_pCurStates->m_GraphState;
- }
- if (bText) {
- pObj->m_TextState = m_pCurStates->m_TextState;
- }
-}
-
-// static
-CPDF_StreamContentParser::OpCodes
-CPDF_StreamContentParser::InitializeOpCodes() {
- return OpCodes({
- {FXBSTR_ID('"', 0, 0, 0),
- &CPDF_StreamContentParser::Handle_NextLineShowText_Space},
- {FXBSTR_ID('\'', 0, 0, 0),
- &CPDF_StreamContentParser::Handle_NextLineShowText},
- {FXBSTR_ID('B', 0, 0, 0),
- &CPDF_StreamContentParser::Handle_FillStrokePath},
- {FXBSTR_ID('B', '*', 0, 0),
- &CPDF_StreamContentParser::Handle_EOFillStrokePath},
- {FXBSTR_ID('B', 'D', 'C', 0),
- &CPDF_StreamContentParser::Handle_BeginMarkedContent_Dictionary},
- {FXBSTR_ID('B', 'I', 0, 0), &CPDF_StreamContentParser::Handle_BeginImage},
- {FXBSTR_ID('B', 'M', 'C', 0),
- &CPDF_StreamContentParser::Handle_BeginMarkedContent},
- {FXBSTR_ID('B', 'T', 0, 0), &CPDF_StreamContentParser::Handle_BeginText},
- {FXBSTR_ID('C', 'S', 0, 0),
- &CPDF_StreamContentParser::Handle_SetColorSpace_Stroke},
- {FXBSTR_ID('D', 'P', 0, 0),
- &CPDF_StreamContentParser::Handle_MarkPlace_Dictionary},
- {FXBSTR_ID('D', 'o', 0, 0),
- &CPDF_StreamContentParser::Handle_ExecuteXObject},
- {FXBSTR_ID('E', 'I', 0, 0), &CPDF_StreamContentParser::Handle_EndImage},
- {FXBSTR_ID('E', 'M', 'C', 0),
- &CPDF_StreamContentParser::Handle_EndMarkedContent},
- {FXBSTR_ID('E', 'T', 0, 0), &CPDF_StreamContentParser::Handle_EndText},
- {FXBSTR_ID('F', 0, 0, 0), &CPDF_StreamContentParser::Handle_FillPathOld},
- {FXBSTR_ID('G', 0, 0, 0),
- &CPDF_StreamContentParser::Handle_SetGray_Stroke},
- {FXBSTR_ID('I', 'D', 0, 0),
- &CPDF_StreamContentParser::Handle_BeginImageData},
- {FXBSTR_ID('J', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineCap},
- {FXBSTR_ID('K', 0, 0, 0),
- &CPDF_StreamContentParser::Handle_SetCMYKColor_Stroke},
- {FXBSTR_ID('M', 0, 0, 0),
- &CPDF_StreamContentParser::Handle_SetMiterLimit},
- {FXBSTR_ID('M', 'P', 0, 0), &CPDF_StreamContentParser::Handle_MarkPlace},
- {FXBSTR_ID('Q', 0, 0, 0),
- &CPDF_StreamContentParser::Handle_RestoreGraphState},
- {FXBSTR_ID('R', 'G', 0, 0),
- &CPDF_StreamContentParser::Handle_SetRGBColor_Stroke},
- {FXBSTR_ID('S', 0, 0, 0), &CPDF_StreamContentParser::Handle_StrokePath},
- {FXBSTR_ID('S', 'C', 0, 0),
- &CPDF_StreamContentParser::Handle_SetColor_Stroke},
- {FXBSTR_ID('S', 'C', 'N', 0),
- &CPDF_StreamContentParser::Handle_SetColorPS_Stroke},
- {FXBSTR_ID('T', '*', 0, 0),
- &CPDF_StreamContentParser::Handle_MoveToNextLine},
- {FXBSTR_ID('T', 'D', 0, 0),
- &CPDF_StreamContentParser::Handle_MoveTextPoint_SetLeading},
- {FXBSTR_ID('T', 'J', 0, 0),
- &CPDF_StreamContentParser::Handle_ShowText_Positioning},
- {FXBSTR_ID('T', 'L', 0, 0),
- &CPDF_StreamContentParser::Handle_SetTextLeading},
- {FXBSTR_ID('T', 'c', 0, 0),
- &CPDF_StreamContentParser::Handle_SetCharSpace},
- {FXBSTR_ID('T', 'd', 0, 0),
- &CPDF_StreamContentParser::Handle_MoveTextPoint},
- {FXBSTR_ID('T', 'f', 0, 0), &CPDF_StreamContentParser::Handle_SetFont},
- {FXBSTR_ID('T', 'j', 0, 0), &CPDF_StreamContentParser::Handle_ShowText},
- {FXBSTR_ID('T', 'm', 0, 0),
- &CPDF_StreamContentParser::Handle_SetTextMatrix},
- {FXBSTR_ID('T', 'r', 0, 0),
- &CPDF_StreamContentParser::Handle_SetTextRenderMode},
- {FXBSTR_ID('T', 's', 0, 0),
- &CPDF_StreamContentParser::Handle_SetTextRise},
- {FXBSTR_ID('T', 'w', 0, 0),
- &CPDF_StreamContentParser::Handle_SetWordSpace},
- {FXBSTR_ID('T', 'z', 0, 0),
- &CPDF_StreamContentParser::Handle_SetHorzScale},
- {FXBSTR_ID('W', 0, 0, 0), &CPDF_StreamContentParser::Handle_Clip},
- {FXBSTR_ID('W', '*', 0, 0), &CPDF_StreamContentParser::Handle_EOClip},
- {FXBSTR_ID('b', 0, 0, 0),
- &CPDF_StreamContentParser::Handle_CloseFillStrokePath},
- {FXBSTR_ID('b', '*', 0, 0),
- &CPDF_StreamContentParser::Handle_CloseEOFillStrokePath},
- {FXBSTR_ID('c', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_123},
- {FXBSTR_ID('c', 'm', 0, 0),
- &CPDF_StreamContentParser::Handle_ConcatMatrix},
- {FXBSTR_ID('c', 's', 0, 0),
- &CPDF_StreamContentParser::Handle_SetColorSpace_Fill},
- {FXBSTR_ID('d', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetDash},
- {FXBSTR_ID('d', '0', 0, 0),
- &CPDF_StreamContentParser::Handle_SetCharWidth},
- {FXBSTR_ID('d', '1', 0, 0),
- &CPDF_StreamContentParser::Handle_SetCachedDevice},
- {FXBSTR_ID('f', 0, 0, 0), &CPDF_StreamContentParser::Handle_FillPath},
- {FXBSTR_ID('f', '*', 0, 0), &CPDF_StreamContentParser::Handle_EOFillPath},
- {FXBSTR_ID('g', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetGray_Fill},
- {FXBSTR_ID('g', 's', 0, 0),
- &CPDF_StreamContentParser::Handle_SetExtendGraphState},
- {FXBSTR_ID('h', 0, 0, 0), &CPDF_StreamContentParser::Handle_ClosePath},
- {FXBSTR_ID('i', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetFlat},
- {FXBSTR_ID('j', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineJoin},
- {FXBSTR_ID('k', 0, 0, 0),
- &CPDF_StreamContentParser::Handle_SetCMYKColor_Fill},
- {FXBSTR_ID('l', 0, 0, 0), &CPDF_StreamContentParser::Handle_LineTo},
- {FXBSTR_ID('m', 0, 0, 0), &CPDF_StreamContentParser::Handle_MoveTo},
- {FXBSTR_ID('n', 0, 0, 0), &CPDF_StreamContentParser::Handle_EndPath},
- {FXBSTR_ID('q', 0, 0, 0),
- &CPDF_StreamContentParser::Handle_SaveGraphState},
- {FXBSTR_ID('r', 'e', 0, 0), &CPDF_StreamContentParser::Handle_Rectangle},
- {FXBSTR_ID('r', 'g', 0, 0),
- &CPDF_StreamContentParser::Handle_SetRGBColor_Fill},
- {FXBSTR_ID('r', 'i', 0, 0),
- &CPDF_StreamContentParser::Handle_SetRenderIntent},
- {FXBSTR_ID('s', 0, 0, 0),
- &CPDF_StreamContentParser::Handle_CloseStrokePath},
- {FXBSTR_ID('s', 'c', 0, 0),
- &CPDF_StreamContentParser::Handle_SetColor_Fill},
- {FXBSTR_ID('s', 'c', 'n', 0),
- &CPDF_StreamContentParser::Handle_SetColorPS_Fill},
- {FXBSTR_ID('s', 'h', 0, 0), &CPDF_StreamContentParser::Handle_ShadeFill},
- {FXBSTR_ID('v', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_23},
- {FXBSTR_ID('w', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineWidth},
- {FXBSTR_ID('y', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_13},
- });
-}
-
-void CPDF_StreamContentParser::OnOperator(const FX_CHAR* op) {
- int i = 0;
- uint32_t opid = 0;
- while (i < 4 && op[i]) {
- opid = (opid << 8) + op[i];
- i++;
- }
- while (i < 4) {
- opid <<= 8;
- i++;
- }
-
- static const OpCodes s_OpCodes = InitializeOpCodes();
-
- auto it = s_OpCodes.find(opid);
- if (it != s_OpCodes.end())
- (this->*it->second)();
-}
-
-void CPDF_StreamContentParser::Handle_CloseFillStrokePath() {
- Handle_ClosePath();
- AddPathObject(FXFILL_WINDING, true);
-}
-
-void CPDF_StreamContentParser::Handle_FillStrokePath() {
- AddPathObject(FXFILL_WINDING, true);
-}
-
-void CPDF_StreamContentParser::Handle_CloseEOFillStrokePath() {
- AddPathPoint(m_PathStartX, m_PathStartY, FXPT_LINETO | FXPT_CLOSEFIGURE);
- AddPathObject(FXFILL_ALTERNATE, true);
-}
-
-void CPDF_StreamContentParser::Handle_EOFillStrokePath() {
- AddPathObject(FXFILL_ALTERNATE, true);
-}
-
-void CPDF_StreamContentParser::Handle_BeginMarkedContent_Dictionary() {
- CFX_ByteString tag = GetString(1);
- CPDF_Object* pProperty = GetObject(0);
- if (!pProperty) {
- return;
- }
- bool bDirect = true;
- if (pProperty->IsName()) {
- pProperty = FindResourceObj("Properties", pProperty->GetString());
- if (!pProperty)
- return;
- bDirect = false;
- }
- if (CPDF_Dictionary* pDict = pProperty->AsDictionary()) {
- m_CurContentMark.AddMark(tag, pDict, bDirect);
- }
-}
-
-void CPDF_StreamContentParser::Handle_BeginImage() {
- FX_FILESIZE savePos = m_pSyntax->GetPos();
- CPDF_Dictionary* pDict =
- new CPDF_Dictionary(m_pDocument->GetByteStringPool());
- while (1) {
- CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
- if (type == CPDF_StreamParser::Keyword) {
- CFX_ByteString bsKeyword(m_pSyntax->GetWordBuf(),
- m_pSyntax->GetWordSize());
- if (bsKeyword != "ID") {
- m_pSyntax->SetPos(savePos);
- pDict->Release();
- return;
- }
- }
- if (type != CPDF_StreamParser::Name) {
- break;
- }
- CFX_ByteString key((const FX_CHAR*)m_pSyntax->GetWordBuf() + 1,
- m_pSyntax->GetWordSize() - 1);
- std::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> pObj(
- m_pSyntax->ReadNextObject(false, 0));
- if (!key.IsEmpty()) {
- uint32_t dwObjNum = pObj ? pObj->GetObjNum() : 0;
- if (dwObjNum)
- pDict->SetReferenceFor(key, m_pDocument, dwObjNum);
- else
- pDict->SetFor(key, pObj.release());
- }
- }
- PDF_ReplaceAbbr(pDict);
- CPDF_Object* pCSObj = nullptr;
- if (pDict->KeyExist("ColorSpace")) {
- pCSObj = pDict->GetDirectObjectFor("ColorSpace");
- if (pCSObj->IsName()) {
- CFX_ByteString name = pCSObj->GetString();
- if (name != "DeviceRGB" && name != "DeviceGray" && name != "DeviceCMYK") {
- pCSObj = FindResourceObj("ColorSpace", name);
- if (pCSObj && pCSObj->IsInline()) {
- pCSObj = pCSObj->Clone();
- pDict->SetFor("ColorSpace", pCSObj);
- }
- }
- }
- }
- pDict->SetNameFor("Subtype", "Image");
- UniqueStream pStream(m_pSyntax->ReadInlineStream(m_pDocument, pDict, pCSObj));
- bool bGaveDictAway = !!pStream;
- while (1) {
- CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
- if (type == CPDF_StreamParser::EndOfData) {
- break;
- }
- if (type != CPDF_StreamParser::Keyword) {
- continue;
- }
- if (m_pSyntax->GetWordSize() == 2 && m_pSyntax->GetWordBuf()[0] == 'E' &&
- m_pSyntax->GetWordBuf()[1] == 'I') {
- break;
- }
- }
- CPDF_ImageObject* pImgObj = AddImage(std::move(pStream));
- if (!pImgObj && !bGaveDictAway)
- pDict->Release();
-}
-
-void CPDF_StreamContentParser::Handle_BeginMarkedContent() {
- m_CurContentMark.AddMark(GetString(0), nullptr, FALSE);
-}
-
-void CPDF_StreamContentParser::Handle_BeginText() {
- m_pCurStates->m_TextMatrix.Set(1.0f, 0, 0, 1.0f, 0, 0);
- OnChangeTextMatrix();
- m_pCurStates->m_TextX = 0;
- m_pCurStates->m_TextY = 0;
- m_pCurStates->m_TextLineX = 0;
- m_pCurStates->m_TextLineY = 0;
-}
-
-void CPDF_StreamContentParser::Handle_CurveTo_123() {
- AddPathPoint(GetNumber(5), GetNumber(4), FXPT_BEZIERTO);
- AddPathPoint(GetNumber(3), GetNumber(2), FXPT_BEZIERTO);
- AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
-}
-
-void CPDF_StreamContentParser::Handle_ConcatMatrix() {
- CFX_Matrix new_matrix(GetNumber(5), GetNumber(4), GetNumber(3), GetNumber(2),
- GetNumber(1), GetNumber(0));
- new_matrix.Concat(m_pCurStates->m_CTM);
- m_pCurStates->m_CTM = new_matrix;
- OnChangeTextMatrix();
-}
-
-void CPDF_StreamContentParser::Handle_SetColorSpace_Fill() {
- CPDF_ColorSpace* pCS = FindColorSpace(GetString(0));
- if (!pCS)
- return;
-
- m_pCurStates->m_ColorState.GetMutableFillColor()->SetColorSpace(pCS);
-}
-
-void CPDF_StreamContentParser::Handle_SetColorSpace_Stroke() {
- CPDF_ColorSpace* pCS = FindColorSpace(GetString(0));
- if (!pCS)
- return;
-
- m_pCurStates->m_ColorState.GetMutableStrokeColor()->SetColorSpace(pCS);
-}
-
-void CPDF_StreamContentParser::Handle_SetDash() {
- CPDF_Array* pArray = ToArray(GetObject(1));
- if (!pArray)
- return;
-
- m_pCurStates->SetLineDash(pArray, GetNumber(0), 1.0f);
-}
-
-void CPDF_StreamContentParser::Handle_SetCharWidth() {
- m_Type3Data[0] = GetNumber(1);
- m_Type3Data[1] = GetNumber(0);
- m_bColored = true;
-}
-
-void CPDF_StreamContentParser::Handle_SetCachedDevice() {
- for (int i = 0; i < 6; i++) {
- m_Type3Data[i] = GetNumber(5 - i);
- }
- m_bColored = false;
-}
-
-void CPDF_StreamContentParser::Handle_ExecuteXObject() {
- CFX_ByteString name = GetString(0);
- if (name == m_LastImageName && m_pLastImage && m_pLastImage->GetStream() &&
- m_pLastImage->GetStream()->GetObjNum()) {
- AddImage(m_pLastImage);
- return;
- }
-
- CPDF_Stream* pXObject = ToStream(FindResourceObj("XObject", name));
- if (!pXObject) {
- m_bResourceMissing = true;
- return;
- }
-
- CFX_ByteString type;
- if (pXObject->GetDict())
- type = pXObject->GetDict()->GetStringFor("Subtype");
-
- if (type == "Image") {
- CPDF_ImageObject* pObj = AddImage(pXObject->GetObjNum());
- m_LastImageName = name;
- m_pLastImage = pObj->GetImage();
- if (!m_pObjectHolder->HasImageMask())
- m_pObjectHolder->SetHasImageMask(m_pLastImage->IsMask());
- } else if (type == "Form") {
- AddForm(pXObject);
- }
-}
-
-void CPDF_StreamContentParser::AddForm(CPDF_Stream* pStream) {
- std::unique_ptr<CPDF_FormObject> pFormObj(new CPDF_FormObject);
- pFormObj->m_pForm.reset(
- new CPDF_Form(m_pDocument, m_pPageResources, pStream, m_pResources));
- pFormObj->m_FormMatrix = m_pCurStates->m_CTM;
- pFormObj->m_FormMatrix.Concat(m_mtContentToUser);
- CPDF_AllStates status;
- status.m_GeneralState = m_pCurStates->m_GeneralState;
- status.m_GraphState = m_pCurStates->m_GraphState;
- status.m_ColorState = m_pCurStates->m_ColorState;
- status.m_TextState = m_pCurStates->m_TextState;
- pFormObj->m_pForm->ParseContent(&status, nullptr, nullptr, m_Level + 1);
- if (!m_pObjectHolder->BackgroundAlphaNeeded() &&
- pFormObj->m_pForm->BackgroundAlphaNeeded()) {
- m_pObjectHolder->SetBackgroundAlphaNeeded(TRUE);
- }
- pFormObj->CalcBoundingBox();
- SetGraphicStates(pFormObj.get(), true, true, true);
- m_pObjectHolder->GetPageObjectList()->push_back(std::move(pFormObj));
-}
-
-CPDF_ImageObject* CPDF_StreamContentParser::AddImage(UniqueStream pStream) {
- if (!pStream)
- return nullptr;
-
- auto pImageObj = pdfium::MakeUnique<CPDF_ImageObject>();
- pImageObj->SetOwnedImage(
- pdfium::MakeUnique<CPDF_Image>(m_pDocument, pStream.release(), true));
-
- return AddImageObject(std::move(pImageObj));
-}
-
-CPDF_ImageObject* CPDF_StreamContentParser::AddImage(uint32_t streamObjNum) {
- CPDF_Stream* pStream = ToStream(m_pDocument->GetIndirectObject(streamObjNum));
- if (!pStream)
- return nullptr;
-
- auto pImageObj = pdfium::MakeUnique<CPDF_ImageObject>();
- pImageObj->SetUnownedImage(m_pDocument->LoadImageF(pStream));
- return AddImageObject(std::move(pImageObj));
-}
-
-CPDF_ImageObject* CPDF_StreamContentParser::AddImage(CPDF_Image* pImage) {
- if (!pImage)
- return nullptr;
-
- auto pImageObj = pdfium::MakeUnique<CPDF_ImageObject>();
- pImageObj->SetUnownedImage(
- m_pDocument->GetPageData()->GetImage(pImage->GetStream()));
-
- return AddImageObject(std::move(pImageObj));
-}
-
-CPDF_ImageObject* CPDF_StreamContentParser::AddImageObject(
- std::unique_ptr<CPDF_ImageObject> pImageObj) {
- SetGraphicStates(pImageObj.get(), pImageObj->GetImage()->IsMask(), false,
- false);
-
- CFX_Matrix ImageMatrix = m_pCurStates->m_CTM;
- ImageMatrix.Concat(m_mtContentToUser);
- pImageObj->m_Matrix = ImageMatrix;
- pImageObj->CalcBoundingBox();
-
- CPDF_ImageObject* pRet = pImageObj.get();
- m_pObjectHolder->GetPageObjectList()->push_back(std::move(pImageObj));
- return pRet;
-}
-
-void CPDF_StreamContentParser::Handle_MarkPlace_Dictionary() {}
-
-void CPDF_StreamContentParser::Handle_EndImage() {}
-
-void CPDF_StreamContentParser::Handle_EndMarkedContent() {
- if (m_CurContentMark)
- m_CurContentMark.DeleteLastMark();
-}
-
-void CPDF_StreamContentParser::Handle_EndText() {
- if (m_ClipTextList.empty())
- return;
-
- if (TextRenderingModeIsClipMode(m_pCurStates->m_TextState.GetTextMode()))
- m_pCurStates->m_ClipPath.AppendTexts(&m_ClipTextList);
-
- m_ClipTextList.clear();
-}
-
-void CPDF_StreamContentParser::Handle_FillPath() {
- AddPathObject(FXFILL_WINDING, false);
-}
-
-void CPDF_StreamContentParser::Handle_FillPathOld() {
- AddPathObject(FXFILL_WINDING, false);
-}
-
-void CPDF_StreamContentParser::Handle_EOFillPath() {
- AddPathObject(FXFILL_ALTERNATE, false);
-}
-
-void CPDF_StreamContentParser::Handle_SetGray_Fill() {
- FX_FLOAT value = GetNumber(0);
- CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
- m_pCurStates->m_ColorState.SetFillColor(pCS, &value, 1);
-}
-
-void CPDF_StreamContentParser::Handle_SetGray_Stroke() {
- FX_FLOAT value = GetNumber(0);
- CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
- m_pCurStates->m_ColorState.SetStrokeColor(pCS, &value, 1);
-}
-
-void CPDF_StreamContentParser::Handle_SetExtendGraphState() {
- CFX_ByteString name = GetString(0);
- CPDF_Dictionary* pGS = ToDictionary(FindResourceObj("ExtGState", name));
- if (!pGS) {
- m_bResourceMissing = true;
- return;
- }
- m_pCurStates->ProcessExtGS(pGS, this);
-}
-
-void CPDF_StreamContentParser::Handle_ClosePath() {
- if (m_PathPointCount == 0) {
- return;
- }
- if (m_PathStartX != m_PathCurrentX || m_PathStartY != m_PathCurrentY) {
- AddPathPoint(m_PathStartX, m_PathStartY, FXPT_LINETO | FXPT_CLOSEFIGURE);
- } else if (m_pPathPoints[m_PathPointCount - 1].m_Flag != FXPT_MOVETO) {
- m_pPathPoints[m_PathPointCount - 1].m_Flag |= FXPT_CLOSEFIGURE;
- }
-}
-
-void CPDF_StreamContentParser::Handle_SetFlat() {
- m_pCurStates->m_GeneralState.SetFlatness(GetNumber(0));
-}
-
-void CPDF_StreamContentParser::Handle_BeginImageData() {}
-
-void CPDF_StreamContentParser::Handle_SetLineJoin() {
- m_pCurStates->m_GraphState.SetLineJoin(
- static_cast<CFX_GraphStateData::LineJoin>(GetInteger(0)));
-}
-
-void CPDF_StreamContentParser::Handle_SetLineCap() {
- m_pCurStates->m_GraphState.SetLineCap(
- static_cast<CFX_GraphStateData::LineCap>(GetInteger(0)));
-}
-
-void CPDF_StreamContentParser::Handle_SetCMYKColor_Fill() {
- if (m_ParamCount != 4)
- return;
-
- FX_FLOAT values[4];
- for (int i = 0; i < 4; i++) {
- values[i] = GetNumber(3 - i);
- }
- CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
- m_pCurStates->m_ColorState.SetFillColor(pCS, values, 4);
-}
-
-void CPDF_StreamContentParser::Handle_SetCMYKColor_Stroke() {
- if (m_ParamCount != 4)
- return;
-
- FX_FLOAT values[4];
- for (int i = 0; i < 4; i++) {
- values[i] = GetNumber(3 - i);
- }
- CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
- m_pCurStates->m_ColorState.SetStrokeColor(pCS, values, 4);
-}
-
-void CPDF_StreamContentParser::Handle_LineTo() {
- if (m_ParamCount != 2)
- return;
-
- AddPathPoint(GetNumber(1), GetNumber(0), FXPT_LINETO);
-}
-
-void CPDF_StreamContentParser::Handle_MoveTo() {
- if (m_ParamCount != 2)
- return;
-
- AddPathPoint(GetNumber(1), GetNumber(0), FXPT_MOVETO);
- ParsePathObject();
-}
-
-void CPDF_StreamContentParser::Handle_SetMiterLimit() {
- m_pCurStates->m_GraphState.SetMiterLimit(GetNumber(0));
-}
-
-void CPDF_StreamContentParser::Handle_MarkPlace() {}
-
-void CPDF_StreamContentParser::Handle_EndPath() {
- AddPathObject(0, false);
-}
-
-void CPDF_StreamContentParser::Handle_SaveGraphState() {
- std::unique_ptr<CPDF_AllStates> pStates(new CPDF_AllStates);
- pStates->Copy(*m_pCurStates);
- m_StateStack.push_back(std::move(pStates));
-}
-
-void CPDF_StreamContentParser::Handle_RestoreGraphState() {
- if (m_StateStack.empty())
- return;
- std::unique_ptr<CPDF_AllStates> pStates = std::move(m_StateStack.back());
- m_StateStack.pop_back();
- m_pCurStates->Copy(*pStates);
-}
-
-void CPDF_StreamContentParser::Handle_Rectangle() {
- FX_FLOAT x = GetNumber(3), y = GetNumber(2);
- FX_FLOAT w = GetNumber(1), h = GetNumber(0);
- AddPathRect(x, y, w, h);
-}
-
-void CPDF_StreamContentParser::AddPathRect(FX_FLOAT x,
- FX_FLOAT y,
- FX_FLOAT w,
- FX_FLOAT h) {
- AddPathPoint(x, y, FXPT_MOVETO);
- AddPathPoint(x + w, y, FXPT_LINETO);
- AddPathPoint(x + w, y + h, FXPT_LINETO);
- AddPathPoint(x, y + h, FXPT_LINETO);
- AddPathPoint(x, y, FXPT_LINETO | FXPT_CLOSEFIGURE);
-}
-
-void CPDF_StreamContentParser::Handle_SetRGBColor_Fill() {
- if (m_ParamCount != 3)
- return;
-
- FX_FLOAT values[3];
- for (int i = 0; i < 3; i++) {
- values[i] = GetNumber(2 - i);
- }
- CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
- m_pCurStates->m_ColorState.SetFillColor(pCS, values, 3);
-}
-
-void CPDF_StreamContentParser::Handle_SetRGBColor_Stroke() {
- if (m_ParamCount != 3)
- return;
-
- FX_FLOAT values[3];
- for (int i = 0; i < 3; i++) {
- values[i] = GetNumber(2 - i);
- }
- CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
- m_pCurStates->m_ColorState.SetStrokeColor(pCS, values, 3);
-}
-
-void CPDF_StreamContentParser::Handle_SetRenderIntent() {}
-
-void CPDF_StreamContentParser::Handle_CloseStrokePath() {
- Handle_ClosePath();
- AddPathObject(0, true);
-}
-
-void CPDF_StreamContentParser::Handle_StrokePath() {
- AddPathObject(0, true);
-}
-
-void CPDF_StreamContentParser::Handle_SetColor_Fill() {
- FX_FLOAT values[4];
- int nargs = m_ParamCount;
- if (nargs > 4) {
- nargs = 4;
- }
- for (int i = 0; i < nargs; i++) {
- values[i] = GetNumber(nargs - i - 1);
- }
- m_pCurStates->m_ColorState.SetFillColor(nullptr, values, nargs);
-}
-
-void CPDF_StreamContentParser::Handle_SetColor_Stroke() {
- FX_FLOAT values[4];
- int nargs = m_ParamCount;
- if (nargs > 4) {
- nargs = 4;
- }
- for (int i = 0; i < nargs; i++) {
- values[i] = GetNumber(nargs - i - 1);
- }
- m_pCurStates->m_ColorState.SetStrokeColor(nullptr, values, nargs);
-}
-
-void CPDF_StreamContentParser::Handle_SetColorPS_Fill() {
- CPDF_Object* pLastParam = GetObject(0);
- if (!pLastParam) {
- return;
- }
- uint32_t nargs = m_ParamCount;
- uint32_t nvalues = nargs;
- if (pLastParam->IsName())
- nvalues--;
- FX_FLOAT* values = nullptr;
- if (nvalues) {
- values = FX_Alloc(FX_FLOAT, nvalues);
- for (uint32_t i = 0; i < nvalues; i++) {
- values[i] = GetNumber(nargs - i - 1);
- }
- }
- if (nvalues != nargs) {
- CPDF_Pattern* pPattern = FindPattern(GetString(0), false);
- if (pPattern) {
- m_pCurStates->m_ColorState.SetFillPattern(pPattern, values, nvalues);
- }
- } else {
- m_pCurStates->m_ColorState.SetFillColor(nullptr, values, nvalues);
- }
- FX_Free(values);
-}
-
-void CPDF_StreamContentParser::Handle_SetColorPS_Stroke() {
- CPDF_Object* pLastParam = GetObject(0);
- if (!pLastParam) {
- return;
- }
- int nargs = m_ParamCount;
- int nvalues = nargs;
- if (pLastParam->IsName())
- nvalues--;
-
- FX_FLOAT* values = nullptr;
- if (nvalues) {
- values = FX_Alloc(FX_FLOAT, nvalues);
- for (int i = 0; i < nvalues; i++) {
- values[i] = GetNumber(nargs - i - 1);
- }
- }
- if (nvalues != nargs) {
- CPDF_Pattern* pPattern = FindPattern(GetString(0), false);
- if (pPattern) {
- m_pCurStates->m_ColorState.SetStrokePattern(pPattern, values, nvalues);
- }
- } else {
- m_pCurStates->m_ColorState.SetStrokeColor(nullptr, values, nvalues);
- }
- FX_Free(values);
-}
-
-void CPDF_StreamContentParser::Handle_ShadeFill() {
- CPDF_Pattern* pPattern = FindPattern(GetString(0), true);
- if (!pPattern)
- return;
-
- CPDF_ShadingPattern* pShading = pPattern->AsShadingPattern();
- if (!pShading)
- return;
-
- if (!pShading->IsShadingObject() || !pShading->Load())
- return;
-
- std::unique_ptr<CPDF_ShadingObject> pObj(new CPDF_ShadingObject);
- pObj->m_pShading = pShading;
- SetGraphicStates(pObj.get(), false, false, false);
- pObj->m_Matrix = m_pCurStates->m_CTM;
- pObj->m_Matrix.Concat(m_mtContentToUser);
- CFX_FloatRect bbox =
- pObj->m_ClipPath ? pObj->m_ClipPath.GetClipBox() : m_BBox;
- if (pShading->IsMeshShading())
- bbox.Intersect(GetShadingBBox(pShading, pObj->m_Matrix));
- pObj->m_Left = bbox.left;
- pObj->m_Right = bbox.right;
- pObj->m_Top = bbox.top;
- pObj->m_Bottom = bbox.bottom;
- m_pObjectHolder->GetPageObjectList()->push_back(std::move(pObj));
-}
-
-void CPDF_StreamContentParser::Handle_SetCharSpace() {
- m_pCurStates->m_TextState.SetCharSpace(GetNumber(0));
-}
-
-void CPDF_StreamContentParser::Handle_MoveTextPoint() {
- m_pCurStates->m_TextLineX += GetNumber(1);
- m_pCurStates->m_TextLineY += GetNumber(0);
- m_pCurStates->m_TextX = m_pCurStates->m_TextLineX;
- m_pCurStates->m_TextY = m_pCurStates->m_TextLineY;
-}
-
-void CPDF_StreamContentParser::Handle_MoveTextPoint_SetLeading() {
- Handle_MoveTextPoint();
- m_pCurStates->m_TextLeading = -GetNumber(0);
-}
-
-void CPDF_StreamContentParser::Handle_SetFont() {
- FX_FLOAT fs = GetNumber(0);
- if (fs == 0) {
- fs = m_DefFontSize;
- }
- m_pCurStates->m_TextState.SetFontSize(fs);
- CPDF_Font* pFont = FindFont(GetString(1));
- if (pFont) {
- m_pCurStates->m_TextState.SetFont(pFont);
- }
-}
-
-CPDF_Object* CPDF_StreamContentParser::FindResourceObj(
- const CFX_ByteString& type,
- const CFX_ByteString& name) {
- if (!m_pResources)
- return nullptr;
- CPDF_Dictionary* pDict = m_pResources->GetDictFor(type);
- if (pDict)
- return pDict->GetDirectObjectFor(name);
- if (m_pResources == m_pPageResources || !m_pPageResources)
- return nullptr;
-
- CPDF_Dictionary* pPageDict = m_pPageResources->GetDictFor(type);
- return pPageDict ? pPageDict->GetDirectObjectFor(name) : nullptr;
-}
-
-CPDF_Font* CPDF_StreamContentParser::FindFont(const CFX_ByteString& name) {
- CPDF_Dictionary* pFontDict = ToDictionary(FindResourceObj("Font", name));
- if (!pFontDict) {
- m_bResourceMissing = true;
- return CPDF_Font::GetStockFont(m_pDocument, "Helvetica");
- }
-
- CPDF_Font* pFont = m_pDocument->LoadFont(pFontDict);
- if (pFont && pFont->IsType3Font()) {
- pFont->AsType3Font()->SetPageResources(m_pResources);
- pFont->AsType3Font()->CheckType3FontMetrics();
- }
- return pFont;
-}
-
-CPDF_ColorSpace* CPDF_StreamContentParser::FindColorSpace(
- const CFX_ByteString& name) {
- if (name == "Pattern") {
- return CPDF_ColorSpace::GetStockCS(PDFCS_PATTERN);
- }
- if (name == "DeviceGray" || name == "DeviceCMYK" || name == "DeviceRGB") {
- CFX_ByteString defname = "Default";
- defname += name.Mid(7);
- CPDF_Object* pDefObj = FindResourceObj("ColorSpace", defname);
- if (!pDefObj) {
- if (name == "DeviceGray") {
- return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
- }
- if (name == "DeviceRGB") {
- return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
- }
- return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
- }
- return m_pDocument->LoadColorSpace(pDefObj);
- }
- CPDF_Object* pCSObj = FindResourceObj("ColorSpace", name);
- if (!pCSObj) {
- m_bResourceMissing = true;
- return nullptr;
- }
- return m_pDocument->LoadColorSpace(pCSObj);
-}
-
-CPDF_Pattern* CPDF_StreamContentParser::FindPattern(const CFX_ByteString& name,
- bool bShading) {
- CPDF_Object* pPattern =
- FindResourceObj(bShading ? "Shading" : "Pattern", name);
- if (!pPattern || (!pPattern->IsDictionary() && !pPattern->IsStream())) {
- m_bResourceMissing = true;
- return nullptr;
- }
- return m_pDocument->LoadPattern(pPattern, bShading,
- m_pCurStates->m_ParentMatrix);
-}
-
-void CPDF_StreamContentParser::ConvertTextSpace(FX_FLOAT& x, FX_FLOAT& y) {
- m_pCurStates->m_TextMatrix.Transform(x, y, x, y);
- ConvertUserSpace(x, y);
-}
-
-void CPDF_StreamContentParser::ConvertUserSpace(FX_FLOAT& x, FX_FLOAT& y) {
- m_pCurStates->m_CTM.Transform(x, y, x, y);
- m_mtContentToUser.Transform(x, y, x, y);
-}
-
-void CPDF_StreamContentParser::AddTextObject(CFX_ByteString* pStrs,
- FX_FLOAT fInitKerning,
- FX_FLOAT* pKerning,
- int nsegs) {
- CPDF_Font* pFont = m_pCurStates->m_TextState.GetFont();
- if (!pFont) {
- return;
- }
- if (fInitKerning != 0) {
- if (!pFont->IsVertWriting()) {
- m_pCurStates->m_TextX -=
- (fInitKerning * m_pCurStates->m_TextState.GetFontSize()) / 1000;
- } else {
- m_pCurStates->m_TextY -=
- (fInitKerning * m_pCurStates->m_TextState.GetFontSize()) / 1000;
- }
- }
- if (nsegs == 0) {
- return;
- }
- const TextRenderingMode text_mode =
- pFont->IsType3Font() ? TextRenderingMode::MODE_FILL
- : m_pCurStates->m_TextState.GetTextMode();
- {
- std::unique_ptr<CPDF_TextObject> pText(new CPDF_TextObject);
- m_pLastTextObject = pText.get();
- SetGraphicStates(m_pLastTextObject, true, true, true);
- if (TextRenderingModeIsStrokeMode(text_mode)) {
- FX_FLOAT* pCTM = pText->m_TextState.GetMutableCTM();
- pCTM[0] = m_pCurStates->m_CTM.a;
- pCTM[1] = m_pCurStates->m_CTM.c;
- pCTM[2] = m_pCurStates->m_CTM.b;
- pCTM[3] = m_pCurStates->m_CTM.d;
- }
- pText->SetSegments(pStrs, pKerning, nsegs);
- pText->m_PosX = m_pCurStates->m_TextX;
- pText->m_PosY = m_pCurStates->m_TextY + m_pCurStates->m_TextRise;
- ConvertTextSpace(pText->m_PosX, pText->m_PosY);
- FX_FLOAT x_advance;
- FX_FLOAT y_advance;
- pText->CalcPositionData(&x_advance, &y_advance,
- m_pCurStates->m_TextHorzScale);
- m_pCurStates->m_TextX += x_advance;
- m_pCurStates->m_TextY += y_advance;
- if (TextRenderingModeIsClipMode(text_mode)) {
- m_ClipTextList.push_back(
- std::unique_ptr<CPDF_TextObject>(pText->Clone()));
- }
- m_pObjectHolder->GetPageObjectList()->push_back(std::move(pText));
- }
- if (pKerning && pKerning[nsegs - 1] != 0) {
- if (!pFont->IsVertWriting()) {
- m_pCurStates->m_TextX -=
- (pKerning[nsegs - 1] * m_pCurStates->m_TextState.GetFontSize()) /
- 1000;
- } else {
- m_pCurStates->m_TextY -=
- (pKerning[nsegs - 1] * m_pCurStates->m_TextState.GetFontSize()) /
- 1000;
- }
- }
-}
-
-void CPDF_StreamContentParser::Handle_ShowText() {
- CFX_ByteString str = GetString(0);
- if (str.IsEmpty()) {
- return;
- }
- AddTextObject(&str, 0, nullptr, 1);
-}
-
-void CPDF_StreamContentParser::Handle_ShowText_Positioning() {
- CPDF_Array* pArray = ToArray(GetObject(0));
- if (!pArray)
- return;
-
- size_t n = pArray->GetCount();
- size_t nsegs = 0;
- for (size_t i = 0; i < n; i++) {
- if (pArray->GetDirectObjectAt(i)->IsString())
- nsegs++;
- }
- if (nsegs == 0) {
- for (size_t i = 0; i < n; i++) {
- m_pCurStates->m_TextX -=
- (pArray->GetNumberAt(i) * m_pCurStates->m_TextState.GetFontSize()) /
- 1000;
- }
- return;
- }
- CFX_ByteString* pStrs = new CFX_ByteString[nsegs];
- FX_FLOAT* pKerning = FX_Alloc(FX_FLOAT, nsegs);
- size_t iSegment = 0;
- FX_FLOAT fInitKerning = 0;
- for (size_t i = 0; i < n; i++) {
- CPDF_Object* pObj = pArray->GetDirectObjectAt(i);
- if (pObj->IsString()) {
- CFX_ByteString str = pObj->GetString();
- if (str.IsEmpty()) {
- continue;
- }
- pStrs[iSegment] = str;
- pKerning[iSegment++] = 0;
- } else {
- FX_FLOAT num = pObj ? pObj->GetNumber() : 0;
- if (iSegment == 0) {
- fInitKerning += num;
- } else {
- pKerning[iSegment - 1] += num;
- }
- }
- }
- AddTextObject(pStrs, fInitKerning, pKerning, iSegment);
- delete[] pStrs;
- FX_Free(pKerning);
-}
-
-void CPDF_StreamContentParser::Handle_SetTextLeading() {
- m_pCurStates->m_TextLeading = GetNumber(0);
-}
-
-void CPDF_StreamContentParser::Handle_SetTextMatrix() {
- m_pCurStates->m_TextMatrix.Set(GetNumber(5), GetNumber(4), GetNumber(3),
- GetNumber(2), GetNumber(1), GetNumber(0));
- OnChangeTextMatrix();
- m_pCurStates->m_TextX = 0;
- m_pCurStates->m_TextY = 0;
- m_pCurStates->m_TextLineX = 0;
- m_pCurStates->m_TextLineY = 0;
-}
-
-void CPDF_StreamContentParser::OnChangeTextMatrix() {
- CFX_Matrix text_matrix(m_pCurStates->m_TextHorzScale, 0.0f, 0.0f, 1.0f, 0.0f,
- 0.0f);
- text_matrix.Concat(m_pCurStates->m_TextMatrix);
- text_matrix.Concat(m_pCurStates->m_CTM);
- text_matrix.Concat(m_mtContentToUser);
- FX_FLOAT* pTextMatrix = m_pCurStates->m_TextState.GetMutableMatrix();
- pTextMatrix[0] = text_matrix.a;
- pTextMatrix[1] = text_matrix.c;
- pTextMatrix[2] = text_matrix.b;
- pTextMatrix[3] = text_matrix.d;
-}
-
-void CPDF_StreamContentParser::Handle_SetTextRenderMode() {
- TextRenderingMode mode;
- if (SetTextRenderingModeFromInt(GetInteger(0), &mode))
- m_pCurStates->m_TextState.SetTextMode(mode);
-}
-
-void CPDF_StreamContentParser::Handle_SetTextRise() {
- m_pCurStates->m_TextRise = GetNumber(0);
-}
-
-void CPDF_StreamContentParser::Handle_SetWordSpace() {
- m_pCurStates->m_TextState.SetWordSpace(GetNumber(0));
-}
-
-void CPDF_StreamContentParser::Handle_SetHorzScale() {
- if (m_ParamCount != 1) {
- return;
- }
- m_pCurStates->m_TextHorzScale = GetNumber(0) / 100;
- OnChangeTextMatrix();
-}
-
-void CPDF_StreamContentParser::Handle_MoveToNextLine() {
- m_pCurStates->m_TextLineY -= m_pCurStates->m_TextLeading;
- m_pCurStates->m_TextX = m_pCurStates->m_TextLineX;
- m_pCurStates->m_TextY = m_pCurStates->m_TextLineY;
-}
-
-void CPDF_StreamContentParser::Handle_CurveTo_23() {
- AddPathPoint(m_PathCurrentX, m_PathCurrentY, FXPT_BEZIERTO);
- AddPathPoint(GetNumber(3), GetNumber(2), FXPT_BEZIERTO);
- AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
-}
-
-void CPDF_StreamContentParser::Handle_SetLineWidth() {
- m_pCurStates->m_GraphState.SetLineWidth(GetNumber(0));
-}
-
-void CPDF_StreamContentParser::Handle_Clip() {
- m_PathClipType = FXFILL_WINDING;
-}
-
-void CPDF_StreamContentParser::Handle_EOClip() {
- m_PathClipType = FXFILL_ALTERNATE;
-}
-
-void CPDF_StreamContentParser::Handle_CurveTo_13() {
- AddPathPoint(GetNumber(3), GetNumber(2), FXPT_BEZIERTO);
- AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
- AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
-}
-
-void CPDF_StreamContentParser::Handle_NextLineShowText() {
- Handle_MoveToNextLine();
- Handle_ShowText();
-}
-
-void CPDF_StreamContentParser::Handle_NextLineShowText_Space() {
- m_pCurStates->m_TextState.SetWordSpace(GetNumber(2));
- m_pCurStates->m_TextState.SetCharSpace(GetNumber(1));
- Handle_NextLineShowText();
-}
-
-void CPDF_StreamContentParser::Handle_Invalid() {}
-
-void CPDF_StreamContentParser::AddPathPoint(FX_FLOAT x, FX_FLOAT y, int flag) {
- m_PathCurrentX = x;
- m_PathCurrentY = y;
- if (flag == FXPT_MOVETO) {
- m_PathStartX = x;
- m_PathStartY = y;
- if (m_PathPointCount &&
- m_pPathPoints[m_PathPointCount - 1].m_Flag == FXPT_MOVETO) {
- m_pPathPoints[m_PathPointCount - 1].m_PointX = x;
- m_pPathPoints[m_PathPointCount - 1].m_PointY = y;
- return;
- }
- } else if (m_PathPointCount == 0) {
- return;
- }
- m_PathPointCount++;
- if (m_PathPointCount > m_PathAllocSize) {
- int newsize = m_PathPointCount + 256;
- FX_PATHPOINT* pNewPoints = FX_Alloc(FX_PATHPOINT, newsize);
- if (m_PathAllocSize) {
- FXSYS_memcpy(pNewPoints, m_pPathPoints,
- m_PathAllocSize * sizeof(FX_PATHPOINT));
- FX_Free(m_pPathPoints);
- }
- m_pPathPoints = pNewPoints;
- m_PathAllocSize = newsize;
- }
- m_pPathPoints[m_PathPointCount - 1].m_Flag = flag;
- m_pPathPoints[m_PathPointCount - 1].m_PointX = x;
- m_pPathPoints[m_PathPointCount - 1].m_PointY = y;
-}
-
-void CPDF_StreamContentParser::AddPathObject(int FillType, bool bStroke) {
- int PathPointCount = m_PathPointCount;
- uint8_t PathClipType = m_PathClipType;
- m_PathPointCount = 0;
- m_PathClipType = 0;
- if (PathPointCount <= 1) {
- if (PathPointCount && PathClipType) {
- CPDF_Path path;
- path.AppendRect(0, 0, 0, 0);
- m_pCurStates->m_ClipPath.AppendPath(path, FXFILL_WINDING, TRUE);
- }
- return;
- }
- if (PathPointCount &&
- m_pPathPoints[PathPointCount - 1].m_Flag == FXPT_MOVETO) {
- PathPointCount--;
- }
- CPDF_Path Path;
- Path.SetPointCount(PathPointCount);
- FXSYS_memcpy(Path.GetMutablePoints(), m_pPathPoints,
- sizeof(FX_PATHPOINT) * PathPointCount);
- CFX_Matrix matrix = m_pCurStates->m_CTM;
- matrix.Concat(m_mtContentToUser);
- if (bStroke || FillType) {
- std::unique_ptr<CPDF_PathObject> pPathObj(new CPDF_PathObject);
- pPathObj->m_bStroke = bStroke;
- pPathObj->m_FillType = FillType;
- pPathObj->m_Path = Path;
- pPathObj->m_Matrix = matrix;
- SetGraphicStates(pPathObj.get(), true, false, true);
- pPathObj->CalcBoundingBox();
- m_pObjectHolder->GetPageObjectList()->push_back(std::move(pPathObj));
- }
- if (PathClipType) {
- if (!matrix.IsIdentity()) {
- Path.Transform(&matrix);
- matrix.SetIdentity();
- }
- m_pCurStates->m_ClipPath.AppendPath(Path, PathClipType, TRUE);
- }
-}
-
-uint32_t CPDF_StreamContentParser::Parse(const uint8_t* pData,
- uint32_t dwSize,
- uint32_t max_cost) {
- if (m_Level > _FPDF_MAX_FORM_LEVEL_) {
- return dwSize;
- }
- uint32_t InitObjCount = m_pObjectHolder->GetPageObjectList()->size();
- CPDF_StreamParser syntax(pData, dwSize, m_pDocument->GetByteStringPool());
- CPDF_StreamParserAutoClearer auto_clearer(&m_pSyntax, &syntax);
- while (1) {
- uint32_t cost = m_pObjectHolder->GetPageObjectList()->size() - InitObjCount;
- if (max_cost && cost >= max_cost) {
- break;
- }
- switch (syntax.ParseNextElement()) {
- case CPDF_StreamParser::EndOfData:
- return m_pSyntax->GetPos();
- case CPDF_StreamParser::Keyword:
- OnOperator((char*)syntax.GetWordBuf());
- ClearAllParams();
- break;
- case CPDF_StreamParser::Number:
- AddNumberParam((char*)syntax.GetWordBuf(), syntax.GetWordSize());
- break;
- case CPDF_StreamParser::Name:
- AddNameParam((const FX_CHAR*)syntax.GetWordBuf() + 1,
- syntax.GetWordSize() - 1);
- break;
- default:
- AddObjectParam(syntax.GetObject());
- }
- }
- return m_pSyntax->GetPos();
-}
-
-void CPDF_StreamContentParser::ParsePathObject() {
- FX_FLOAT params[6] = {};
- int nParams = 0;
- int last_pos = m_pSyntax->GetPos();
- while (1) {
- CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
- FX_BOOL bProcessed = TRUE;
- switch (type) {
- case CPDF_StreamParser::EndOfData:
- return;
- case CPDF_StreamParser::Keyword: {
- int len = m_pSyntax->GetWordSize();
- if (len == 1) {
- switch (m_pSyntax->GetWordBuf()[0]) {
- case kPathOperatorSubpath:
- AddPathPoint(params[0], params[1], FXPT_MOVETO);
- nParams = 0;
- break;
- case kPathOperatorLine:
- AddPathPoint(params[0], params[1], FXPT_LINETO);
- nParams = 0;
- break;
- case kPathOperatorCubicBezier1:
- AddPathPoint(params[0], params[1], FXPT_BEZIERTO);
- AddPathPoint(params[2], params[3], FXPT_BEZIERTO);
- AddPathPoint(params[4], params[5], FXPT_BEZIERTO);
- nParams = 0;
- break;
- case kPathOperatorCubicBezier2:
- AddPathPoint(m_PathCurrentX, m_PathCurrentY, FXPT_BEZIERTO);
- AddPathPoint(params[0], params[1], FXPT_BEZIERTO);
- AddPathPoint(params[2], params[3], FXPT_BEZIERTO);
- nParams = 0;
- break;
- case kPathOperatorCubicBezier3:
- AddPathPoint(params[0], params[1], FXPT_BEZIERTO);
- AddPathPoint(params[2], params[3], FXPT_BEZIERTO);
- AddPathPoint(params[2], params[3], FXPT_BEZIERTO);
- nParams = 0;
- break;
- case kPathOperatorClosePath:
- Handle_ClosePath();
- nParams = 0;
- break;
- default:
- bProcessed = FALSE;
- break;
- }
- } else if (len == 2) {
- if (m_pSyntax->GetWordBuf()[0] == kPathOperatorRectangle[0] &&
- m_pSyntax->GetWordBuf()[1] == kPathOperatorRectangle[1]) {
- AddPathRect(params[0], params[1], params[2], params[3]);
- nParams = 0;
- } else {
- bProcessed = FALSE;
- }
- } else {
- bProcessed = FALSE;
- }
- if (bProcessed) {
- last_pos = m_pSyntax->GetPos();
- }
- break;
- }
- case CPDF_StreamParser::Number: {
- if (nParams == 6)
- break;
-
- int value;
- bool bInteger = FX_atonum(
- CFX_ByteStringC(m_pSyntax->GetWordBuf(), m_pSyntax->GetWordSize()),
- &value);
- params[nParams++] = bInteger ? (FX_FLOAT)value : *(FX_FLOAT*)&value;
- break;
- }
- default:
- bProcessed = FALSE;
- }
- if (!bProcessed) {
- m_pSyntax->SetPos(last_pos);
- return;
- }
- }
-}
-
void PDF_ReplaceAbbr(CPDF_Object* pObj) {
switch (pObj->GetType()) {
case CPDF_Object::DICTIONARY: {
diff --git a/core/fpdfapi/page/pageint.h b/core/fpdfapi/page/pageint.h
index 7ab9c6c863..d70ecf1a6e 100644
--- a/core/fpdfapi/page/pageint.h
+++ b/core/fpdfapi/page/pageint.h
@@ -16,6 +16,7 @@
#include "core/fpdfapi/page/cpdf_contentmark.h"
#include "core/fpdfapi/page/cpdf_countedobject.h"
#include "core/fpdfapi/page/cpdf_pageobjectholder.h"
+#include "core/fpdfapi/page/cpdf_streamcontentparser.h"
#include "core/fpdfapi/parser/cpdf_stream.h"
#include "core/fxcrt/cfx_string_pool_template.h"
#include "core/fxcrt/cfx_weak_ptr.h"
@@ -79,202 +80,8 @@ class CPDF_StreamParser {
CFX_WeakPtr<CFX_ByteStringPool> m_pPool;
};
-#define PARAM_BUF_SIZE 16
-
-struct ContentParam {
- enum Type { OBJECT = 0, NUMBER, NAME };
- Type m_Type;
- union {
- struct {
- bool m_bInteger;
- union {
- int m_Integer;
- FX_FLOAT m_Float;
- };
- } m_Number;
- CPDF_Object* m_pObject;
- struct {
- int m_Len;
- char m_Buffer[32];
- } m_Name;
- };
-};
-
-#define _FPDF_MAX_FORM_LEVEL_ 30
#define _FPDF_MAX_TYPE3_FORM_LEVEL_ 4
-class CPDF_StreamContentParser {
- public:
- CPDF_StreamContentParser(CPDF_Document* pDoc,
- CPDF_Dictionary* pPageResources,
- CPDF_Dictionary* pParentResources,
- const CFX_Matrix* pmtContentToUser,
- CPDF_PageObjectHolder* pObjectHolder,
- CPDF_Dictionary* pResources,
- CFX_FloatRect* pBBox,
- CPDF_AllStates* pAllStates,
- int level);
- ~CPDF_StreamContentParser();
-
- CPDF_PageObjectHolder* GetPageObjectHolder() const { return m_pObjectHolder; }
- CPDF_AllStates* GetCurStates() const { return m_pCurStates.get(); }
- bool IsColored() const { return m_bColored; }
- const FX_FLOAT* GetType3Data() const { return m_Type3Data; }
-
- void AddNumberParam(const FX_CHAR* str, int len);
- void AddObjectParam(CPDF_Object* pObj);
- void AddNameParam(const FX_CHAR* name, int size);
- int GetNextParamPos();
- void ClearAllParams();
- CPDF_Object* GetObject(uint32_t index);
- CFX_ByteString GetString(uint32_t index);
- FX_FLOAT GetNumber(uint32_t index);
- int GetInteger(uint32_t index) { return (int32_t)(GetNumber(index)); }
- void OnOperator(const FX_CHAR* op);
- void AddTextObject(CFX_ByteString* pText,
- FX_FLOAT fInitKerning,
- FX_FLOAT* pKerning,
- int count);
-
- void ConvertUserSpace(FX_FLOAT& x, FX_FLOAT& y);
- void ConvertTextSpace(FX_FLOAT& x, FX_FLOAT& y);
- void OnChangeTextMatrix();
- uint32_t Parse(const uint8_t* pData, uint32_t dwSize, uint32_t max_cost);
- void ParsePathObject();
- void AddPathPoint(FX_FLOAT x, FX_FLOAT y, int flag);
- void AddPathRect(FX_FLOAT x, FX_FLOAT y, FX_FLOAT w, FX_FLOAT h);
- void AddPathObject(int FillType, bool bStroke);
- CPDF_ImageObject* AddImage(UniqueStream pStream);
- CPDF_ImageObject* AddImage(uint32_t streamObjNum);
- CPDF_ImageObject* AddImage(CPDF_Image* pImage);
-
- void AddForm(CPDF_Stream* pStream);
- void SetGraphicStates(CPDF_PageObject* pObj,
- bool bColor,
- bool bText,
- bool bGraph);
- CPDF_Font* FindFont(const CFX_ByteString& name);
- CPDF_ColorSpace* FindColorSpace(const CFX_ByteString& name);
- CPDF_Pattern* FindPattern(const CFX_ByteString& name, bool bShading);
- CPDF_Object* FindResourceObj(const CFX_ByteString& type,
- const CFX_ByteString& name);
-
- private:
- using OpCodes =
- std::unordered_map<uint32_t, void (CPDF_StreamContentParser::*)()>;
- static OpCodes InitializeOpCodes();
-
- // Takes ownership of |pImageObj|, returns unowned pointer to it.
- CPDF_ImageObject* AddImageObject(std::unique_ptr<CPDF_ImageObject> pImageObj);
-
- void Handle_CloseFillStrokePath();
- void Handle_FillStrokePath();
- void Handle_CloseEOFillStrokePath();
- void Handle_EOFillStrokePath();
- void Handle_BeginMarkedContent_Dictionary();
- void Handle_BeginImage();
- void Handle_BeginMarkedContent();
- void Handle_BeginText();
- void Handle_CurveTo_123();
- void Handle_ConcatMatrix();
- void Handle_SetColorSpace_Fill();
- void Handle_SetColorSpace_Stroke();
- void Handle_SetDash();
- void Handle_SetCharWidth();
- void Handle_SetCachedDevice();
- void Handle_ExecuteXObject();
- void Handle_MarkPlace_Dictionary();
- void Handle_EndImage();
- void Handle_EndMarkedContent();
- void Handle_EndText();
- void Handle_FillPath();
- void Handle_FillPathOld();
- void Handle_EOFillPath();
- void Handle_SetGray_Fill();
- void Handle_SetGray_Stroke();
- void Handle_SetExtendGraphState();
- void Handle_ClosePath();
- void Handle_SetFlat();
- void Handle_BeginImageData();
- void Handle_SetLineJoin();
- void Handle_SetLineCap();
- void Handle_SetCMYKColor_Fill();
- void Handle_SetCMYKColor_Stroke();
- void Handle_LineTo();
- void Handle_MoveTo();
- void Handle_SetMiterLimit();
- void Handle_MarkPlace();
- void Handle_EndPath();
- void Handle_SaveGraphState();
- void Handle_RestoreGraphState();
- void Handle_Rectangle();
- void Handle_SetRGBColor_Fill();
- void Handle_SetRGBColor_Stroke();
- void Handle_SetRenderIntent();
- void Handle_CloseStrokePath();
- void Handle_StrokePath();
- void Handle_SetColor_Fill();
- void Handle_SetColor_Stroke();
- void Handle_SetColorPS_Fill();
- void Handle_SetColorPS_Stroke();
- void Handle_ShadeFill();
- void Handle_SetCharSpace();
- void Handle_MoveTextPoint();
- void Handle_MoveTextPoint_SetLeading();
- void Handle_SetFont();
- void Handle_ShowText();
- void Handle_ShowText_Positioning();
- void Handle_SetTextLeading();
- void Handle_SetTextMatrix();
- void Handle_SetTextRenderMode();
- void Handle_SetTextRise();
- void Handle_SetWordSpace();
- void Handle_SetHorzScale();
- void Handle_MoveToNextLine();
- void Handle_CurveTo_23();
- void Handle_SetLineWidth();
- void Handle_Clip();
- void Handle_EOClip();
- void Handle_CurveTo_13();
- void Handle_NextLineShowText();
- void Handle_NextLineShowText_Space();
- void Handle_Invalid();
-
- CPDF_Document* const m_pDocument;
- CPDF_Dictionary* m_pPageResources;
- CPDF_Dictionary* m_pParentResources;
- CPDF_Dictionary* m_pResources;
- CPDF_PageObjectHolder* m_pObjectHolder;
- int m_Level;
- CFX_Matrix m_mtContentToUser;
- CFX_FloatRect m_BBox;
- ContentParam m_ParamBuf[PARAM_BUF_SIZE];
- uint32_t m_ParamStartPos;
- uint32_t m_ParamCount;
- CPDF_StreamParser* m_pSyntax;
- std::unique_ptr<CPDF_AllStates> m_pCurStates;
- CPDF_ContentMark m_CurContentMark;
- std::vector<std::unique_ptr<CPDF_TextObject>> m_ClipTextList;
- CPDF_TextObject* m_pLastTextObject;
- FX_FLOAT m_DefFontSize;
- FX_PATHPOINT* m_pPathPoints;
- int m_PathPointCount;
- int m_PathAllocSize;
- FX_FLOAT m_PathStartX;
- FX_FLOAT m_PathStartY;
- FX_FLOAT m_PathCurrentX;
- FX_FLOAT m_PathCurrentY;
- uint8_t m_PathClipType;
- CFX_ByteString m_LastImageName;
- CPDF_Image* m_pLastImage;
- CPDF_Dictionary* m_pLastImageDict;
- CPDF_Dictionary* m_pLastCloneImageDict;
- bool m_bColored;
- FX_FLOAT m_Type3Data[6];
- bool m_bResourceMissing;
- std::vector<std::unique_ptr<CPDF_AllStates>> m_StateStack;
-};
-
class CPDF_ContentParser {
public:
enum ParseStatus { Ready, ToBeContinued, Done };