1 // Copyright 2016 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6
7 #include "core/fpdfapi/page/cpdf_streamcontentparser.h"
8
9 #include <algorithm>
10 #include <memory>
11 #include <utility>
12 #include <vector>
13
14 #include "core/fpdfapi/font/cpdf_font.h"
15 #include "core/fpdfapi/font/cpdf_type3font.h"
16 #include "core/fpdfapi/page/cpdf_allstates.h"
17 #include "core/fpdfapi/page/cpdf_docpagedata.h"
18 #include "core/fpdfapi/page/cpdf_form.h"
19 #include "core/fpdfapi/page/cpdf_formobject.h"
20 #include "core/fpdfapi/page/cpdf_image.h"
21 #include "core/fpdfapi/page/cpdf_imageobject.h"
22 #include "core/fpdfapi/page/cpdf_meshstream.h"
23 #include "core/fpdfapi/page/cpdf_pageobject.h"
24 #include "core/fpdfapi/page/cpdf_pathobject.h"
25 #include "core/fpdfapi/page/cpdf_shadingobject.h"
26 #include "core/fpdfapi/page/cpdf_shadingpattern.h"
27 #include "core/fpdfapi/page/cpdf_streamparser.h"
28 #include "core/fpdfapi/page/cpdf_textobject.h"
29 #include "core/fpdfapi/parser/cpdf_array.h"
30 #include "core/fpdfapi/parser/cpdf_dictionary.h"
31 #include "core/fpdfapi/parser/cpdf_document.h"
32 #include "core/fpdfapi/parser/cpdf_name.h"
33 #include "core/fpdfapi/parser/cpdf_number.h"
34 #include "core/fpdfapi/parser/cpdf_reference.h"
35 #include "core/fpdfapi/parser/cpdf_stream.h"
36 #include "core/fpdfapi/parser/fpdf_parser_utility.h"
37 #include "core/fxcrt/autonuller.h"
38 #include "core/fxcrt/fx_safe_types.h"
39 #include "core/fxge/cfx_graphstatedata.h"
40 #include "third_party/base/notreached.h"
41 #include "third_party/base/span.h"
42 #include "third_party/base/stl_util.h"
43
44 namespace {
45
46 const int kMaxFormLevel = 40;
47
48 const int kSingleCoordinatePair = 1;
49 const int kTensorCoordinatePairs = 16;
50 const int kCoonsCoordinatePairs = 12;
51 const int kSingleColorPerPatch = 1;
52 const int kQuadColorsPerPatch = 4;
53
54 const char kPathOperatorSubpath = 'm';
55 const char kPathOperatorLine = 'l';
56 const char kPathOperatorCubicBezier1 = 'c';
57 const char kPathOperatorCubicBezier2 = 'v';
58 const char kPathOperatorCubicBezier3 = 'y';
59 const char kPathOperatorClosePath = 'h';
60 const char kPathOperatorRectangle[] = "re";
61
GetShadingBBox(CPDF_ShadingPattern * pShading,const CFX_Matrix & matrix)62 CFX_FloatRect GetShadingBBox(CPDF_ShadingPattern* pShading,
63 const CFX_Matrix& matrix) {
64 ShadingType type = pShading->GetShadingType();
65 const CPDF_Stream* pStream = ToStream(pShading->GetShadingObject());
66 RetainPtr<CPDF_ColorSpace> pCS = pShading->GetCS();
67 if (!pStream || !pCS)
68 return CFX_FloatRect();
69
70 CPDF_MeshStream stream(type, pShading->GetFuncs(), pStream, pCS);
71 if (!stream.Load())
72 return CFX_FloatRect();
73
74 CFX_FloatRect rect;
75 bool bStarted = false;
76 bool bGouraud = type == kFreeFormGouraudTriangleMeshShading ||
77 type == kLatticeFormGouraudTriangleMeshShading;
78
79 int point_count = kSingleCoordinatePair;
80 if (type == kTensorProductPatchMeshShading)
81 point_count = kTensorCoordinatePairs;
82 else if (type == kCoonsPatchMeshShading)
83 point_count = kCoonsCoordinatePairs;
84
85 int color_count = kSingleColorPerPatch;
86 if (type == kCoonsPatchMeshShading || type == kTensorProductPatchMeshShading)
87 color_count = kQuadColorsPerPatch;
88
89 while (!stream.BitStream()->IsEOF()) {
90 uint32_t flag = 0;
91 if (type != kLatticeFormGouraudTriangleMeshShading) {
92 if (!stream.CanReadFlag())
93 break;
94 flag = stream.ReadFlag();
95 }
96
97 if (!bGouraud && flag) {
98 point_count -= 4;
99 color_count -= 2;
100 }
101
102 for (int i = 0; i < point_count; i++) {
103 if (!stream.CanReadCoords())
104 break;
105 CFX_PointF origin = stream.ReadCoords();
106 if (bStarted) {
107 rect.UpdateRect(origin);
108 } else {
109 rect.InitRect(origin);
110 bStarted = true;
111 }
112 }
113 FX_SAFE_UINT32 nBits = stream.Components();
114 nBits *= stream.ComponentBits();
115 nBits *= color_count;
116 if (!nBits.IsValid())
117 break;
118
119 stream.BitStream()->SkipBits(nBits.ValueOrDie());
120 if (bGouraud)
121 stream.BitStream()->ByteAlign();
122 }
123 return matrix.TransformRect(rect);
124 }
125
126 struct AbbrPair {
127 const char* abbr;
128 const char* full_name;
129 };
130
131 const AbbrPair kInlineKeyAbbr[] = {
132 {"BPC", "BitsPerComponent"}, {"CS", "ColorSpace"}, {"D", "Decode"},
133 {"DP", "DecodeParms"}, {"F", "Filter"}, {"H", "Height"},
134 {"IM", "ImageMask"}, {"I", "Interpolate"}, {"W", "Width"},
135 };
136
137 const AbbrPair kInlineValueAbbr[] = {
138 {"G", "DeviceGray"}, {"RGB", "DeviceRGB"},
139 {"CMYK", "DeviceCMYK"}, {"I", "Indexed"},
140 {"AHx", "ASCIIHexDecode"}, {"A85", "ASCII85Decode"},
141 {"LZW", "LZWDecode"}, {"Fl", "FlateDecode"},
142 {"RL", "RunLengthDecode"}, {"CCF", "CCITTFaxDecode"},
143 {"DCT", "DCTDecode"},
144 };
145
146 struct AbbrReplacementOp {
147 bool is_replace_key;
148 ByteString key;
149 ByteStringView replacement;
150 };
151
FindFullName(const AbbrPair * table,size_t count,ByteStringView abbr)152 ByteStringView FindFullName(const AbbrPair* table,
153 size_t count,
154 ByteStringView abbr) {
155 auto* it = std::find_if(table, table + count, [abbr](const AbbrPair& pair) {
156 return pair.abbr == abbr;
157 });
158 return it != table + count ? ByteStringView(it->full_name) : ByteStringView();
159 }
160
161 void ReplaceAbbr(CPDF_Object* pObj);
162
ReplaceAbbrInDictionary(CPDF_Dictionary * pDict)163 void ReplaceAbbrInDictionary(CPDF_Dictionary* pDict) {
164 std::vector<AbbrReplacementOp> replacements;
165 {
166 CPDF_DictionaryLocker locker(pDict);
167 for (const auto& it : locker) {
168 ByteString key = it.first;
169 CPDF_Object* value = it.second.Get();
170 ByteStringView fullname = FindFullName(
171 kInlineKeyAbbr, pdfium::size(kInlineKeyAbbr), key.AsStringView());
172 if (!fullname.IsEmpty()) {
173 AbbrReplacementOp op;
174 op.is_replace_key = true;
175 op.key = std::move(key);
176 op.replacement = fullname;
177 replacements.push_back(op);
178 key = fullname;
179 }
180
181 if (value->IsName()) {
182 ByteString name = value->GetString();
183 fullname =
184 FindFullName(kInlineValueAbbr, pdfium::size(kInlineValueAbbr),
185 name.AsStringView());
186 if (!fullname.IsEmpty()) {
187 AbbrReplacementOp op;
188 op.is_replace_key = false;
189 op.key = key;
190 op.replacement = fullname;
191 replacements.push_back(op);
192 }
193 } else {
194 ReplaceAbbr(value);
195 }
196 }
197 }
198 for (const auto& op : replacements) {
199 if (op.is_replace_key)
200 pDict->ReplaceKey(op.key, ByteString(op.replacement));
201 else
202 pDict->SetNewFor<CPDF_Name>(op.key, ByteString(op.replacement));
203 }
204 }
205
ReplaceAbbrInArray(CPDF_Array * pArray)206 void ReplaceAbbrInArray(CPDF_Array* pArray) {
207 for (size_t i = 0; i < pArray->size(); ++i) {
208 CPDF_Object* pElement = pArray->GetObjectAt(i);
209 if (pElement->IsName()) {
210 ByteString name = pElement->GetString();
211 ByteStringView fullname =
212 FindFullName(kInlineValueAbbr, pdfium::size(kInlineValueAbbr),
213 name.AsStringView());
214 if (!fullname.IsEmpty())
215 pArray->SetNewAt<CPDF_Name>(i, ByteString(fullname));
216 } else {
217 ReplaceAbbr(pElement);
218 }
219 }
220 }
221
ReplaceAbbr(CPDF_Object * pObj)222 void ReplaceAbbr(CPDF_Object* pObj) {
223 CPDF_Dictionary* pDict = pObj->AsDictionary();
224 if (pDict) {
225 ReplaceAbbrInDictionary(pDict);
226 return;
227 }
228
229 CPDF_Array* pArray = pObj->AsArray();
230 if (pArray)
231 ReplaceAbbrInArray(pArray);
232 }
233
234 } // namespace
235
CPDF_StreamContentParser(CPDF_Document * pDocument,CPDF_Dictionary * pPageResources,CPDF_Dictionary * pParentResources,const CFX_Matrix * pmtContentToUser,CPDF_PageObjectHolder * pObjHolder,CPDF_Dictionary * pResources,const CFX_FloatRect & rcBBox,const CPDF_AllStates * pStates,std::set<const uint8_t * > * pParsedSet)236 CPDF_StreamContentParser::CPDF_StreamContentParser(
237 CPDF_Document* pDocument,
238 CPDF_Dictionary* pPageResources,
239 CPDF_Dictionary* pParentResources,
240 const CFX_Matrix* pmtContentToUser,
241 CPDF_PageObjectHolder* pObjHolder,
242 CPDF_Dictionary* pResources,
243 const CFX_FloatRect& rcBBox,
244 const CPDF_AllStates* pStates,
245 std::set<const uint8_t*>* pParsedSet)
246 : m_pDocument(pDocument),
247 m_pPageResources(pPageResources),
248 m_pParentResources(pParentResources),
249 m_pResources(CPDF_Form::ChooseResourcesDict(pResources,
250 pParentResources,
251 pPageResources)),
252 m_pObjectHolder(pObjHolder),
253 m_ParsedSet(pParsedSet),
254 m_BBox(rcBBox),
255 m_pCurStates(std::make_unique<CPDF_AllStates>()) {
256 if (pmtContentToUser)
257 m_mtContentToUser = *pmtContentToUser;
258 if (pStates) {
259 m_pCurStates->Copy(*pStates);
260 } else {
261 m_pCurStates->m_GeneralState.Emplace();
262 m_pCurStates->m_GraphState.Emplace();
263 m_pCurStates->m_TextState.Emplace();
264 m_pCurStates->m_ColorState.Emplace();
265 }
266
267 // Add the sentinel.
268 m_ContentMarksStack.push(std::make_unique<CPDF_ContentMarks>());
269 }
270
~CPDF_StreamContentParser()271 CPDF_StreamContentParser::~CPDF_StreamContentParser() {
272 ClearAllParams();
273 }
274
GetNextParamPos()275 int CPDF_StreamContentParser::GetNextParamPos() {
276 if (m_ParamCount == kParamBufSize) {
277 m_ParamStartPos++;
278 if (m_ParamStartPos == kParamBufSize) {
279 m_ParamStartPos = 0;
280 }
281 if (m_ParamBuf[m_ParamStartPos].m_Type == ContentParam::OBJECT)
282 m_ParamBuf[m_ParamStartPos].m_pObject.Reset();
283
284 return m_ParamStartPos;
285 }
286 int index = m_ParamStartPos + m_ParamCount;
287 if (index >= kParamBufSize) {
288 index -= kParamBufSize;
289 }
290 m_ParamCount++;
291 return index;
292 }
293
AddNameParam(ByteStringView bsName)294 void CPDF_StreamContentParser::AddNameParam(ByteStringView bsName) {
295 ContentParam& param = m_ParamBuf[GetNextParamPos()];
296 param.m_Type = ContentParam::NAME;
297 param.m_Name = PDF_NameDecode(bsName);
298 }
299
AddNumberParam(ByteStringView str)300 void CPDF_StreamContentParser::AddNumberParam(ByteStringView str) {
301 ContentParam& param = m_ParamBuf[GetNextParamPos()];
302 param.m_Type = ContentParam::NUMBER;
303 param.m_Number = FX_Number(str);
304 }
305
AddObjectParam(RetainPtr<CPDF_Object> pObj)306 void CPDF_StreamContentParser::AddObjectParam(RetainPtr<CPDF_Object> pObj) {
307 ContentParam& param = m_ParamBuf[GetNextParamPos()];
308 param.m_Type = ContentParam::OBJECT;
309 param.m_pObject = std::move(pObj);
310 }
311
ClearAllParams()312 void CPDF_StreamContentParser::ClearAllParams() {
313 uint32_t index = m_ParamStartPos;
314 for (uint32_t i = 0; i < m_ParamCount; i++) {
315 if (m_ParamBuf[index].m_Type == ContentParam::OBJECT)
316 m_ParamBuf[index].m_pObject.Reset();
317 index++;
318 if (index == kParamBufSize)
319 index = 0;
320 }
321 m_ParamStartPos = 0;
322 m_ParamCount = 0;
323 }
324
GetObject(uint32_t index)325 CPDF_Object* CPDF_StreamContentParser::GetObject(uint32_t index) {
326 if (index >= m_ParamCount) {
327 return nullptr;
328 }
329 int real_index = m_ParamStartPos + m_ParamCount - index - 1;
330 if (real_index >= kParamBufSize) {
331 real_index -= kParamBufSize;
332 }
333 ContentParam& param = m_ParamBuf[real_index];
334 if (param.m_Type == ContentParam::NUMBER) {
335 param.m_Type = ContentParam::OBJECT;
336 param.m_pObject =
337 param.m_Number.IsInteger()
338 ? pdfium::MakeRetain<CPDF_Number>(param.m_Number.GetSigned())
339 : pdfium::MakeRetain<CPDF_Number>(param.m_Number.GetFloat());
340 return param.m_pObject.Get();
341 }
342 if (param.m_Type == ContentParam::NAME) {
343 param.m_Type = ContentParam::OBJECT;
344 param.m_pObject = m_pDocument->New<CPDF_Name>(param.m_Name);
345 return param.m_pObject.Get();
346 }
347 if (param.m_Type == ContentParam::OBJECT)
348 return param.m_pObject.Get();
349
350 NOTREACHED();
351 return nullptr;
352 }
353
GetString(uint32_t index) const354 ByteString CPDF_StreamContentParser::GetString(uint32_t index) const {
355 if (index >= m_ParamCount)
356 return ByteString();
357
358 int real_index = m_ParamStartPos + m_ParamCount - index - 1;
359 if (real_index >= kParamBufSize)
360 real_index -= kParamBufSize;
361
362 const ContentParam& param = m_ParamBuf[real_index];
363 if (param.m_Type == ContentParam::NAME)
364 return param.m_Name;
365
366 if (param.m_Type == 0 && param.m_pObject)
367 return param.m_pObject->GetString();
368
369 return ByteString();
370 }
371
GetNumber(uint32_t index) const372 float CPDF_StreamContentParser::GetNumber(uint32_t index) const {
373 if (index >= m_ParamCount)
374 return 0;
375
376 int real_index = m_ParamStartPos + m_ParamCount - index - 1;
377 if (real_index >= kParamBufSize)
378 real_index -= kParamBufSize;
379
380 const ContentParam& param = m_ParamBuf[real_index];
381 if (param.m_Type == ContentParam::NUMBER)
382 return param.m_Number.GetFloat();
383
384 if (param.m_Type == 0 && param.m_pObject)
385 return param.m_pObject->GetNumber();
386
387 return 0;
388 }
389
GetNumbers(size_t count) const390 std::vector<float> CPDF_StreamContentParser::GetNumbers(size_t count) const {
391 std::vector<float> values(count);
392 for (size_t i = 0; i < count; ++i)
393 values[i] = GetNumber(count - i - 1);
394 return values;
395 }
396
SetGraphicStates(CPDF_PageObject * pObj,bool bColor,bool bText,bool bGraph)397 void CPDF_StreamContentParser::SetGraphicStates(CPDF_PageObject* pObj,
398 bool bColor,
399 bool bText,
400 bool bGraph) {
401 pObj->m_GeneralState = m_pCurStates->m_GeneralState;
402 pObj->m_ClipPath = m_pCurStates->m_ClipPath;
403 pObj->m_ContentMarks = *m_ContentMarksStack.top();
404 if (bColor) {
405 pObj->m_ColorState = m_pCurStates->m_ColorState;
406 }
407 if (bGraph) {
408 pObj->m_GraphState = m_pCurStates->m_GraphState;
409 }
410 if (bText) {
411 pObj->m_TextState = m_pCurStates->m_TextState;
412 }
413 }
414
415 // static
416 CPDF_StreamContentParser::OpCodes
InitializeOpCodes()417 CPDF_StreamContentParser::InitializeOpCodes() {
418 return OpCodes({
419 {FXBSTR_ID('"', 0, 0, 0),
420 &CPDF_StreamContentParser::Handle_NextLineShowText_Space},
421 {FXBSTR_ID('\'', 0, 0, 0),
422 &CPDF_StreamContentParser::Handle_NextLineShowText},
423 {FXBSTR_ID('B', 0, 0, 0),
424 &CPDF_StreamContentParser::Handle_FillStrokePath},
425 {FXBSTR_ID('B', '*', 0, 0),
426 &CPDF_StreamContentParser::Handle_EOFillStrokePath},
427 {FXBSTR_ID('B', 'D', 'C', 0),
428 &CPDF_StreamContentParser::Handle_BeginMarkedContent_Dictionary},
429 {FXBSTR_ID('B', 'I', 0, 0), &CPDF_StreamContentParser::Handle_BeginImage},
430 {FXBSTR_ID('B', 'M', 'C', 0),
431 &CPDF_StreamContentParser::Handle_BeginMarkedContent},
432 {FXBSTR_ID('B', 'T', 0, 0), &CPDF_StreamContentParser::Handle_BeginText},
433 {FXBSTR_ID('C', 'S', 0, 0),
434 &CPDF_StreamContentParser::Handle_SetColorSpace_Stroke},
435 {FXBSTR_ID('D', 'P', 0, 0),
436 &CPDF_StreamContentParser::Handle_MarkPlace_Dictionary},
437 {FXBSTR_ID('D', 'o', 0, 0),
438 &CPDF_StreamContentParser::Handle_ExecuteXObject},
439 {FXBSTR_ID('E', 'I', 0, 0), &CPDF_StreamContentParser::Handle_EndImage},
440 {FXBSTR_ID('E', 'M', 'C', 0),
441 &CPDF_StreamContentParser::Handle_EndMarkedContent},
442 {FXBSTR_ID('E', 'T', 0, 0), &CPDF_StreamContentParser::Handle_EndText},
443 {FXBSTR_ID('F', 0, 0, 0), &CPDF_StreamContentParser::Handle_FillPathOld},
444 {FXBSTR_ID('G', 0, 0, 0),
445 &CPDF_StreamContentParser::Handle_SetGray_Stroke},
446 {FXBSTR_ID('I', 'D', 0, 0),
447 &CPDF_StreamContentParser::Handle_BeginImageData},
448 {FXBSTR_ID('J', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineCap},
449 {FXBSTR_ID('K', 0, 0, 0),
450 &CPDF_StreamContentParser::Handle_SetCMYKColor_Stroke},
451 {FXBSTR_ID('M', 0, 0, 0),
452 &CPDF_StreamContentParser::Handle_SetMiterLimit},
453 {FXBSTR_ID('M', 'P', 0, 0), &CPDF_StreamContentParser::Handle_MarkPlace},
454 {FXBSTR_ID('Q', 0, 0, 0),
455 &CPDF_StreamContentParser::Handle_RestoreGraphState},
456 {FXBSTR_ID('R', 'G', 0, 0),
457 &CPDF_StreamContentParser::Handle_SetRGBColor_Stroke},
458 {FXBSTR_ID('S', 0, 0, 0), &CPDF_StreamContentParser::Handle_StrokePath},
459 {FXBSTR_ID('S', 'C', 0, 0),
460 &CPDF_StreamContentParser::Handle_SetColor_Stroke},
461 {FXBSTR_ID('S', 'C', 'N', 0),
462 &CPDF_StreamContentParser::Handle_SetColorPS_Stroke},
463 {FXBSTR_ID('T', '*', 0, 0),
464 &CPDF_StreamContentParser::Handle_MoveToNextLine},
465 {FXBSTR_ID('T', 'D', 0, 0),
466 &CPDF_StreamContentParser::Handle_MoveTextPoint_SetLeading},
467 {FXBSTR_ID('T', 'J', 0, 0),
468 &CPDF_StreamContentParser::Handle_ShowText_Positioning},
469 {FXBSTR_ID('T', 'L', 0, 0),
470 &CPDF_StreamContentParser::Handle_SetTextLeading},
471 {FXBSTR_ID('T', 'c', 0, 0),
472 &CPDF_StreamContentParser::Handle_SetCharSpace},
473 {FXBSTR_ID('T', 'd', 0, 0),
474 &CPDF_StreamContentParser::Handle_MoveTextPoint},
475 {FXBSTR_ID('T', 'f', 0, 0), &CPDF_StreamContentParser::Handle_SetFont},
476 {FXBSTR_ID('T', 'j', 0, 0), &CPDF_StreamContentParser::Handle_ShowText},
477 {FXBSTR_ID('T', 'm', 0, 0),
478 &CPDF_StreamContentParser::Handle_SetTextMatrix},
479 {FXBSTR_ID('T', 'r', 0, 0),
480 &CPDF_StreamContentParser::Handle_SetTextRenderMode},
481 {FXBSTR_ID('T', 's', 0, 0),
482 &CPDF_StreamContentParser::Handle_SetTextRise},
483 {FXBSTR_ID('T', 'w', 0, 0),
484 &CPDF_StreamContentParser::Handle_SetWordSpace},
485 {FXBSTR_ID('T', 'z', 0, 0),
486 &CPDF_StreamContentParser::Handle_SetHorzScale},
487 {FXBSTR_ID('W', 0, 0, 0), &CPDF_StreamContentParser::Handle_Clip},
488 {FXBSTR_ID('W', '*', 0, 0), &CPDF_StreamContentParser::Handle_EOClip},
489 {FXBSTR_ID('b', 0, 0, 0),
490 &CPDF_StreamContentParser::Handle_CloseFillStrokePath},
491 {FXBSTR_ID('b', '*', 0, 0),
492 &CPDF_StreamContentParser::Handle_CloseEOFillStrokePath},
493 {FXBSTR_ID('c', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_123},
494 {FXBSTR_ID('c', 'm', 0, 0),
495 &CPDF_StreamContentParser::Handle_ConcatMatrix},
496 {FXBSTR_ID('c', 's', 0, 0),
497 &CPDF_StreamContentParser::Handle_SetColorSpace_Fill},
498 {FXBSTR_ID('d', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetDash},
499 {FXBSTR_ID('d', '0', 0, 0),
500 &CPDF_StreamContentParser::Handle_SetCharWidth},
501 {FXBSTR_ID('d', '1', 0, 0),
502 &CPDF_StreamContentParser::Handle_SetCachedDevice},
503 {FXBSTR_ID('f', 0, 0, 0), &CPDF_StreamContentParser::Handle_FillPath},
504 {FXBSTR_ID('f', '*', 0, 0), &CPDF_StreamContentParser::Handle_EOFillPath},
505 {FXBSTR_ID('g', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetGray_Fill},
506 {FXBSTR_ID('g', 's', 0, 0),
507 &CPDF_StreamContentParser::Handle_SetExtendGraphState},
508 {FXBSTR_ID('h', 0, 0, 0), &CPDF_StreamContentParser::Handle_ClosePath},
509 {FXBSTR_ID('i', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetFlat},
510 {FXBSTR_ID('j', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineJoin},
511 {FXBSTR_ID('k', 0, 0, 0),
512 &CPDF_StreamContentParser::Handle_SetCMYKColor_Fill},
513 {FXBSTR_ID('l', 0, 0, 0), &CPDF_StreamContentParser::Handle_LineTo},
514 {FXBSTR_ID('m', 0, 0, 0), &CPDF_StreamContentParser::Handle_MoveTo},
515 {FXBSTR_ID('n', 0, 0, 0), &CPDF_StreamContentParser::Handle_EndPath},
516 {FXBSTR_ID('q', 0, 0, 0),
517 &CPDF_StreamContentParser::Handle_SaveGraphState},
518 {FXBSTR_ID('r', 'e', 0, 0), &CPDF_StreamContentParser::Handle_Rectangle},
519 {FXBSTR_ID('r', 'g', 0, 0),
520 &CPDF_StreamContentParser::Handle_SetRGBColor_Fill},
521 {FXBSTR_ID('r', 'i', 0, 0),
522 &CPDF_StreamContentParser::Handle_SetRenderIntent},
523 {FXBSTR_ID('s', 0, 0, 0),
524 &CPDF_StreamContentParser::Handle_CloseStrokePath},
525 {FXBSTR_ID('s', 'c', 0, 0),
526 &CPDF_StreamContentParser::Handle_SetColor_Fill},
527 {FXBSTR_ID('s', 'c', 'n', 0),
528 &CPDF_StreamContentParser::Handle_SetColorPS_Fill},
529 {FXBSTR_ID('s', 'h', 0, 0), &CPDF_StreamContentParser::Handle_ShadeFill},
530 {FXBSTR_ID('v', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_23},
531 {FXBSTR_ID('w', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineWidth},
532 {FXBSTR_ID('y', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_13},
533 });
534 }
535
OnOperator(ByteStringView op)536 void CPDF_StreamContentParser::OnOperator(ByteStringView op) {
537 static const OpCodes s_OpCodes = InitializeOpCodes();
538
539 auto it = s_OpCodes.find(op.GetID());
540 if (it != s_OpCodes.end())
541 (this->*it->second)();
542 }
543
Handle_CloseFillStrokePath()544 void CPDF_StreamContentParser::Handle_CloseFillStrokePath() {
545 Handle_ClosePath();
546 AddPathObject(CFX_FillRenderOptions::FillType::kWinding, true);
547 }
548
Handle_FillStrokePath()549 void CPDF_StreamContentParser::Handle_FillStrokePath() {
550 AddPathObject(CFX_FillRenderOptions::FillType::kWinding, true);
551 }
552
Handle_CloseEOFillStrokePath()553 void CPDF_StreamContentParser::Handle_CloseEOFillStrokePath() {
554 AddPathPoint(m_PathStartX, m_PathStartY, FXPT_TYPE::LineTo, true);
555 AddPathObject(CFX_FillRenderOptions::FillType::kEvenOdd, true);
556 }
557
Handle_EOFillStrokePath()558 void CPDF_StreamContentParser::Handle_EOFillStrokePath() {
559 AddPathObject(CFX_FillRenderOptions::FillType::kEvenOdd, true);
560 }
561
Handle_BeginMarkedContent_Dictionary()562 void CPDF_StreamContentParser::Handle_BeginMarkedContent_Dictionary() {
563 CPDF_Object* pProperty = GetObject(0);
564 if (!pProperty)
565 return;
566
567 ByteString tag = GetString(1);
568 std::unique_ptr<CPDF_ContentMarks> new_marks =
569 m_ContentMarksStack.top()->Clone();
570
571 if (pProperty->IsName()) {
572 ByteString property_name = pProperty->GetString();
573 CPDF_Dictionary* pHolder = FindResourceHolder("Properties");
574 if (!pHolder || !pHolder->GetDictFor(property_name))
575 return;
576 new_marks->AddMarkWithPropertiesHolder(tag, pHolder, property_name);
577 } else if (pProperty->IsDictionary()) {
578 new_marks->AddMarkWithDirectDict(tag, pProperty->AsDictionary());
579 } else {
580 return;
581 }
582 m_ContentMarksStack.push(std::move(new_marks));
583 }
584
Handle_BeginImage()585 void CPDF_StreamContentParser::Handle_BeginImage() {
586 FX_FILESIZE savePos = m_pSyntax->GetPos();
587 auto pDict = m_pDocument->New<CPDF_Dictionary>();
588 while (1) {
589 CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
590 if (type == CPDF_StreamParser::Keyword) {
591 if (m_pSyntax->GetWord() != "ID") {
592 m_pSyntax->SetPos(savePos);
593 return;
594 }
595 }
596 if (type != CPDF_StreamParser::Name) {
597 break;
598 }
599 auto word = m_pSyntax->GetWord();
600 ByteString key(word.Last(word.GetLength() - 1));
601 auto pObj = m_pSyntax->ReadNextObject(false, false, 0);
602 if (!key.IsEmpty()) {
603 if (pObj && !pObj->IsInline()) {
604 pDict->SetNewFor<CPDF_Reference>(key, m_pDocument.Get(),
605 pObj->GetObjNum());
606 } else {
607 pDict->SetFor(key, std::move(pObj));
608 }
609 }
610 }
611 ReplaceAbbr(pDict.Get());
612 CPDF_Object* pCSObj = nullptr;
613 if (pDict->KeyExist("ColorSpace")) {
614 pCSObj = pDict->GetDirectObjectFor("ColorSpace");
615 if (pCSObj->IsName()) {
616 ByteString name = pCSObj->GetString();
617 if (name != "DeviceRGB" && name != "DeviceGray" && name != "DeviceCMYK") {
618 pCSObj = FindResourceObj("ColorSpace", name);
619 if (pCSObj && pCSObj->IsInline())
620 pDict->SetFor("ColorSpace", pCSObj->Clone());
621 }
622 }
623 }
624 pDict->SetNewFor<CPDF_Name>("Subtype", "Image");
625 RetainPtr<CPDF_Stream> pStream =
626 m_pSyntax->ReadInlineStream(m_pDocument.Get(), std::move(pDict), pCSObj);
627 while (1) {
628 CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
629 if (type == CPDF_StreamParser::EndOfData) {
630 break;
631 }
632 if (type != CPDF_StreamParser::Keyword) {
633 continue;
634 }
635 if (m_pSyntax->GetWord() == "EI") {
636 break;
637 }
638 }
639 CPDF_ImageObject* pObj = AddImage(std::move(pStream));
640 // Record the bounding box of this image, so rendering code can draw it
641 // properly.
642 if (pObj && pObj->GetImage()->IsMask())
643 m_pObjectHolder->AddImageMaskBoundingBox(pObj->GetRect());
644 }
645
Handle_BeginMarkedContent()646 void CPDF_StreamContentParser::Handle_BeginMarkedContent() {
647 std::unique_ptr<CPDF_ContentMarks> new_marks =
648 m_ContentMarksStack.top()->Clone();
649 new_marks->AddMark(GetString(0));
650 m_ContentMarksStack.push(std::move(new_marks));
651 }
652
Handle_BeginText()653 void CPDF_StreamContentParser::Handle_BeginText() {
654 m_pCurStates->m_TextMatrix = CFX_Matrix();
655 OnChangeTextMatrix();
656 m_pCurStates->m_TextPos = CFX_PointF();
657 m_pCurStates->m_TextLinePos = CFX_PointF();
658 }
659
Handle_CurveTo_123()660 void CPDF_StreamContentParser::Handle_CurveTo_123() {
661 AddPathPoint(GetNumber(5), GetNumber(4), FXPT_TYPE::BezierTo, false);
662 AddPathPoint(GetNumber(3), GetNumber(2), FXPT_TYPE::BezierTo, false);
663 AddPathPoint(GetNumber(1), GetNumber(0), FXPT_TYPE::BezierTo, false);
664 }
665
Handle_ConcatMatrix()666 void CPDF_StreamContentParser::Handle_ConcatMatrix() {
667 CFX_Matrix new_matrix(GetNumber(5), GetNumber(4), GetNumber(3), GetNumber(2),
668 GetNumber(1), GetNumber(0));
669 m_pCurStates->m_CTM = new_matrix * m_pCurStates->m_CTM;
670 OnChangeTextMatrix();
671 }
672
Handle_SetColorSpace_Fill()673 void CPDF_StreamContentParser::Handle_SetColorSpace_Fill() {
674 RetainPtr<CPDF_ColorSpace> pCS = FindColorSpace(GetString(0));
675 if (!pCS)
676 return;
677
678 m_pCurStates->m_ColorState.GetMutableFillColor()->SetColorSpace(pCS);
679 }
680
Handle_SetColorSpace_Stroke()681 void CPDF_StreamContentParser::Handle_SetColorSpace_Stroke() {
682 RetainPtr<CPDF_ColorSpace> pCS = FindColorSpace(GetString(0));
683 if (!pCS)
684 return;
685
686 m_pCurStates->m_ColorState.GetMutableStrokeColor()->SetColorSpace(pCS);
687 }
688
Handle_SetDash()689 void CPDF_StreamContentParser::Handle_SetDash() {
690 CPDF_Array* pArray = ToArray(GetObject(1));
691 if (!pArray)
692 return;
693
694 m_pCurStates->SetLineDash(pArray, GetNumber(0), 1.0f);
695 }
696
Handle_SetCharWidth()697 void CPDF_StreamContentParser::Handle_SetCharWidth() {
698 m_Type3Data[0] = GetNumber(1);
699 m_Type3Data[1] = GetNumber(0);
700 m_bColored = true;
701 }
702
Handle_SetCachedDevice()703 void CPDF_StreamContentParser::Handle_SetCachedDevice() {
704 for (int i = 0; i < 6; i++) {
705 m_Type3Data[i] = GetNumber(5 - i);
706 }
707 m_bColored = false;
708 }
709
Handle_ExecuteXObject()710 void CPDF_StreamContentParser::Handle_ExecuteXObject() {
711 ByteString name = GetString(0);
712 if (name == m_LastImageName && m_pLastImage && m_pLastImage->GetStream() &&
713 m_pLastImage->GetStream()->GetObjNum()) {
714 CPDF_ImageObject* pObj = AddImage(m_pLastImage);
715 // Record the bounding box of this image, so rendering code can draw it
716 // properly.
717 if (pObj && pObj->GetImage()->IsMask())
718 m_pObjectHolder->AddImageMaskBoundingBox(pObj->GetRect());
719 return;
720 }
721
722 CPDF_Stream* pXObject = ToStream(FindResourceObj("XObject", name));
723 if (!pXObject) {
724 m_bResourceMissing = true;
725 return;
726 }
727
728 ByteString type;
729 if (pXObject->GetDict())
730 type = pXObject->GetDict()->GetStringFor("Subtype");
731
732 if (type == "Form") {
733 AddForm(pXObject);
734 return;
735 }
736
737 if (type == "Image") {
738 CPDF_ImageObject* pObj = pXObject->IsInline()
739 ? AddImage(ToStream(pXObject->Clone()))
740 : AddImage(pXObject->GetObjNum());
741
742 m_LastImageName = std::move(name);
743 if (pObj) {
744 m_pLastImage = pObj->GetImage();
745 if (m_pLastImage->IsMask())
746 m_pObjectHolder->AddImageMaskBoundingBox(pObj->GetRect());
747 }
748 }
749 }
750
AddForm(CPDF_Stream * pStream)751 void CPDF_StreamContentParser::AddForm(CPDF_Stream* pStream) {
752 CPDF_AllStates status;
753 status.m_GeneralState = m_pCurStates->m_GeneralState;
754 status.m_GraphState = m_pCurStates->m_GraphState;
755 status.m_ColorState = m_pCurStates->m_ColorState;
756 status.m_TextState = m_pCurStates->m_TextState;
757 auto form = std::make_unique<CPDF_Form>(
758 m_pDocument.Get(), m_pPageResources.Get(), pStream, m_pResources.Get());
759 form->ParseContent(&status, nullptr, m_ParsedSet.Get());
760
761 CFX_Matrix matrix = m_pCurStates->m_CTM * m_mtContentToUser;
762
763 auto pFormObj = std::make_unique<CPDF_FormObject>(GetCurrentStreamIndex(),
764 std::move(form), matrix);
765 if (!m_pObjectHolder->BackgroundAlphaNeeded() &&
766 pFormObj->form()->BackgroundAlphaNeeded()) {
767 m_pObjectHolder->SetBackgroundAlphaNeeded(true);
768 }
769 pFormObj->CalcBoundingBox();
770 SetGraphicStates(pFormObj.get(), true, true, true);
771 m_pObjectHolder->AppendPageObject(std::move(pFormObj));
772 }
773
AddImage(RetainPtr<CPDF_Stream> pStream)774 CPDF_ImageObject* CPDF_StreamContentParser::AddImage(
775 RetainPtr<CPDF_Stream> pStream) {
776 if (!pStream)
777 return nullptr;
778
779 auto pImageObj = std::make_unique<CPDF_ImageObject>(GetCurrentStreamIndex());
780 pImageObj->SetImage(
781 pdfium::MakeRetain<CPDF_Image>(m_pDocument.Get(), std::move(pStream)));
782
783 return AddImageObject(std::move(pImageObj));
784 }
785
AddImage(uint32_t streamObjNum)786 CPDF_ImageObject* CPDF_StreamContentParser::AddImage(uint32_t streamObjNum) {
787 auto pImageObj = std::make_unique<CPDF_ImageObject>(GetCurrentStreamIndex());
788 pImageObj->SetImage(CPDF_DocPageData::FromDocument(m_pDocument.Get())
789 ->GetImage(streamObjNum));
790
791 return AddImageObject(std::move(pImageObj));
792 }
793
AddImage(const RetainPtr<CPDF_Image> & pImage)794 CPDF_ImageObject* CPDF_StreamContentParser::AddImage(
795 const RetainPtr<CPDF_Image>& pImage) {
796 if (!pImage)
797 return nullptr;
798
799 auto pImageObj = std::make_unique<CPDF_ImageObject>(GetCurrentStreamIndex());
800 pImageObj->SetImage(CPDF_DocPageData::FromDocument(m_pDocument.Get())
801 ->GetImage(pImage->GetStream()->GetObjNum()));
802
803 return AddImageObject(std::move(pImageObj));
804 }
805
AddImageObject(std::unique_ptr<CPDF_ImageObject> pImageObj)806 CPDF_ImageObject* CPDF_StreamContentParser::AddImageObject(
807 std::unique_ptr<CPDF_ImageObject> pImageObj) {
808 SetGraphicStates(pImageObj.get(), pImageObj->GetImage()->IsMask(), false,
809 false);
810
811 CFX_Matrix ImageMatrix = m_pCurStates->m_CTM * m_mtContentToUser;
812 pImageObj->set_matrix(ImageMatrix);
813 pImageObj->CalcBoundingBox();
814
815 CPDF_ImageObject* pRet = pImageObj.get();
816 m_pObjectHolder->AppendPageObject(std::move(pImageObj));
817 return pRet;
818 }
819
GetColors() const820 std::vector<float> CPDF_StreamContentParser::GetColors() const {
821 ASSERT(m_ParamCount > 0);
822 return GetNumbers(m_ParamCount);
823 }
824
GetNamedColors() const825 std::vector<float> CPDF_StreamContentParser::GetNamedColors() const {
826 ASSERT(m_ParamCount > 0);
827 const uint32_t nvalues = m_ParamCount - 1;
828 std::vector<float> values(nvalues);
829 for (size_t i = 0; i < nvalues; ++i)
830 values[i] = GetNumber(m_ParamCount - i - 1);
831 return values;
832 }
833
Handle_MarkPlace_Dictionary()834 void CPDF_StreamContentParser::Handle_MarkPlace_Dictionary() {}
835
Handle_EndImage()836 void CPDF_StreamContentParser::Handle_EndImage() {}
837
Handle_EndMarkedContent()838 void CPDF_StreamContentParser::Handle_EndMarkedContent() {
839 // First element is a sentinel, so do not pop it, ever. This may come up if
840 // the EMCs are mismatched with the BMC/BDCs.
841 if (m_ContentMarksStack.size() > 1)
842 m_ContentMarksStack.pop();
843 }
844
Handle_EndText()845 void CPDF_StreamContentParser::Handle_EndText() {
846 if (m_ClipTextList.empty())
847 return;
848
849 if (TextRenderingModeIsClipMode(m_pCurStates->m_TextState.GetTextMode()))
850 m_pCurStates->m_ClipPath.AppendTexts(&m_ClipTextList);
851
852 m_ClipTextList.clear();
853 }
854
Handle_FillPath()855 void CPDF_StreamContentParser::Handle_FillPath() {
856 AddPathObject(CFX_FillRenderOptions::FillType::kWinding, false);
857 }
858
Handle_FillPathOld()859 void CPDF_StreamContentParser::Handle_FillPathOld() {
860 AddPathObject(CFX_FillRenderOptions::FillType::kWinding, false);
861 }
862
Handle_EOFillPath()863 void CPDF_StreamContentParser::Handle_EOFillPath() {
864 AddPathObject(CFX_FillRenderOptions::FillType::kEvenOdd, false);
865 }
866
Handle_SetGray_Fill()867 void CPDF_StreamContentParser::Handle_SetGray_Fill() {
868 RetainPtr<CPDF_ColorSpace> pCS =
869 CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
870 m_pCurStates->m_ColorState.SetFillColor(pCS, GetNumbers(1));
871 }
872
Handle_SetGray_Stroke()873 void CPDF_StreamContentParser::Handle_SetGray_Stroke() {
874 RetainPtr<CPDF_ColorSpace> pCS =
875 CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
876 m_pCurStates->m_ColorState.SetStrokeColor(pCS, GetNumbers(1));
877 }
878
Handle_SetExtendGraphState()879 void CPDF_StreamContentParser::Handle_SetExtendGraphState() {
880 ByteString name = GetString(0);
881 CPDF_Dictionary* pGS = ToDictionary(FindResourceObj("ExtGState", name));
882 if (!pGS) {
883 m_bResourceMissing = true;
884 return;
885 }
886 m_pCurStates->ProcessExtGS(pGS, this);
887 }
888
Handle_ClosePath()889 void CPDF_StreamContentParser::Handle_ClosePath() {
890 if (m_PathPoints.empty())
891 return;
892
893 if (m_PathStartX != m_PathCurrentX || m_PathStartY != m_PathCurrentY)
894 AddPathPoint(m_PathStartX, m_PathStartY, FXPT_TYPE::LineTo, true);
895 else if (m_PathPoints.back().m_Type != FXPT_TYPE::MoveTo)
896 m_PathPoints.back().m_CloseFigure = true;
897 }
898
Handle_SetFlat()899 void CPDF_StreamContentParser::Handle_SetFlat() {
900 m_pCurStates->m_GeneralState.SetFlatness(GetNumber(0));
901 }
902
Handle_BeginImageData()903 void CPDF_StreamContentParser::Handle_BeginImageData() {}
904
Handle_SetLineJoin()905 void CPDF_StreamContentParser::Handle_SetLineJoin() {
906 m_pCurStates->m_GraphState.SetLineJoin(
907 static_cast<CFX_GraphStateData::LineJoin>(GetInteger(0)));
908 }
909
Handle_SetLineCap()910 void CPDF_StreamContentParser::Handle_SetLineCap() {
911 m_pCurStates->m_GraphState.SetLineCap(
912 static_cast<CFX_GraphStateData::LineCap>(GetInteger(0)));
913 }
914
Handle_SetCMYKColor_Fill()915 void CPDF_StreamContentParser::Handle_SetCMYKColor_Fill() {
916 if (m_ParamCount != 4)
917 return;
918
919 RetainPtr<CPDF_ColorSpace> pCS =
920 CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
921 m_pCurStates->m_ColorState.SetFillColor(pCS, GetNumbers(4));
922 }
923
Handle_SetCMYKColor_Stroke()924 void CPDF_StreamContentParser::Handle_SetCMYKColor_Stroke() {
925 if (m_ParamCount != 4)
926 return;
927
928 RetainPtr<CPDF_ColorSpace> pCS =
929 CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
930 m_pCurStates->m_ColorState.SetStrokeColor(pCS, GetNumbers(4));
931 }
932
Handle_LineTo()933 void CPDF_StreamContentParser::Handle_LineTo() {
934 if (m_ParamCount != 2)
935 return;
936
937 AddPathPoint(GetNumber(1), GetNumber(0), FXPT_TYPE::LineTo, false);
938 }
939
Handle_MoveTo()940 void CPDF_StreamContentParser::Handle_MoveTo() {
941 if (m_ParamCount != 2)
942 return;
943
944 AddPathPoint(GetNumber(1), GetNumber(0), FXPT_TYPE::MoveTo, false);
945 ParsePathObject();
946 }
947
Handle_SetMiterLimit()948 void CPDF_StreamContentParser::Handle_SetMiterLimit() {
949 m_pCurStates->m_GraphState.SetMiterLimit(GetNumber(0));
950 }
951
Handle_MarkPlace()952 void CPDF_StreamContentParser::Handle_MarkPlace() {}
953
Handle_EndPath()954 void CPDF_StreamContentParser::Handle_EndPath() {
955 AddPathObject(CFX_FillRenderOptions::FillType::kNoFill, false);
956 }
957
Handle_SaveGraphState()958 void CPDF_StreamContentParser::Handle_SaveGraphState() {
959 auto pStates = std::make_unique<CPDF_AllStates>();
960 pStates->Copy(*m_pCurStates);
961 m_StateStack.push_back(std::move(pStates));
962 }
963
Handle_RestoreGraphState()964 void CPDF_StreamContentParser::Handle_RestoreGraphState() {
965 if (m_StateStack.empty())
966 return;
967 std::unique_ptr<CPDF_AllStates> pStates = std::move(m_StateStack.back());
968 m_StateStack.pop_back();
969 m_pCurStates->Copy(*pStates);
970 }
971
Handle_Rectangle()972 void CPDF_StreamContentParser::Handle_Rectangle() {
973 float x = GetNumber(3), y = GetNumber(2);
974 float w = GetNumber(1), h = GetNumber(0);
975 AddPathRect(x, y, w, h);
976 }
977
AddPathRect(float x,float y,float w,float h)978 void CPDF_StreamContentParser::AddPathRect(float x, float y, float w, float h) {
979 AddPathPoint(x, y, FXPT_TYPE::MoveTo, false);
980 AddPathPoint(x + w, y, FXPT_TYPE::LineTo, false);
981 AddPathPoint(x + w, y + h, FXPT_TYPE::LineTo, false);
982 AddPathPoint(x, y + h, FXPT_TYPE::LineTo, false);
983 AddPathPoint(x, y, FXPT_TYPE::LineTo, true);
984 }
985
Handle_SetRGBColor_Fill()986 void CPDF_StreamContentParser::Handle_SetRGBColor_Fill() {
987 if (m_ParamCount != 3)
988 return;
989
990 RetainPtr<CPDF_ColorSpace> pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
991 m_pCurStates->m_ColorState.SetFillColor(pCS, GetNumbers(3));
992 }
993
Handle_SetRGBColor_Stroke()994 void CPDF_StreamContentParser::Handle_SetRGBColor_Stroke() {
995 if (m_ParamCount != 3)
996 return;
997
998 RetainPtr<CPDF_ColorSpace> pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
999 m_pCurStates->m_ColorState.SetStrokeColor(pCS, GetNumbers(3));
1000 }
1001
Handle_SetRenderIntent()1002 void CPDF_StreamContentParser::Handle_SetRenderIntent() {}
1003
Handle_CloseStrokePath()1004 void CPDF_StreamContentParser::Handle_CloseStrokePath() {
1005 Handle_ClosePath();
1006 AddPathObject(CFX_FillRenderOptions::FillType::kNoFill, true);
1007 }
1008
Handle_StrokePath()1009 void CPDF_StreamContentParser::Handle_StrokePath() {
1010 AddPathObject(CFX_FillRenderOptions::FillType::kNoFill, true);
1011 }
1012
Handle_SetColor_Fill()1013 void CPDF_StreamContentParser::Handle_SetColor_Fill() {
1014 int nargs = std::min(m_ParamCount, 4U);
1015 m_pCurStates->m_ColorState.SetFillColor(nullptr, GetNumbers(nargs));
1016 }
1017
Handle_SetColor_Stroke()1018 void CPDF_StreamContentParser::Handle_SetColor_Stroke() {
1019 int nargs = std::min(m_ParamCount, 4U);
1020 m_pCurStates->m_ColorState.SetStrokeColor(nullptr, GetNumbers(nargs));
1021 }
1022
Handle_SetColorPS_Fill()1023 void CPDF_StreamContentParser::Handle_SetColorPS_Fill() {
1024 CPDF_Object* pLastParam = GetObject(0);
1025 if (!pLastParam)
1026 return;
1027
1028 if (!pLastParam->IsName()) {
1029 m_pCurStates->m_ColorState.SetFillColor(nullptr, GetColors());
1030 return;
1031 }
1032
1033 // A valid |pLastParam| implies |m_ParamCount| > 0, so GetNamedColors() call
1034 // below is safe.
1035 RetainPtr<CPDF_Pattern> pPattern = FindPattern(GetString(0), false);
1036 if (pPattern)
1037 m_pCurStates->m_ColorState.SetFillPattern(pPattern, GetNamedColors());
1038 }
1039
Handle_SetColorPS_Stroke()1040 void CPDF_StreamContentParser::Handle_SetColorPS_Stroke() {
1041 CPDF_Object* pLastParam = GetObject(0);
1042 if (!pLastParam)
1043 return;
1044
1045 if (!pLastParam->IsName()) {
1046 m_pCurStates->m_ColorState.SetStrokeColor(nullptr, GetColors());
1047 return;
1048 }
1049
1050 // A valid |pLastParam| implies |m_ParamCount| > 0, so GetNamedColors() call
1051 // below is safe.
1052 RetainPtr<CPDF_Pattern> pPattern = FindPattern(GetString(0), false);
1053 if (pPattern)
1054 m_pCurStates->m_ColorState.SetStrokePattern(pPattern, GetNamedColors());
1055 }
1056
Handle_ShadeFill()1057 void CPDF_StreamContentParser::Handle_ShadeFill() {
1058 RetainPtr<CPDF_Pattern> pPattern = FindPattern(GetString(0), true);
1059 if (!pPattern)
1060 return;
1061
1062 CPDF_ShadingPattern* pShading = pPattern->AsShadingPattern();
1063 if (!pShading)
1064 return;
1065
1066 if (!pShading->IsShadingObject() || !pShading->Load())
1067 return;
1068
1069 CFX_Matrix matrix = m_pCurStates->m_CTM * m_mtContentToUser;
1070 auto pObj = std::make_unique<CPDF_ShadingObject>(GetCurrentStreamIndex(),
1071 pShading, matrix);
1072 SetGraphicStates(pObj.get(), false, false, false);
1073 CFX_FloatRect bbox =
1074 pObj->m_ClipPath.HasRef() ? pObj->m_ClipPath.GetClipBox() : m_BBox;
1075 if (pShading->IsMeshShading())
1076 bbox.Intersect(GetShadingBBox(pShading, pObj->matrix()));
1077 pObj->SetRect(bbox);
1078 m_pObjectHolder->AppendPageObject(std::move(pObj));
1079 }
1080
Handle_SetCharSpace()1081 void CPDF_StreamContentParser::Handle_SetCharSpace() {
1082 m_pCurStates->m_TextState.SetCharSpace(GetNumber(0));
1083 }
1084
Handle_MoveTextPoint()1085 void CPDF_StreamContentParser::Handle_MoveTextPoint() {
1086 m_pCurStates->m_TextLinePos += CFX_PointF(GetNumber(1), GetNumber(0));
1087 m_pCurStates->m_TextPos = m_pCurStates->m_TextLinePos;
1088 }
1089
Handle_MoveTextPoint_SetLeading()1090 void CPDF_StreamContentParser::Handle_MoveTextPoint_SetLeading() {
1091 Handle_MoveTextPoint();
1092 m_pCurStates->m_TextLeading = -GetNumber(0);
1093 }
1094
Handle_SetFont()1095 void CPDF_StreamContentParser::Handle_SetFont() {
1096 float fs = GetNumber(0);
1097 if (fs == 0) {
1098 constexpr float kDefaultFontSize = 0.0f;
1099 fs = kDefaultFontSize;
1100 }
1101
1102 m_pCurStates->m_TextState.SetFontSize(fs);
1103 RetainPtr<CPDF_Font> pFont = FindFont(GetString(1));
1104 if (pFont)
1105 m_pCurStates->m_TextState.SetFont(pFont);
1106 }
1107
FindResourceHolder(const ByteString & type)1108 CPDF_Dictionary* CPDF_StreamContentParser::FindResourceHolder(
1109 const ByteString& type) {
1110 if (!m_pResources)
1111 return nullptr;
1112
1113 CPDF_Dictionary* pDict = m_pResources->GetDictFor(type);
1114 if (pDict)
1115 return pDict;
1116
1117 if (m_pResources == m_pPageResources || !m_pPageResources)
1118 return nullptr;
1119
1120 return m_pPageResources->GetDictFor(type);
1121 }
1122
FindResourceObj(const ByteString & type,const ByteString & name)1123 CPDF_Object* CPDF_StreamContentParser::FindResourceObj(const ByteString& type,
1124 const ByteString& name) {
1125 CPDF_Dictionary* pHolder = FindResourceHolder(type);
1126 return pHolder ? pHolder->GetDirectObjectFor(name) : nullptr;
1127 }
1128
FindFont(const ByteString & name)1129 RetainPtr<CPDF_Font> CPDF_StreamContentParser::FindFont(
1130 const ByteString& name) {
1131 CPDF_Dictionary* pFontDict = ToDictionary(FindResourceObj("Font", name));
1132 if (!pFontDict) {
1133 m_bResourceMissing = true;
1134 return CPDF_Font::GetStockFont(m_pDocument.Get(),
1135 CFX_Font::kDefaultAnsiFontName);
1136 }
1137 RetainPtr<CPDF_Font> pFont =
1138 CPDF_DocPageData::FromDocument(m_pDocument.Get())->GetFont(pFontDict);
1139 if (pFont && pFont->IsType3Font()) {
1140 pFont->AsType3Font()->SetPageResources(m_pResources.Get());
1141 pFont->AsType3Font()->CheckType3FontMetrics();
1142 }
1143 return pFont;
1144 }
1145
FindColorSpace(const ByteString & name)1146 RetainPtr<CPDF_ColorSpace> CPDF_StreamContentParser::FindColorSpace(
1147 const ByteString& name) {
1148 if (name == "Pattern")
1149 return CPDF_ColorSpace::GetStockCS(PDFCS_PATTERN);
1150
1151 if (name == "DeviceGray" || name == "DeviceCMYK" || name == "DeviceRGB") {
1152 ByteString defname = "Default";
1153 defname += name.Last(name.GetLength() - 7);
1154 const CPDF_Object* pDefObj = FindResourceObj("ColorSpace", defname);
1155 if (!pDefObj) {
1156 if (name == "DeviceGray")
1157 return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
1158
1159 if (name == "DeviceRGB")
1160 return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
1161
1162 return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
1163 }
1164 return CPDF_DocPageData::FromDocument(m_pDocument.Get())
1165 ->GetColorSpace(pDefObj, nullptr);
1166 }
1167 const CPDF_Object* pCSObj = FindResourceObj("ColorSpace", name);
1168 if (!pCSObj) {
1169 m_bResourceMissing = true;
1170 return nullptr;
1171 }
1172 return CPDF_DocPageData::FromDocument(m_pDocument.Get())
1173 ->GetColorSpace(pCSObj, nullptr);
1174 }
1175
FindPattern(const ByteString & name,bool bShading)1176 RetainPtr<CPDF_Pattern> CPDF_StreamContentParser::FindPattern(
1177 const ByteString& name,
1178 bool bShading) {
1179 CPDF_Object* pPattern =
1180 FindResourceObj(bShading ? "Shading" : "Pattern", name);
1181 if (!pPattern || (!pPattern->IsDictionary() && !pPattern->IsStream())) {
1182 m_bResourceMissing = true;
1183 return nullptr;
1184 }
1185 return CPDF_DocPageData::FromDocument(m_pDocument.Get())
1186 ->GetPattern(pPattern, bShading, m_pCurStates->m_ParentMatrix);
1187 }
1188
AddTextObject(const ByteString * pStrs,float fInitKerning,const std::vector<float> & kernings,size_t nSegs)1189 void CPDF_StreamContentParser::AddTextObject(const ByteString* pStrs,
1190 float fInitKerning,
1191 const std::vector<float>& kernings,
1192 size_t nSegs) {
1193 RetainPtr<CPDF_Font> pFont = m_pCurStates->m_TextState.GetFont();
1194 if (!pFont)
1195 return;
1196
1197 if (fInitKerning != 0) {
1198 if (pFont->IsVertWriting())
1199 m_pCurStates->m_TextPos.y -= GetVerticalTextSize(fInitKerning);
1200 else
1201 m_pCurStates->m_TextPos.x -= GetHorizontalTextSize(fInitKerning);
1202 }
1203 if (nSegs == 0)
1204 return;
1205
1206 const TextRenderingMode text_mode =
1207 pFont->IsType3Font() ? TextRenderingMode::MODE_FILL
1208 : m_pCurStates->m_TextState.GetTextMode();
1209 {
1210 auto pText = std::make_unique<CPDF_TextObject>(GetCurrentStreamIndex());
1211 m_pLastTextObject = pText.get();
1212 SetGraphicStates(m_pLastTextObject.Get(), true, true, true);
1213 if (TextRenderingModeIsStrokeMode(text_mode)) {
1214 float* pCTM = pText->m_TextState.GetMutableCTM();
1215 pCTM[0] = m_pCurStates->m_CTM.a;
1216 pCTM[1] = m_pCurStates->m_CTM.c;
1217 pCTM[2] = m_pCurStates->m_CTM.b;
1218 pCTM[3] = m_pCurStates->m_CTM.d;
1219 }
1220 pText->SetSegments(pStrs, kernings, nSegs);
1221 pText->SetPosition(
1222 m_mtContentToUser.Transform(m_pCurStates->m_CTM.Transform(
1223 m_pCurStates->m_TextMatrix.Transform(CFX_PointF(
1224 m_pCurStates->m_TextPos.x,
1225 m_pCurStates->m_TextPos.y + m_pCurStates->m_TextRise)))));
1226
1227 m_pCurStates->m_TextPos +=
1228 pText->CalcPositionData(m_pCurStates->m_TextHorzScale);
1229 if (TextRenderingModeIsClipMode(text_mode)) {
1230 m_ClipTextList.push_back(
1231 std::unique_ptr<CPDF_TextObject>(pText->Clone()));
1232 }
1233 m_pObjectHolder->AppendPageObject(std::move(pText));
1234 }
1235 if (!kernings.empty() && kernings[nSegs - 1] != 0) {
1236 if (pFont->IsVertWriting())
1237 m_pCurStates->m_TextPos.y -= GetVerticalTextSize(kernings[nSegs - 1]);
1238 else
1239 m_pCurStates->m_TextPos.x -= GetHorizontalTextSize(kernings[nSegs - 1]);
1240 }
1241 }
1242
GetHorizontalTextSize(float fKerning) const1243 float CPDF_StreamContentParser::GetHorizontalTextSize(float fKerning) const {
1244 return GetVerticalTextSize(fKerning) * m_pCurStates->m_TextHorzScale;
1245 }
1246
GetVerticalTextSize(float fKerning) const1247 float CPDF_StreamContentParser::GetVerticalTextSize(float fKerning) const {
1248 return fKerning * m_pCurStates->m_TextState.GetFontSize() / 1000;
1249 }
1250
GetCurrentStreamIndex()1251 int32_t CPDF_StreamContentParser::GetCurrentStreamIndex() {
1252 auto it =
1253 std::upper_bound(m_StreamStartOffsets.begin(), m_StreamStartOffsets.end(),
1254 m_pSyntax->GetPos() + m_StartParseOffset);
1255 return (it - m_StreamStartOffsets.begin()) - 1;
1256 }
1257
Handle_ShowText()1258 void CPDF_StreamContentParser::Handle_ShowText() {
1259 ByteString str = GetString(0);
1260 if (!str.IsEmpty())
1261 AddTextObject(&str, 0, std::vector<float>(), 1);
1262 }
1263
Handle_ShowText_Positioning()1264 void CPDF_StreamContentParser::Handle_ShowText_Positioning() {
1265 CPDF_Array* pArray = ToArray(GetObject(0));
1266 if (!pArray)
1267 return;
1268
1269 size_t n = pArray->size();
1270 size_t nsegs = 0;
1271 for (size_t i = 0; i < n; i++) {
1272 const CPDF_Object* pDirectObject = pArray->GetDirectObjectAt(i);
1273 if (pDirectObject && pDirectObject->IsString())
1274 nsegs++;
1275 }
1276 if (nsegs == 0) {
1277 for (size_t i = 0; i < n; i++) {
1278 float fKerning = pArray->GetNumberAt(i);
1279 if (fKerning != 0)
1280 m_pCurStates->m_TextPos.x -= GetHorizontalTextSize(fKerning);
1281 }
1282 return;
1283 }
1284 std::vector<ByteString> strs(nsegs);
1285 std::vector<float> kernings(nsegs);
1286 size_t iSegment = 0;
1287 float fInitKerning = 0;
1288 for (size_t i = 0; i < n; i++) {
1289 CPDF_Object* pObj = pArray->GetDirectObjectAt(i);
1290 if (!pObj)
1291 continue;
1292
1293 if (pObj->IsString()) {
1294 ByteString str = pObj->GetString();
1295 if (str.IsEmpty())
1296 continue;
1297 strs[iSegment] = std::move(str);
1298 kernings[iSegment++] = 0;
1299 } else {
1300 float num = pObj->GetNumber();
1301 if (iSegment == 0)
1302 fInitKerning += num;
1303 else
1304 kernings[iSegment - 1] += num;
1305 }
1306 }
1307 AddTextObject(strs.data(), fInitKerning, kernings, iSegment);
1308 }
1309
Handle_SetTextLeading()1310 void CPDF_StreamContentParser::Handle_SetTextLeading() {
1311 m_pCurStates->m_TextLeading = GetNumber(0);
1312 }
1313
Handle_SetTextMatrix()1314 void CPDF_StreamContentParser::Handle_SetTextMatrix() {
1315 m_pCurStates->m_TextMatrix =
1316 CFX_Matrix(GetNumber(5), GetNumber(4), GetNumber(3), GetNumber(2),
1317 GetNumber(1), GetNumber(0));
1318 OnChangeTextMatrix();
1319 m_pCurStates->m_TextPos = CFX_PointF();
1320 m_pCurStates->m_TextLinePos = CFX_PointF();
1321 }
1322
OnChangeTextMatrix()1323 void CPDF_StreamContentParser::OnChangeTextMatrix() {
1324 CFX_Matrix text_matrix(m_pCurStates->m_TextHorzScale, 0.0f, 0.0f, 1.0f, 0.0f,
1325 0.0f);
1326 text_matrix.Concat(m_pCurStates->m_TextMatrix);
1327 text_matrix.Concat(m_pCurStates->m_CTM);
1328 text_matrix.Concat(m_mtContentToUser);
1329 float* pTextMatrix = m_pCurStates->m_TextState.GetMutableMatrix();
1330 pTextMatrix[0] = text_matrix.a;
1331 pTextMatrix[1] = text_matrix.c;
1332 pTextMatrix[2] = text_matrix.b;
1333 pTextMatrix[3] = text_matrix.d;
1334 }
1335
Handle_SetTextRenderMode()1336 void CPDF_StreamContentParser::Handle_SetTextRenderMode() {
1337 TextRenderingMode mode;
1338 if (SetTextRenderingModeFromInt(GetInteger(0), &mode))
1339 m_pCurStates->m_TextState.SetTextMode(mode);
1340 }
1341
Handle_SetTextRise()1342 void CPDF_StreamContentParser::Handle_SetTextRise() {
1343 m_pCurStates->m_TextRise = GetNumber(0);
1344 }
1345
Handle_SetWordSpace()1346 void CPDF_StreamContentParser::Handle_SetWordSpace() {
1347 m_pCurStates->m_TextState.SetWordSpace(GetNumber(0));
1348 }
1349
Handle_SetHorzScale()1350 void CPDF_StreamContentParser::Handle_SetHorzScale() {
1351 if (m_ParamCount != 1) {
1352 return;
1353 }
1354 m_pCurStates->m_TextHorzScale = GetNumber(0) / 100;
1355 OnChangeTextMatrix();
1356 }
1357
Handle_MoveToNextLine()1358 void CPDF_StreamContentParser::Handle_MoveToNextLine() {
1359 m_pCurStates->m_TextLinePos.y -= m_pCurStates->m_TextLeading;
1360 m_pCurStates->m_TextPos = m_pCurStates->m_TextLinePos;
1361 }
1362
Handle_CurveTo_23()1363 void CPDF_StreamContentParser::Handle_CurveTo_23() {
1364 AddPathPoint(m_PathCurrentX, m_PathCurrentY, FXPT_TYPE::BezierTo, false);
1365 AddPathPoint(GetNumber(3), GetNumber(2), FXPT_TYPE::BezierTo, false);
1366 AddPathPoint(GetNumber(1), GetNumber(0), FXPT_TYPE::BezierTo, false);
1367 }
1368
Handle_SetLineWidth()1369 void CPDF_StreamContentParser::Handle_SetLineWidth() {
1370 m_pCurStates->m_GraphState.SetLineWidth(GetNumber(0));
1371 }
1372
Handle_Clip()1373 void CPDF_StreamContentParser::Handle_Clip() {
1374 m_PathClipType = CFX_FillRenderOptions::FillType::kWinding;
1375 }
1376
Handle_EOClip()1377 void CPDF_StreamContentParser::Handle_EOClip() {
1378 m_PathClipType = CFX_FillRenderOptions::FillType::kEvenOdd;
1379 }
1380
Handle_CurveTo_13()1381 void CPDF_StreamContentParser::Handle_CurveTo_13() {
1382 AddPathPoint(GetNumber(3), GetNumber(2), FXPT_TYPE::BezierTo, false);
1383 AddPathPoint(GetNumber(1), GetNumber(0), FXPT_TYPE::BezierTo, false);
1384 AddPathPoint(GetNumber(1), GetNumber(0), FXPT_TYPE::BezierTo, false);
1385 }
1386
Handle_NextLineShowText()1387 void CPDF_StreamContentParser::Handle_NextLineShowText() {
1388 Handle_MoveToNextLine();
1389 Handle_ShowText();
1390 }
1391
Handle_NextLineShowText_Space()1392 void CPDF_StreamContentParser::Handle_NextLineShowText_Space() {
1393 m_pCurStates->m_TextState.SetWordSpace(GetNumber(2));
1394 m_pCurStates->m_TextState.SetCharSpace(GetNumber(1));
1395 Handle_NextLineShowText();
1396 }
1397
Handle_Invalid()1398 void CPDF_StreamContentParser::Handle_Invalid() {}
1399
AddPathPoint(float x,float y,FXPT_TYPE type,bool close)1400 void CPDF_StreamContentParser::AddPathPoint(float x,
1401 float y,
1402 FXPT_TYPE type,
1403 bool close) {
1404 // If the path point is the same move as the previous one and neither of them
1405 // closes the path, then just skip it.
1406 if (!close && type == FXPT_TYPE::MoveTo && !m_PathPoints.empty() &&
1407 !m_PathPoints.back().m_CloseFigure &&
1408 m_PathPoints.back().m_Type == type && m_PathCurrentX == x &&
1409 m_PathCurrentY == y) {
1410 return;
1411 }
1412
1413 m_PathCurrentX = x;
1414 m_PathCurrentY = y;
1415 if (type == FXPT_TYPE::MoveTo && !close) {
1416 m_PathStartX = x;
1417 m_PathStartY = y;
1418 if (!m_PathPoints.empty() &&
1419 m_PathPoints.back().IsTypeAndOpen(FXPT_TYPE::MoveTo)) {
1420 m_PathPoints.back().m_Point = CFX_PointF(x, y);
1421 return;
1422 }
1423 } else if (m_PathPoints.empty()) {
1424 return;
1425 }
1426 m_PathPoints.push_back(FX_PATHPOINT(CFX_PointF(x, y), type, close));
1427 }
1428
AddPathObject(CFX_FillRenderOptions::FillType fill_type,bool bStroke)1429 void CPDF_StreamContentParser::AddPathObject(
1430 CFX_FillRenderOptions::FillType fill_type,
1431 bool bStroke) {
1432 std::vector<FX_PATHPOINT> path_points;
1433 path_points.swap(m_PathPoints);
1434 CFX_FillRenderOptions::FillType path_clip_type = m_PathClipType;
1435 m_PathClipType = CFX_FillRenderOptions::FillType::kNoFill;
1436
1437 if (path_points.empty())
1438 return;
1439
1440 if (path_points.size() == 1) {
1441 if (path_clip_type != CFX_FillRenderOptions::FillType::kNoFill) {
1442 CPDF_Path path;
1443 path.AppendRect(0, 0, 0, 0);
1444 m_pCurStates->m_ClipPath.AppendPath(
1445 path, CFX_FillRenderOptions::FillType::kWinding, true);
1446 }
1447 return;
1448 }
1449
1450 if (path_points.back().IsTypeAndOpen(FXPT_TYPE::MoveTo))
1451 path_points.pop_back();
1452
1453 CPDF_Path path;
1454 for (const auto& point : path_points) {
1455 if (point.m_CloseFigure)
1456 path.AppendPointAndClose(point.m_Point, point.m_Type);
1457 else
1458 path.AppendPoint(point.m_Point, point.m_Type);
1459 }
1460
1461 CFX_Matrix matrix = m_pCurStates->m_CTM * m_mtContentToUser;
1462 if (bStroke || fill_type != CFX_FillRenderOptions::FillType::kNoFill) {
1463 auto pPathObj = std::make_unique<CPDF_PathObject>(GetCurrentStreamIndex());
1464 pPathObj->set_stroke(bStroke);
1465 pPathObj->set_filltype(fill_type);
1466 pPathObj->path() = path;
1467 pPathObj->set_matrix(matrix);
1468 SetGraphicStates(pPathObj.get(), true, false, true);
1469 pPathObj->CalcBoundingBox();
1470 m_pObjectHolder->AppendPageObject(std::move(pPathObj));
1471 }
1472 if (path_clip_type != CFX_FillRenderOptions::FillType::kNoFill) {
1473 if (!matrix.IsIdentity())
1474 path.Transform(matrix);
1475 m_pCurStates->m_ClipPath.AppendPath(path, path_clip_type, true);
1476 }
1477 }
1478
Parse(const uint8_t * pData,uint32_t dwSize,uint32_t start_offset,uint32_t max_cost,const std::vector<uint32_t> & stream_start_offsets)1479 uint32_t CPDF_StreamContentParser::Parse(
1480 const uint8_t* pData,
1481 uint32_t dwSize,
1482 uint32_t start_offset,
1483 uint32_t max_cost,
1484 const std::vector<uint32_t>& stream_start_offsets) {
1485 ASSERT(start_offset < dwSize);
1486
1487 // Parsing will be done from |pDataStart|, for at most |size_left| bytes.
1488 const uint8_t* pDataStart = pData + start_offset;
1489 uint32_t size_left = dwSize - start_offset;
1490
1491 m_StartParseOffset = start_offset;
1492
1493 if (m_ParsedSet->size() > kMaxFormLevel ||
1494 pdfium::Contains(*m_ParsedSet, pDataStart)) {
1495 return size_left;
1496 }
1497
1498 m_StreamStartOffsets = stream_start_offsets;
1499
1500 pdfium::ScopedSetInsertion<const uint8_t*> scopedInsert(m_ParsedSet.Get(),
1501 pDataStart);
1502
1503 uint32_t init_obj_count = m_pObjectHolder->GetPageObjectCount();
1504 CPDF_StreamParser syntax(pdfium::make_span(pDataStart, size_left),
1505 m_pDocument->GetByteStringPool());
1506 AutoNuller<UnownedPtr<CPDF_StreamParser>> auto_clearer(&m_pSyntax);
1507 m_pSyntax = &syntax;
1508 while (1) {
1509 uint32_t cost = m_pObjectHolder->GetPageObjectCount() - init_obj_count;
1510 if (max_cost && cost >= max_cost) {
1511 break;
1512 }
1513 switch (syntax.ParseNextElement()) {
1514 case CPDF_StreamParser::EndOfData:
1515 return m_pSyntax->GetPos();
1516 case CPDF_StreamParser::Keyword:
1517 OnOperator(syntax.GetWord());
1518 ClearAllParams();
1519 break;
1520 case CPDF_StreamParser::Number:
1521 AddNumberParam(syntax.GetWord());
1522 break;
1523 case CPDF_StreamParser::Name: {
1524 auto word = syntax.GetWord();
1525 AddNameParam(word.Last(word.GetLength() - 1));
1526 break;
1527 }
1528 default:
1529 AddObjectParam(syntax.GetObject());
1530 }
1531 }
1532 return m_pSyntax->GetPos();
1533 }
1534
ParsePathObject()1535 void CPDF_StreamContentParser::ParsePathObject() {
1536 float params[6] = {};
1537 int nParams = 0;
1538 int last_pos = m_pSyntax->GetPos();
1539 while (1) {
1540 CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
1541 bool bProcessed = true;
1542 switch (type) {
1543 case CPDF_StreamParser::EndOfData:
1544 return;
1545 case CPDF_StreamParser::Keyword: {
1546 ByteStringView strc = m_pSyntax->GetWord();
1547 int len = strc.GetLength();
1548 if (len == 1) {
1549 switch (strc[0]) {
1550 case kPathOperatorSubpath:
1551 AddPathPoint(params[0], params[1], FXPT_TYPE::MoveTo, false);
1552 nParams = 0;
1553 break;
1554 case kPathOperatorLine:
1555 AddPathPoint(params[0], params[1], FXPT_TYPE::LineTo, false);
1556 nParams = 0;
1557 break;
1558 case kPathOperatorCubicBezier1:
1559 AddPathPoint(params[0], params[1], FXPT_TYPE::BezierTo, false);
1560 AddPathPoint(params[2], params[3], FXPT_TYPE::BezierTo, false);
1561 AddPathPoint(params[4], params[5], FXPT_TYPE::BezierTo, false);
1562 nParams = 0;
1563 break;
1564 case kPathOperatorCubicBezier2:
1565 AddPathPoint(m_PathCurrentX, m_PathCurrentY, FXPT_TYPE::BezierTo,
1566 false);
1567 AddPathPoint(params[0], params[1], FXPT_TYPE::BezierTo, false);
1568 AddPathPoint(params[2], params[3], FXPT_TYPE::BezierTo, false);
1569 nParams = 0;
1570 break;
1571 case kPathOperatorCubicBezier3:
1572 AddPathPoint(params[0], params[1], FXPT_TYPE::BezierTo, false);
1573 AddPathPoint(params[2], params[3], FXPT_TYPE::BezierTo, false);
1574 AddPathPoint(params[2], params[3], FXPT_TYPE::BezierTo, false);
1575 nParams = 0;
1576 break;
1577 case kPathOperatorClosePath:
1578 Handle_ClosePath();
1579 nParams = 0;
1580 break;
1581 default:
1582 bProcessed = false;
1583 break;
1584 }
1585 } else if (len == 2) {
1586 if (strc[0] == kPathOperatorRectangle[0] &&
1587 strc[1] == kPathOperatorRectangle[1]) {
1588 AddPathRect(params[0], params[1], params[2], params[3]);
1589 nParams = 0;
1590 } else {
1591 bProcessed = false;
1592 }
1593 } else {
1594 bProcessed = false;
1595 }
1596 if (bProcessed) {
1597 last_pos = m_pSyntax->GetPos();
1598 }
1599 break;
1600 }
1601 case CPDF_StreamParser::Number: {
1602 if (nParams == 6)
1603 break;
1604
1605 FX_Number number(m_pSyntax->GetWord());
1606 params[nParams++] = number.GetFloat();
1607 break;
1608 }
1609 default:
1610 bProcessed = false;
1611 }
1612 if (!bProcessed) {
1613 m_pSyntax->SetPos(last_pos);
1614 return;
1615 }
1616 }
1617 }
1618
1619 // static
FindKeyAbbreviationForTesting(ByteStringView abbr)1620 ByteStringView CPDF_StreamContentParser::FindKeyAbbreviationForTesting(
1621 ByteStringView abbr) {
1622 return FindFullName(kInlineKeyAbbr, pdfium::size(kInlineKeyAbbr), abbr);
1623 }
1624
1625 // static
FindValueAbbreviationForTesting(ByteStringView abbr)1626 ByteStringView CPDF_StreamContentParser::FindValueAbbreviationForTesting(
1627 ByteStringView abbr) {
1628 return FindFullName(kInlineValueAbbr, pdfium::size(kInlineValueAbbr), abbr);
1629 }
1630
1631 CPDF_StreamContentParser::ContentParam::ContentParam() = default;
1632
1633 CPDF_StreamContentParser::ContentParam::~ContentParam() = default;
1634