Revert "Make m_pShadingObj a CPDF_Stream instead of CPDF_Object."
[pdfium.git] / core / src / fpdfapi / fpdf_page / fpdf_page_parser.cpp
1 // Copyright 2014 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 "../../../include/fpdfapi/fpdf_page.h"
8 #include "../../../include/fpdfapi/fpdf_module.h"
9 #include "../../../include/fpdfapi/fpdf_serial.h"
10 #include "pageint.h"
11
12 #define REQUIRE_PARAMS(count)  \
13   if (m_ParamCount != count) { \
14     return;                    \
15   }
16
17 CPDF_StreamContentParser::CPDF_StreamContentParser(
18     CPDF_Document* pDocument,
19     CPDF_Dictionary* pPageResources,
20     CPDF_Dictionary* pParentResources,
21     CFX_AffineMatrix* pmtContentToUser,
22     CPDF_PageObjects* pObjList,
23     CPDF_Dictionary* pResources,
24     CPDF_Rect* pBBox,
25     CPDF_ParseOptions* pOptions,
26     CPDF_AllStates* pStates,
27     int level)
28     : m_pDocument(pDocument),
29       m_pPageResources(pPageResources),
30       m_pParentResources(pParentResources),
31       m_pResources(pResources),
32       m_pObjectList(pObjList),
33       m_Level(level),
34       m_ParamStartPos(0),
35       m_ParamCount(0),
36       m_pCurStates(new CPDF_AllStates),
37       m_pLastTextObject(nullptr),
38       m_DefFontSize(0),
39       m_pPathPoints(nullptr),
40       m_PathPointCount(0),
41       m_PathAllocSize(0),
42       m_PathCurrentX(0.0f),
43       m_PathCurrentY(0.0f),
44       m_PathClipType(0),
45       m_pLastImage(nullptr),
46       m_pLastImageDict(nullptr),
47       m_pLastCloneImageDict(nullptr),
48       m_bReleaseLastDict(TRUE),
49       m_bColored(FALSE),
50       m_bResourceMissing(FALSE) {
51   if (pmtContentToUser) {
52     m_mtContentToUser = *pmtContentToUser;
53   }
54   if (pOptions) {
55     m_Options = *pOptions;
56   }
57   if (!m_pResources) {
58     m_pResources = m_pParentResources;
59   }
60   if (!m_pResources) {
61     m_pResources = m_pPageResources;
62   }
63   if (pBBox) {
64     m_BBox = *pBBox;
65   }
66   if (pStates) {
67     m_pCurStates->Copy(*pStates);
68   } else {
69     m_pCurStates->m_GeneralState.New();
70     m_pCurStates->m_GraphState.New();
71     m_pCurStates->m_TextState.New();
72     m_pCurStates->m_ColorState.New();
73   }
74   for (size_t i = 0; i < FX_ArraySize(m_Type3Data); ++i) {
75     m_Type3Data[i] = 0.0;
76   }
77 }
78
79 CPDF_StreamContentParser::~CPDF_StreamContentParser() {
80   ClearAllParams();
81   for (int i = 0; i < m_StateStack.GetSize(); ++i) {
82     delete (CPDF_AllStates*)m_StateStack[i];
83   }
84   FX_Free(m_pPathPoints);
85   if (m_pLastImageDict) {
86     m_pLastImageDict->Release();
87   }
88   if (m_pLastCloneImageDict) {
89     m_pLastCloneImageDict->Release();
90   }
91 }
92 int CPDF_StreamContentParser::GetNextParamPos() {
93   if (m_ParamCount == PARAM_BUF_SIZE) {
94     m_ParamStartPos++;
95     if (m_ParamStartPos == PARAM_BUF_SIZE) {
96       m_ParamStartPos = 0;
97     }
98     if (m_ParamBuf1[m_ParamStartPos].m_Type == 0) {
99       if (CPDF_Object* pObject = m_ParamBuf1[m_ParamStartPos].m_pObject)
100         pObject->Release();
101     }
102     return m_ParamStartPos;
103   }
104   int index = m_ParamStartPos + m_ParamCount;
105   if (index >= PARAM_BUF_SIZE) {
106     index -= PARAM_BUF_SIZE;
107   }
108   m_ParamCount++;
109   return index;
110 }
111 void CPDF_StreamContentParser::AddNameParam(const FX_CHAR* name, int len) {
112   int index = GetNextParamPos();
113   if (len > 32) {
114     m_ParamBuf1[index].m_Type = 0;
115     m_ParamBuf1[index].m_pObject =
116         CPDF_Name::Create(PDF_NameDecode(CFX_ByteStringC(name, len)));
117   } else {
118     m_ParamBuf1[index].m_Type = PDFOBJ_NAME;
119     if (FXSYS_memchr(name, '#', len) == NULL) {
120       FXSYS_memcpy(m_ParamBuf1[index].m_Name.m_Buffer, name, len);
121       m_ParamBuf1[index].m_Name.m_Len = len;
122     } else {
123       CFX_ByteString str = PDF_NameDecode(CFX_ByteStringC(name, len));
124       FXSYS_memcpy(m_ParamBuf1[index].m_Name.m_Buffer, str.c_str(),
125                    str.GetLength());
126       m_ParamBuf1[index].m_Name.m_Len = str.GetLength();
127     }
128   }
129 }
130 void CPDF_StreamContentParser::AddNumberParam(const FX_CHAR* str, int len) {
131   int index = GetNextParamPos();
132   m_ParamBuf1[index].m_Type = PDFOBJ_NUMBER;
133   FX_atonum(CFX_ByteStringC(str, len), m_ParamBuf1[index].m_Number.m_bInteger,
134             &m_ParamBuf1[index].m_Number.m_Integer);
135 }
136 void CPDF_StreamContentParser::AddObjectParam(CPDF_Object* pObj) {
137   int index = GetNextParamPos();
138   m_ParamBuf1[index].m_Type = 0;
139   m_ParamBuf1[index].m_pObject = pObj;
140 }
141 void CPDF_StreamContentParser::ClearAllParams() {
142   FX_DWORD index = m_ParamStartPos;
143   for (FX_DWORD i = 0; i < m_ParamCount; i++) {
144     if (m_ParamBuf1[index].m_Type == 0) {
145       if (CPDF_Object* pObject = m_ParamBuf1[index].m_pObject)
146         pObject->Release();
147     }
148     index++;
149     if (index == PARAM_BUF_SIZE) {
150       index = 0;
151     }
152   }
153   m_ParamStartPos = 0;
154   m_ParamCount = 0;
155 }
156 CPDF_Object* CPDF_StreamContentParser::GetObject(FX_DWORD index) {
157   if (index >= m_ParamCount) {
158     return NULL;
159   }
160   int real_index = m_ParamStartPos + m_ParamCount - index - 1;
161   if (real_index >= PARAM_BUF_SIZE) {
162     real_index -= PARAM_BUF_SIZE;
163   }
164   _ContentParam& param = m_ParamBuf1[real_index];
165   if (param.m_Type == PDFOBJ_NUMBER) {
166     CPDF_Number* pNumber = param.m_Number.m_bInteger
167                                ? CPDF_Number::Create(param.m_Number.m_Integer)
168                                : CPDF_Number::Create(param.m_Number.m_Float);
169
170     param.m_Type = 0;
171     param.m_pObject = pNumber;
172     return pNumber;
173   }
174   if (param.m_Type == PDFOBJ_NAME) {
175     CPDF_Name* pName = CPDF_Name::Create(
176         CFX_ByteString(param.m_Name.m_Buffer, param.m_Name.m_Len));
177     param.m_Type = 0;
178     param.m_pObject = pName;
179     return pName;
180   }
181   if (param.m_Type == 0) {
182     return param.m_pObject;
183   }
184   ASSERT(FALSE);
185   return NULL;
186 }
187 CFX_ByteString CPDF_StreamContentParser::GetString(FX_DWORD index) {
188   if (index >= m_ParamCount) {
189     return CFX_ByteString();
190   }
191   int real_index = m_ParamStartPos + m_ParamCount - index - 1;
192   if (real_index >= PARAM_BUF_SIZE) {
193     real_index -= PARAM_BUF_SIZE;
194   }
195   _ContentParam& param = m_ParamBuf1[real_index];
196   if (param.m_Type == PDFOBJ_NAME) {
197     return CFX_ByteString(param.m_Name.m_Buffer, param.m_Name.m_Len);
198   }
199   if (param.m_Type == 0 && param.m_pObject) {
200     return param.m_pObject->GetString();
201   }
202   return CFX_ByteString();
203 }
204 FX_FLOAT CPDF_StreamContentParser::GetNumber(FX_DWORD index) {
205   if (index >= m_ParamCount) {
206     return 0;
207   }
208   int real_index = m_ParamStartPos + m_ParamCount - index - 1;
209   if (real_index >= PARAM_BUF_SIZE) {
210     real_index -= PARAM_BUF_SIZE;
211   }
212   _ContentParam& param = m_ParamBuf1[real_index];
213   if (param.m_Type == PDFOBJ_NUMBER) {
214     return param.m_Number.m_bInteger ? (FX_FLOAT)param.m_Number.m_Integer
215                                      : param.m_Number.m_Float;
216   }
217   if (param.m_Type == 0 && param.m_pObject) {
218     return param.m_pObject->GetNumber();
219   }
220   return 0;
221 }
222 FX_FLOAT CPDF_StreamContentParser::GetNumber16(FX_DWORD index) {
223   return GetNumber(index);
224 }
225 void CPDF_StreamContentParser::SetGraphicStates(CPDF_PageObject* pObj,
226                                                 FX_BOOL bColor,
227                                                 FX_BOOL bText,
228                                                 FX_BOOL bGraph) {
229   pObj->m_GeneralState = m_pCurStates->m_GeneralState;
230   pObj->m_ClipPath = m_pCurStates->m_ClipPath;
231   pObj->m_ContentMark = m_CurContentMark;
232   if (bColor) {
233     pObj->m_ColorState = m_pCurStates->m_ColorState;
234   }
235   if (bGraph) {
236     pObj->m_GraphState = m_pCurStates->m_GraphState;
237   }
238   if (bText) {
239     pObj->m_TextState = m_pCurStates->m_TextState;
240   }
241 }
242
243 const CPDF_StreamContentParser::OpCode CPDF_StreamContentParser::g_OpCodes[] = {
244     {FXBSTR_ID('"', 0, 0, 0),
245      &CPDF_StreamContentParser::Handle_NextLineShowText_Space},
246     {FXBSTR_ID('\'', 0, 0, 0),
247      &CPDF_StreamContentParser::Handle_NextLineShowText},
248     {FXBSTR_ID('B', 0, 0, 0), &CPDF_StreamContentParser::Handle_FillStrokePath},
249     {FXBSTR_ID('B', '*', 0, 0),
250      &CPDF_StreamContentParser::Handle_EOFillStrokePath},
251     {FXBSTR_ID('B', 'D', 'C', 0),
252      &CPDF_StreamContentParser::Handle_BeginMarkedContent_Dictionary},
253     {FXBSTR_ID('B', 'I', 0, 0), &CPDF_StreamContentParser::Handle_BeginImage},
254     {FXBSTR_ID('B', 'M', 'C', 0),
255      &CPDF_StreamContentParser::Handle_BeginMarkedContent},
256     {FXBSTR_ID('B', 'T', 0, 0), &CPDF_StreamContentParser::Handle_BeginText},
257     {FXBSTR_ID('B', 'X', 0, 0),
258      &CPDF_StreamContentParser::Handle_BeginSectionUndefined},
259     {FXBSTR_ID('C', 'S', 0, 0),
260      &CPDF_StreamContentParser::Handle_SetColorSpace_Stroke},
261     {FXBSTR_ID('D', 'P', 0, 0),
262      &CPDF_StreamContentParser::Handle_MarkPlace_Dictionary},
263     {FXBSTR_ID('D', 'o', 0, 0),
264      &CPDF_StreamContentParser::Handle_ExecuteXObject},
265     {FXBSTR_ID('E', 'I', 0, 0), &CPDF_StreamContentParser::Handle_EndImage},
266     {FXBSTR_ID('E', 'M', 'C', 0),
267      &CPDF_StreamContentParser::Handle_EndMarkedContent},
268     {FXBSTR_ID('E', 'T', 0, 0), &CPDF_StreamContentParser::Handle_EndText},
269     {FXBSTR_ID('E', 'X', 0, 0),
270      &CPDF_StreamContentParser::Handle_EndSectionUndefined},
271     {FXBSTR_ID('F', 0, 0, 0), &CPDF_StreamContentParser::Handle_FillPathOld},
272     {FXBSTR_ID('G', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetGray_Stroke},
273     {FXBSTR_ID('I', 'D', 0, 0),
274      &CPDF_StreamContentParser::Handle_BeginImageData},
275     {FXBSTR_ID('J', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineCap},
276     {FXBSTR_ID('K', 0, 0, 0),
277      &CPDF_StreamContentParser::Handle_SetCMYKColor_Stroke},
278     {FXBSTR_ID('M', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetMiterLimit},
279     {FXBSTR_ID('M', 'P', 0, 0), &CPDF_StreamContentParser::Handle_MarkPlace},
280     {FXBSTR_ID('Q', 0, 0, 0),
281      &CPDF_StreamContentParser::Handle_RestoreGraphState},
282     {FXBSTR_ID('R', 'G', 0, 0),
283      &CPDF_StreamContentParser::Handle_SetRGBColor_Stroke},
284     {FXBSTR_ID('S', 0, 0, 0), &CPDF_StreamContentParser::Handle_StrokePath},
285     {FXBSTR_ID('S', 'C', 0, 0),
286      &CPDF_StreamContentParser::Handle_SetColor_Stroke},
287     {FXBSTR_ID('S', 'C', 'N', 0),
288      &CPDF_StreamContentParser::Handle_SetColorPS_Stroke},
289     {FXBSTR_ID('T', '*', 0, 0),
290      &CPDF_StreamContentParser::Handle_MoveToNextLine},
291     {FXBSTR_ID('T', 'D', 0, 0),
292      &CPDF_StreamContentParser::Handle_MoveTextPoint_SetLeading},
293     {FXBSTR_ID('T', 'J', 0, 0),
294      &CPDF_StreamContentParser::Handle_ShowText_Positioning},
295     {FXBSTR_ID('T', 'L', 0, 0),
296      &CPDF_StreamContentParser::Handle_SetTextLeading},
297     {FXBSTR_ID('T', 'c', 0, 0), &CPDF_StreamContentParser::Handle_SetCharSpace},
298     {FXBSTR_ID('T', 'd', 0, 0),
299      &CPDF_StreamContentParser::Handle_MoveTextPoint},
300     {FXBSTR_ID('T', 'f', 0, 0), &CPDF_StreamContentParser::Handle_SetFont},
301     {FXBSTR_ID('T', 'j', 0, 0), &CPDF_StreamContentParser::Handle_ShowText},
302     {FXBSTR_ID('T', 'm', 0, 0),
303      &CPDF_StreamContentParser::Handle_SetTextMatrix},
304     {FXBSTR_ID('T', 'r', 0, 0),
305      &CPDF_StreamContentParser::Handle_SetTextRenderMode},
306     {FXBSTR_ID('T', 's', 0, 0), &CPDF_StreamContentParser::Handle_SetTextRise},
307     {FXBSTR_ID('T', 'w', 0, 0), &CPDF_StreamContentParser::Handle_SetWordSpace},
308     {FXBSTR_ID('T', 'z', 0, 0), &CPDF_StreamContentParser::Handle_SetHorzScale},
309     {FXBSTR_ID('W', 0, 0, 0), &CPDF_StreamContentParser::Handle_Clip},
310     {FXBSTR_ID('W', '*', 0, 0), &CPDF_StreamContentParser::Handle_EOClip},
311     {FXBSTR_ID('b', 0, 0, 0),
312      &CPDF_StreamContentParser::Handle_CloseFillStrokePath},
313     {FXBSTR_ID('b', '*', 0, 0),
314      &CPDF_StreamContentParser::Handle_CloseEOFillStrokePath},
315     {FXBSTR_ID('c', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_123},
316     {FXBSTR_ID('c', 'm', 0, 0), &CPDF_StreamContentParser::Handle_ConcatMatrix},
317     {FXBSTR_ID('c', 's', 0, 0),
318      &CPDF_StreamContentParser::Handle_SetColorSpace_Fill},
319     {FXBSTR_ID('d', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetDash},
320     {FXBSTR_ID('d', '0', 0, 0), &CPDF_StreamContentParser::Handle_SetCharWidth},
321     {FXBSTR_ID('d', '1', 0, 0),
322      &CPDF_StreamContentParser::Handle_SetCachedDevice},
323     {FXBSTR_ID('f', 0, 0, 0), &CPDF_StreamContentParser::Handle_FillPath},
324     {FXBSTR_ID('f', '*', 0, 0), &CPDF_StreamContentParser::Handle_EOFillPath},
325     {FXBSTR_ID('g', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetGray_Fill},
326     {FXBSTR_ID('g', 's', 0, 0),
327      &CPDF_StreamContentParser::Handle_SetExtendGraphState},
328     {FXBSTR_ID('h', 0, 0, 0), &CPDF_StreamContentParser::Handle_ClosePath},
329     {FXBSTR_ID('i', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetFlat},
330     {FXBSTR_ID('j', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineJoin},
331     {FXBSTR_ID('k', 0, 0, 0),
332      &CPDF_StreamContentParser::Handle_SetCMYKColor_Fill},
333     {FXBSTR_ID('l', 0, 0, 0), &CPDF_StreamContentParser::Handle_LineTo},
334     {FXBSTR_ID('m', 0, 0, 0), &CPDF_StreamContentParser::Handle_MoveTo},
335     {FXBSTR_ID('n', 0, 0, 0), &CPDF_StreamContentParser::Handle_EndPath},
336     {FXBSTR_ID('q', 0, 0, 0), &CPDF_StreamContentParser::Handle_SaveGraphState},
337     {FXBSTR_ID('r', 'e', 0, 0), &CPDF_StreamContentParser::Handle_Rectangle},
338     {FXBSTR_ID('r', 'g', 0, 0),
339      &CPDF_StreamContentParser::Handle_SetRGBColor_Fill},
340     {FXBSTR_ID('r', 'i', 0, 0),
341      &CPDF_StreamContentParser::Handle_SetRenderIntent},
342     {FXBSTR_ID('s', 0, 0, 0),
343      &CPDF_StreamContentParser::Handle_CloseStrokePath},
344     {FXBSTR_ID('s', 'c', 0, 0),
345      &CPDF_StreamContentParser::Handle_SetColor_Fill},
346     {FXBSTR_ID('s', 'c', 'n', 0),
347      &CPDF_StreamContentParser::Handle_SetColorPS_Fill},
348     {FXBSTR_ID('s', 'h', 0, 0), &CPDF_StreamContentParser::Handle_ShadeFill},
349     {FXBSTR_ID('v', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_23},
350     {FXBSTR_ID('w', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineWidth},
351     {FXBSTR_ID('y', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_13},
352 };
353 FX_BOOL CPDF_StreamContentParser::OnOperator(const FX_CHAR* op) {
354   int i = 0;
355   FX_DWORD opid = 0;
356   while (i < 4 && op[i]) {
357     opid = (opid << 8) + op[i];
358     i++;
359   }
360   while (i < 4) {
361     opid <<= 8;
362     i++;
363   };
364   int low = 0, high = sizeof g_OpCodes / sizeof(OpCode) - 1;
365   while (low <= high) {
366     int middle = (low + high) / 2;
367     int compare = opid - g_OpCodes[middle].m_OpId;
368     if (compare == 0) {
369       (this->*g_OpCodes[middle].m_OpHandler)();
370       return TRUE;
371     }
372     if (compare < 0) {
373       high = middle - 1;
374     } else {
375       low = middle + 1;
376     }
377   }
378   return m_CompatCount != 0;
379 }
380 void CPDF_StreamContentParser::Handle_CloseFillStrokePath() {
381   if (m_Options.m_bTextOnly) {
382     return;
383   }
384   Handle_ClosePath();
385   AddPathObject(FXFILL_WINDING, TRUE);
386 }
387 void CPDF_StreamContentParser::Handle_FillStrokePath() {
388   if (m_Options.m_bTextOnly) {
389     return;
390   }
391   AddPathObject(FXFILL_WINDING, TRUE);
392 }
393 void CPDF_StreamContentParser::Handle_CloseEOFillStrokePath() {
394   if (m_Options.m_bTextOnly) {
395     return;
396   }
397   AddPathPoint(m_PathStartX, m_PathStartY, FXPT_LINETO | FXPT_CLOSEFIGURE);
398   AddPathObject(FXFILL_ALTERNATE, TRUE);
399 }
400 void CPDF_StreamContentParser::Handle_EOFillStrokePath() {
401   if (m_Options.m_bTextOnly) {
402     return;
403   }
404   AddPathObject(FXFILL_ALTERNATE, TRUE);
405 }
406 void CPDF_StreamContentParser::Handle_BeginMarkedContent_Dictionary() {
407   if (!m_Options.m_bMarkedContent) {
408     return;
409   }
410   CFX_ByteString tag = GetString(1);
411   CPDF_Object* pProperty = GetObject(0);
412   if (pProperty == NULL) {
413     return;
414   }
415   FX_BOOL bDirect = TRUE;
416   if (pProperty->IsName()) {
417     pProperty = FindResourceObj(FX_BSTRC("Properties"), pProperty->GetString());
418     if (!pProperty)
419       return;
420     bDirect = FALSE;
421   }
422   if (CPDF_Dictionary* pDict = pProperty->AsDictionary()) {
423     m_CurContentMark.GetModify()->AddMark(tag, pDict, bDirect);
424   }
425 }
426 void CPDF_StreamContentParser::Handle_BeginMarkedContent() {
427   if (!m_Options.m_bMarkedContent) {
428     return;
429   }
430   CFX_ByteString tag = GetString(0);
431   m_CurContentMark.GetModify()->AddMark(tag, NULL, FALSE);
432 }
433 struct _FX_BSTR {
434   const FX_CHAR* m_Ptr;
435   int m_Size;
436 };
437 #define _FX_BSTRC(str) \
438   { str, sizeof(str) - 1 }
439 const _FX_BSTR _PDF_InlineKeyAbbr[] = {
440     _FX_BSTRC("BitsPerComponent"),
441     _FX_BSTRC("BPC"),
442     _FX_BSTRC("ColorSpace"),
443     _FX_BSTRC("CS"),
444     _FX_BSTRC("Decode"),
445     _FX_BSTRC("D"),
446     _FX_BSTRC("DecodeParms"),
447     _FX_BSTRC("DP"),
448     _FX_BSTRC("Filter"),
449     _FX_BSTRC("F"),
450     _FX_BSTRC("Height"),
451     _FX_BSTRC("H"),
452     _FX_BSTRC("ImageMask"),
453     _FX_BSTRC("IM"),
454     _FX_BSTRC("Interpolate"),
455     _FX_BSTRC("I"),
456     _FX_BSTRC("Width"),
457     _FX_BSTRC("W"),
458 };
459 const _FX_BSTR _PDF_InlineValueAbbr[] = {
460     _FX_BSTRC("DeviceGray"),      _FX_BSTRC("G"),
461     _FX_BSTRC("DeviceRGB"),       _FX_BSTRC("RGB"),
462     _FX_BSTRC("DeviceCMYK"),      _FX_BSTRC("CMYK"),
463     _FX_BSTRC("Indexed"),         _FX_BSTRC("I"),
464     _FX_BSTRC("ASCIIHexDecode"),  _FX_BSTRC("AHx"),
465     _FX_BSTRC("ASCII85Decode"),   _FX_BSTRC("A85"),
466     _FX_BSTRC("LZWDecode"),       _FX_BSTRC("LZW"),
467     _FX_BSTRC("FlateDecode"),     _FX_BSTRC("Fl"),
468     _FX_BSTRC("RunLengthDecode"), _FX_BSTRC("RL"),
469     _FX_BSTRC("CCITTFaxDecode"),  _FX_BSTRC("CCF"),
470     _FX_BSTRC("DCTDecode"),       _FX_BSTRC("DCT"),
471 };
472 static CFX_ByteStringC _PDF_FindFullName(const _FX_BSTR* table,
473                                          int count,
474                                          const CFX_ByteStringC& abbr) {
475   int i = 0;
476   while (i < count) {
477     if (abbr.GetLength() == table[i + 1].m_Size &&
478         FXSYS_memcmp(abbr.GetPtr(), table[i + 1].m_Ptr, abbr.GetLength()) ==
479             0) {
480       return CFX_ByteStringC(table[i].m_Ptr, table[i].m_Size);
481     }
482     i += 2;
483   }
484   return CFX_ByteStringC();
485 }
486 void _PDF_ReplaceAbbr(CPDF_Object* pObj) {
487   switch (pObj->GetType()) {
488     case PDFOBJ_DICTIONARY: {
489       CPDF_Dictionary* pDict = pObj->AsDictionary();
490       FX_POSITION pos = pDict->GetStartPos();
491       while (pos) {
492         CFX_ByteString key;
493         CPDF_Object* value = pDict->GetNextElement(pos, key);
494         CFX_ByteStringC fullname = _PDF_FindFullName(
495             _PDF_InlineKeyAbbr, sizeof _PDF_InlineKeyAbbr / sizeof(_FX_BSTR),
496             key);
497         if (!fullname.IsEmpty()) {
498           pDict->ReplaceKey(key, fullname);
499           key = fullname;
500         }
501
502         if (value->IsName()) {
503           CFX_ByteString name = value->GetString();
504           fullname = _PDF_FindFullName(
505               _PDF_InlineValueAbbr,
506               sizeof _PDF_InlineValueAbbr / sizeof(_FX_BSTR), name);
507           if (!fullname.IsEmpty()) {
508             pDict->SetAtName(key, fullname);
509           }
510         } else {
511           _PDF_ReplaceAbbr(value);
512         }
513       }
514       break;
515     }
516     case PDFOBJ_ARRAY: {
517       CPDF_Array* pArray = pObj->AsArray();
518       for (FX_DWORD i = 0; i < pArray->GetCount(); i++) {
519         CPDF_Object* pElement = pArray->GetElement(i);
520         if (pElement->IsName()) {
521           CFX_ByteString name = pElement->GetString();
522           CFX_ByteStringC fullname = _PDF_FindFullName(
523               _PDF_InlineValueAbbr,
524               sizeof _PDF_InlineValueAbbr / sizeof(_FX_BSTR), name);
525           if (!fullname.IsEmpty()) {
526             pArray->SetAt(i, CPDF_Name::Create(fullname));
527           }
528         } else {
529           _PDF_ReplaceAbbr(pElement);
530         }
531       }
532       break;
533     }
534   }
535 }
536 static CFX_ByteStringC _PDF_FindAbbrName(const _FX_BSTR* table,
537                                          int count,
538                                          const CFX_ByteStringC& fullName) {
539   int i = 0;
540   while (i < count) {
541     if (fullName.GetLength() == table[i].m_Size &&
542         FXSYS_memcmp(fullName.GetPtr(), table[i].m_Ptr, fullName.GetLength()) ==
543             0) {
544       return CFX_ByteStringC(table[i + 1].m_Ptr, table[i + 1].m_Size);
545     }
546     i += 2;
547   }
548   return CFX_ByteStringC();
549 }
550 void _PDF_ReplaceFull(CPDF_Object* pObj) {
551   switch (pObj->GetType()) {
552     case PDFOBJ_DICTIONARY: {
553       CPDF_Dictionary* pDict = pObj->AsDictionary();
554       FX_POSITION pos = pDict->GetStartPos();
555       while (pos) {
556         CFX_ByteString key;
557         CPDF_Object* value = pDict->GetNextElement(pos, key);
558         CFX_ByteStringC abbrName = _PDF_FindAbbrName(
559             _PDF_InlineKeyAbbr, sizeof(_PDF_InlineKeyAbbr) / sizeof(_FX_BSTR),
560             key);
561         if (!abbrName.IsEmpty()) {
562           pDict->ReplaceKey(key, abbrName);
563           key = abbrName;
564         }
565         if (value->IsName()) {
566           CFX_ByteString name = value->GetString();
567           abbrName = _PDF_FindAbbrName(
568               _PDF_InlineValueAbbr,
569               sizeof(_PDF_InlineValueAbbr) / sizeof(_FX_BSTR), name);
570           if (!abbrName.IsEmpty()) {
571             pDict->SetAtName(key, abbrName);
572           }
573         } else {
574           _PDF_ReplaceFull(value);
575         }
576       }
577       break;
578     }
579     case PDFOBJ_ARRAY: {
580       CPDF_Array* pArray = pObj->AsArray();
581       for (FX_DWORD i = 0; i < pArray->GetCount(); i++) {
582         CPDF_Object* pElement = pArray->GetElement(i);
583         if (pElement->IsName()) {
584           CFX_ByteString name = pElement->GetString();
585           CFX_ByteStringC abbrName = _PDF_FindAbbrName(
586               _PDF_InlineValueAbbr,
587               sizeof _PDF_InlineValueAbbr / sizeof(_FX_BSTR), name);
588           if (!abbrName.IsEmpty()) {
589             pArray->SetAt(i, CPDF_Name::Create(abbrName));
590           }
591         } else {
592           _PDF_ReplaceFull(pElement);
593         }
594       }
595       break;
596     }
597   }
598 }
599 void CPDF_StreamContentParser::Handle_BeginText() {
600   m_pCurStates->m_TextMatrix.Set(1.0f, 0, 0, 1.0f, 0, 0);
601   OnChangeTextMatrix();
602   m_pCurStates->m_TextX = 0;
603   m_pCurStates->m_TextY = 0;
604   m_pCurStates->m_TextLineX = 0;
605   m_pCurStates->m_TextLineY = 0;
606 }
607 void CPDF_StreamContentParser::Handle_BeginSectionUndefined() {
608   m_CompatCount++;
609 }
610 void CPDF_StreamContentParser::Handle_CurveTo_123() {
611   if (m_Options.m_bTextOnly) {
612     return;
613   }
614   AddPathPoint(GetNumber(5), GetNumber(4), FXPT_BEZIERTO);
615   AddPathPoint(GetNumber(3), GetNumber(2), FXPT_BEZIERTO);
616   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
617 }
618 void CPDF_StreamContentParser::Handle_ConcatMatrix() {
619   FX_FLOAT a2 = GetNumber16(5), b2 = GetNumber16(4), c2 = GetNumber16(3),
620            d2 = GetNumber16(2);
621   FX_FLOAT e2 = GetNumber(1), f2 = GetNumber(0);
622   CFX_AffineMatrix new_matrix(a2, b2, c2, d2, e2, f2);
623   new_matrix.Concat(m_pCurStates->m_CTM);
624   m_pCurStates->m_CTM = new_matrix;
625   OnChangeTextMatrix();
626 }
627 void CPDF_StreamContentParser::Handle_SetColorSpace_Fill() {
628   if (m_Options.m_bTextOnly) {
629     return;
630   }
631   CFX_ByteString csname = GetString(0);
632   CPDF_ColorSpace* pCS = FindColorSpace(csname);
633   if (pCS == NULL) {
634     return;
635   }
636   m_pCurStates->m_ColorState.GetModify()->m_FillColor.SetColorSpace(pCS);
637 }
638 void CPDF_StreamContentParser::Handle_SetColorSpace_Stroke() {
639   if (m_Options.m_bTextOnly) {
640     return;
641   }
642   CFX_ByteString csname = GetString(0);
643   CPDF_ColorSpace* pCS = FindColorSpace(csname);
644   if (pCS == NULL) {
645     return;
646   }
647   m_pCurStates->m_ColorState.GetModify()->m_StrokeColor.SetColorSpace(pCS);
648 }
649 void CPDF_StreamContentParser::Handle_SetDash() {
650   if (m_Options.m_bTextOnly) {
651     return;
652   }
653   CPDF_Array* pArray = GetObject(1) ? GetObject(1)->GetArray() : NULL;
654   if (pArray == NULL) {
655     return;
656   }
657   m_pCurStates->SetLineDash(pArray, GetNumber(0), 1.0f);
658 }
659 void CPDF_StreamContentParser::Handle_SetCharWidth() {
660   m_Type3Data[0] = GetNumber(1);
661   m_Type3Data[1] = GetNumber(0);
662   m_bColored = TRUE;
663 }
664 void CPDF_StreamContentParser::Handle_SetCachedDevice() {
665   for (int i = 0; i < 6; i++) {
666     m_Type3Data[i] = GetNumber(5 - i);
667   }
668   m_bColored = FALSE;
669 }
670 void CPDF_StreamContentParser::Handle_ExecuteXObject() {
671   CFX_ByteString name = GetString(0);
672   if (name == m_LastImageName && m_pLastImage && m_pLastImage->GetStream() &&
673       m_pLastImage->GetStream()->GetObjNum()) {
674     AddImage(nullptr, m_pLastImage, FALSE);
675     return;
676   }
677
678   if (m_Options.m_bTextOnly) {
679     if (!m_pResources)
680       return;
681
682     CPDF_Dictionary* pList = m_pResources->GetDict(FX_BSTRC("XObject"));
683     if (!pList && m_pPageResources && m_pResources != m_pPageResources)
684       pList = m_pPageResources->GetDict(FX_BSTRC("XObject"));
685     if (!pList)
686       return;
687     CPDF_Reference* pRes = ToReference(pList->GetElement(name));
688     if (!pRes)
689       return;
690
691     FX_BOOL bForm;
692     if (m_pDocument->IsFormStream(pRes->GetRefObjNum(), bForm) && !bForm)
693       return;
694   }
695
696   CPDF_Stream* pXObject = ToStream(FindResourceObj(FX_BSTRC("XObject"), name));
697   if (!pXObject) {
698     m_bResourceMissing = TRUE;
699     return;
700   }
701
702   CFX_ByteStringC type =
703       pXObject->GetDict()
704           ? pXObject->GetDict()->GetConstString(FX_BSTRC("Subtype"))
705           : CFX_ByteStringC();
706   if (type == FX_BSTRC("Image")) {
707     if (m_Options.m_bTextOnly) {
708       return;
709     }
710     CPDF_ImageObject* pObj = AddImage(pXObject, NULL, FALSE);
711     m_LastImageName = name;
712     m_pLastImage = pObj->m_pImage;
713   } else if (type == FX_BSTRC("Form")) {
714     AddForm(pXObject);
715   } else {
716     return;
717   }
718 }
719 void CPDF_StreamContentParser::AddForm(CPDF_Stream* pStream) {
720   if (!m_Options.m_bSeparateForm) {
721     CPDF_Dictionary* pResources =
722         pStream->GetDict()->GetDict(FX_BSTRC("Resources"));
723     CFX_AffineMatrix form_matrix =
724         pStream->GetDict()->GetMatrix(FX_BSTRC("Matrix"));
725     form_matrix.Concat(m_pCurStates->m_CTM);
726     CPDF_Array* pBBox = pStream->GetDict()->GetArray(FX_BSTRC("BBox"));
727     CFX_FloatRect form_bbox;
728     CPDF_Path ClipPath;
729     if (pBBox) {
730       form_bbox = pStream->GetDict()->GetRect(FX_BSTRC("BBox"));
731       ClipPath.New();
732       ClipPath.AppendRect(form_bbox.left, form_bbox.bottom, form_bbox.right,
733                           form_bbox.top);
734       ClipPath.Transform(&form_matrix);
735       form_bbox.Transform(&form_matrix);
736     }
737     CPDF_StreamContentParser parser(m_pDocument, m_pPageResources, m_pResources,
738                                     &m_mtContentToUser, m_pObjectList,
739                                     pResources, &form_bbox, &m_Options,
740                                     m_pCurStates.get(), m_Level + 1);
741     parser.m_pCurStates->m_CTM = form_matrix;
742     if (ClipPath.NotNull()) {
743       parser.m_pCurStates->m_ClipPath.AppendPath(ClipPath, FXFILL_WINDING,
744                                                  TRUE);
745     }
746     CPDF_StreamAcc stream;
747     stream.LoadAllData(pStream, FALSE);
748     if (stream.GetSize() == 0) {
749       return;
750     }
751     parser.Parse(stream.GetData(), stream.GetSize(), 0);
752     return;
753   }
754   CPDF_FormObject* pFormObj = new CPDF_FormObject;
755   pFormObj->m_pForm =
756       new CPDF_Form(m_pDocument, m_pPageResources, pStream, m_pResources);
757   pFormObj->m_FormMatrix = m_pCurStates->m_CTM;
758   pFormObj->m_FormMatrix.Concat(m_mtContentToUser);
759   CPDF_AllStates status;
760   status.m_GeneralState = m_pCurStates->m_GeneralState;
761   status.m_GraphState = m_pCurStates->m_GraphState;
762   status.m_ColorState = m_pCurStates->m_ColorState;
763   status.m_TextState = m_pCurStates->m_TextState;
764   pFormObj->m_pForm->ParseContent(&status, NULL, NULL, &m_Options, m_Level + 1);
765   if (!m_pObjectList->m_bBackgroundAlphaNeeded &&
766       pFormObj->m_pForm->m_bBackgroundAlphaNeeded) {
767     m_pObjectList->m_bBackgroundAlphaNeeded = TRUE;
768   }
769   pFormObj->CalcBoundingBox();
770   SetGraphicStates(pFormObj, TRUE, TRUE, TRUE);
771   m_pObjectList->m_ObjectList.AddTail(pFormObj);
772 }
773 CPDF_ImageObject* CPDF_StreamContentParser::AddImage(CPDF_Stream* pStream,
774                                                      CPDF_Image* pImage,
775                                                      FX_BOOL bInline) {
776   if (pStream == NULL && pImage == NULL) {
777     return NULL;
778   }
779   CFX_AffineMatrix ImageMatrix;
780   ImageMatrix.Copy(m_pCurStates->m_CTM);
781   ImageMatrix.Concat(m_mtContentToUser);
782   CPDF_ImageObject* pImageObj = new CPDF_ImageObject;
783   if (pImage) {
784     pImageObj->m_pImage =
785         m_pDocument->GetPageData()->GetImage(pImage->GetStream());
786   } else if (pStream->GetObjNum()) {
787     pImageObj->m_pImage = m_pDocument->LoadImageF(pStream);
788   } else {
789     pImageObj->m_pImage = new CPDF_Image(m_pDocument);
790     pImageObj->m_pImage->LoadImageF(pStream, bInline);
791   }
792   SetGraphicStates(pImageObj, pImageObj->m_pImage->IsMask(), FALSE, FALSE);
793   pImageObj->m_Matrix = ImageMatrix;
794   pImageObj->CalcBoundingBox();
795   m_pObjectList->m_ObjectList.AddTail(pImageObj);
796   return pImageObj;
797 }
798 void CPDF_StreamContentParser::Handle_MarkPlace_Dictionary() {}
799 void CPDF_StreamContentParser::Handle_EndImage() {}
800 void CPDF_StreamContentParser::Handle_EndMarkedContent() {
801   if (!m_Options.m_bMarkedContent) {
802     return;
803   }
804   if (m_CurContentMark.IsNull()) {
805     return;
806   }
807   int count = m_CurContentMark.GetObject()->CountItems();
808   if (count == 1) {
809     m_CurContentMark.SetNull();
810     return;
811   }
812   m_CurContentMark.GetModify()->DeleteLastMark();
813 }
814 void CPDF_StreamContentParser::Handle_EndText() {
815   int count = m_ClipTextList.GetSize();
816   if (count == 0) {
817     return;
818   }
819   if (m_pCurStates->m_TextState.GetObject()->m_TextMode < 4) {
820     for (int i = 0; i < count; i++) {
821       CPDF_TextObject* pText = (CPDF_TextObject*)m_ClipTextList.GetAt(i);
822       delete pText;
823     }
824   } else {
825     m_pCurStates->m_ClipPath.AppendTexts(
826         (CPDF_TextObject**)m_ClipTextList.GetData(), count);
827   }
828   m_ClipTextList.RemoveAll();
829 }
830 void CPDF_StreamContentParser::Handle_EndSectionUndefined() {
831   if (m_CompatCount) {
832     m_CompatCount--;
833   }
834 }
835 void CPDF_StreamContentParser::Handle_FillPath() {
836   if (m_Options.m_bTextOnly) {
837     return;
838   }
839   AddPathObject(FXFILL_WINDING, FALSE);
840 }
841 void CPDF_StreamContentParser::Handle_FillPathOld() {
842   if (m_Options.m_bTextOnly) {
843     return;
844   }
845   AddPathObject(FXFILL_WINDING, FALSE);
846 }
847 void CPDF_StreamContentParser::Handle_EOFillPath() {
848   if (m_Options.m_bTextOnly) {
849     return;
850   }
851   AddPathObject(FXFILL_ALTERNATE, FALSE);
852 }
853 void CPDF_StreamContentParser::Handle_SetGray_Fill() {
854   FX_FLOAT value = GetNumber(0);
855   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
856   m_pCurStates->m_ColorState.SetFillColor(pCS, &value, 1);
857 }
858 void CPDF_StreamContentParser::Handle_SetGray_Stroke() {
859   FX_FLOAT value = GetNumber(0);
860   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
861   m_pCurStates->m_ColorState.SetStrokeColor(pCS, &value, 1);
862 }
863 void CPDF_StreamContentParser::Handle_SetExtendGraphState() {
864   CFX_ByteString name = GetString(0);
865   CPDF_Dictionary* pGS =
866       ToDictionary(FindResourceObj(FX_BSTRC("ExtGState"), name));
867   if (!pGS) {
868     m_bResourceMissing = TRUE;
869     return;
870   }
871   m_pCurStates->ProcessExtGS(pGS, this);
872 }
873 void CPDF_StreamContentParser::Handle_ClosePath() {
874   if (m_Options.m_bTextOnly) {
875     return;
876   }
877   if (m_PathPointCount == 0) {
878     return;
879   }
880   if (m_PathStartX != m_PathCurrentX || m_PathStartY != m_PathCurrentY) {
881     AddPathPoint(m_PathStartX, m_PathStartY, FXPT_LINETO | FXPT_CLOSEFIGURE);
882   } else if (m_pPathPoints[m_PathPointCount - 1].m_Flag != FXPT_MOVETO) {
883     m_pPathPoints[m_PathPointCount - 1].m_Flag |= FXPT_CLOSEFIGURE;
884   }
885 }
886 void CPDF_StreamContentParser::Handle_SetFlat() {
887   m_pCurStates->m_GeneralState.GetModify()->m_Flatness = GetNumber(0);
888 }
889 void CPDF_StreamContentParser::Handle_BeginImageData() {}
890 void CPDF_StreamContentParser::Handle_SetLineJoin() {
891   m_pCurStates->m_GraphState.GetModify()->m_LineJoin =
892       (CFX_GraphStateData::LineJoin)GetInteger(0);
893 }
894 void CPDF_StreamContentParser::Handle_SetLineCap() {
895   m_pCurStates->m_GraphState.GetModify()->m_LineCap =
896       (CFX_GraphStateData::LineCap)GetInteger(0);
897 }
898 void CPDF_StreamContentParser::Handle_SetCMYKColor_Fill() {
899   REQUIRE_PARAMS(4);
900   FX_FLOAT values[4];
901   for (int i = 0; i < 4; i++) {
902     values[i] = GetNumber(3 - i);
903   }
904   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
905   m_pCurStates->m_ColorState.SetFillColor(pCS, values, 4);
906 }
907 void CPDF_StreamContentParser::Handle_SetCMYKColor_Stroke() {
908   REQUIRE_PARAMS(4);
909   FX_FLOAT values[4];
910   for (int i = 0; i < 4; i++) {
911     values[i] = GetNumber(3 - i);
912   }
913   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
914   m_pCurStates->m_ColorState.SetStrokeColor(pCS, values, 4);
915 }
916 void CPDF_StreamContentParser::Handle_LineTo() {
917   REQUIRE_PARAMS(2);
918   if (m_Options.m_bTextOnly) {
919     return;
920   }
921   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_LINETO);
922 }
923 void CPDF_StreamContentParser::Handle_MoveTo() {
924   REQUIRE_PARAMS(2);
925   if (m_Options.m_bTextOnly) {
926     m_pSyntax->SkipPathObject();
927     return;
928   }
929   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_MOVETO);
930   ParsePathObject();
931 }
932 void CPDF_StreamContentParser::Handle_SetMiterLimit() {
933   m_pCurStates->m_GraphState.GetModify()->m_MiterLimit = GetNumber(0);
934 }
935 void CPDF_StreamContentParser::Handle_MarkPlace() {}
936 void CPDF_StreamContentParser::Handle_EndPath() {
937   if (m_Options.m_bTextOnly) {
938     return;
939   }
940   AddPathObject(0, FALSE);
941 }
942 void CPDF_StreamContentParser::Handle_SaveGraphState() {
943   CPDF_AllStates* pStates = new CPDF_AllStates;
944   pStates->Copy(*m_pCurStates);
945   m_StateStack.Add(pStates);
946 }
947 void CPDF_StreamContentParser::Handle_RestoreGraphState() {
948   int size = m_StateStack.GetSize();
949   if (size == 0) {
950     return;
951   }
952   CPDF_AllStates* pStates = (CPDF_AllStates*)m_StateStack.GetAt(size - 1);
953   m_pCurStates->Copy(*pStates);
954   delete pStates;
955   m_StateStack.RemoveAt(size - 1);
956 }
957 void CPDF_StreamContentParser::Handle_Rectangle() {
958   if (m_Options.m_bTextOnly) {
959     return;
960   }
961   FX_FLOAT x = GetNumber(3), y = GetNumber(2);
962   FX_FLOAT w = GetNumber(1), h = GetNumber(0);
963   AddPathRect(x, y, w, h);
964 }
965 void CPDF_StreamContentParser::AddPathRect(FX_FLOAT x,
966                                            FX_FLOAT y,
967                                            FX_FLOAT w,
968                                            FX_FLOAT h) {
969   AddPathPoint(x, y, FXPT_MOVETO);
970   AddPathPoint(x + w, y, FXPT_LINETO);
971   AddPathPoint(x + w, y + h, FXPT_LINETO);
972   AddPathPoint(x, y + h, FXPT_LINETO);
973   AddPathPoint(x, y, FXPT_LINETO | FXPT_CLOSEFIGURE);
974 }
975 void CPDF_StreamContentParser::Handle_SetRGBColor_Fill() {
976   REQUIRE_PARAMS(3);
977   FX_FLOAT values[3];
978   for (int i = 0; i < 3; i++) {
979     values[i] = GetNumber(2 - i);
980   }
981   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
982   m_pCurStates->m_ColorState.SetFillColor(pCS, values, 3);
983 }
984 void CPDF_StreamContentParser::Handle_SetRGBColor_Stroke() {
985   REQUIRE_PARAMS(3);
986   FX_FLOAT values[3];
987   for (int i = 0; i < 3; i++) {
988     values[i] = GetNumber(2 - i);
989   }
990   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
991   m_pCurStates->m_ColorState.SetStrokeColor(pCS, values, 3);
992 }
993 void CPDF_StreamContentParser::Handle_SetRenderIntent() {}
994 void CPDF_StreamContentParser::Handle_CloseStrokePath() {
995   if (m_Options.m_bTextOnly) {
996     return;
997   }
998   Handle_ClosePath();
999   AddPathObject(0, TRUE);
1000 }
1001 void CPDF_StreamContentParser::Handle_StrokePath() {
1002   if (m_Options.m_bTextOnly) {
1003     return;
1004   }
1005   AddPathObject(0, TRUE);
1006 }
1007 void CPDF_StreamContentParser::Handle_SetColor_Fill() {
1008   if (m_Options.m_bTextOnly) {
1009     return;
1010   }
1011   FX_FLOAT values[4];
1012   int nargs = m_ParamCount;
1013   if (nargs > 4) {
1014     nargs = 4;
1015   }
1016   for (int i = 0; i < nargs; i++) {
1017     values[i] = GetNumber(nargs - i - 1);
1018   }
1019   m_pCurStates->m_ColorState.SetFillColor(NULL, values, nargs);
1020 }
1021 void CPDF_StreamContentParser::Handle_SetColor_Stroke() {
1022   if (m_Options.m_bTextOnly) {
1023     return;
1024   }
1025   FX_FLOAT values[4];
1026   int nargs = m_ParamCount;
1027   if (nargs > 4) {
1028     nargs = 4;
1029   }
1030   for (int i = 0; i < nargs; i++) {
1031     values[i] = GetNumber(nargs - i - 1);
1032   }
1033   m_pCurStates->m_ColorState.SetStrokeColor(NULL, values, nargs);
1034 }
1035 void CPDF_StreamContentParser::Handle_SetColorPS_Fill() {
1036   if (m_Options.m_bTextOnly) {
1037     return;
1038   }
1039   CPDF_Object* pLastParam = GetObject(0);
1040   if (pLastParam == NULL) {
1041     return;
1042   }
1043   int nargs = m_ParamCount;
1044   int nvalues = nargs;
1045   if (pLastParam->IsName()) {
1046     nvalues--;
1047   }
1048   FX_FLOAT* values = NULL;
1049   if (nvalues) {
1050     values = FX_Alloc(FX_FLOAT, nvalues);
1051     for (int i = 0; i < nvalues; i++) {
1052       values[i] = GetNumber(nargs - i - 1);
1053     }
1054   }
1055   if (nvalues != nargs) {
1056     CPDF_Pattern* pPattern = FindPattern(GetString(0), FALSE);
1057     if (pPattern) {
1058       m_pCurStates->m_ColorState.SetFillPattern(pPattern, values, nvalues);
1059     }
1060   } else {
1061     m_pCurStates->m_ColorState.SetFillColor(NULL, values, nvalues);
1062   }
1063   FX_Free(values);
1064 }
1065 void CPDF_StreamContentParser::Handle_SetColorPS_Stroke() {
1066   if (m_Options.m_bTextOnly) {
1067     return;
1068   }
1069   CPDF_Object* pLastParam = GetObject(0);
1070   if (pLastParam == NULL) {
1071     return;
1072   }
1073   int nargs = m_ParamCount;
1074   int nvalues = nargs;
1075   if (pLastParam->IsName())
1076     nvalues--;
1077
1078   FX_FLOAT* values = NULL;
1079   if (nvalues) {
1080     values = FX_Alloc(FX_FLOAT, nvalues);
1081     for (int i = 0; i < nvalues; i++) {
1082       values[i] = GetNumber(nargs - i - 1);
1083     }
1084   }
1085   if (nvalues != nargs) {
1086     CPDF_Pattern* pPattern = FindPattern(GetString(0), FALSE);
1087     if (pPattern) {
1088       m_pCurStates->m_ColorState.SetStrokePattern(pPattern, values, nvalues);
1089     }
1090   } else {
1091     m_pCurStates->m_ColorState.SetStrokeColor(NULL, values, nvalues);
1092   }
1093   FX_Free(values);
1094 }
1095 CFX_FloatRect _GetShadingBBox(CPDF_Stream* pStream,
1096                               int type,
1097                               const CFX_AffineMatrix* pMatrix,
1098                               CPDF_Function** pFuncs,
1099                               int nFuncs,
1100                               CPDF_ColorSpace* pCS);
1101 void CPDF_StreamContentParser::Handle_ShadeFill() {
1102   if (m_Options.m_bTextOnly) {
1103     return;
1104   }
1105   CPDF_Pattern* pPattern = FindPattern(GetString(0), TRUE);
1106   if (pPattern == NULL) {
1107     return;
1108   }
1109   if (pPattern->m_PatternType != PATTERN_SHADING) {
1110     return;
1111   }
1112   CPDF_ShadingPattern* pShading = (CPDF_ShadingPattern*)pPattern;
1113   if (!pShading->m_bShadingObj) {
1114     return;
1115   }
1116   if (!pShading->Load()) {
1117     return;
1118   }
1119   CPDF_ShadingObject* pObj = new CPDF_ShadingObject;
1120   pObj->m_pShading = pShading;
1121   SetGraphicStates(pObj, FALSE, FALSE, FALSE);
1122   pObj->m_Matrix = m_pCurStates->m_CTM;
1123   pObj->m_Matrix.Concat(m_mtContentToUser);
1124   CFX_FloatRect bbox;
1125   if (!pObj->m_ClipPath.IsNull()) {
1126     bbox = pObj->m_ClipPath.GetClipBox();
1127   } else {
1128     bbox = m_BBox;
1129   }
1130   if (pShading->m_ShadingType >= 4) {
1131     bbox.Intersect(_GetShadingBBox(ToStream(pShading->m_pShadingObj),
1132                                    pShading->m_ShadingType, &pObj->m_Matrix,
1133                                    pShading->m_pFunctions, pShading->m_nFuncs,
1134                                    pShading->m_pCS));
1135   }
1136   pObj->m_Left = bbox.left;
1137   pObj->m_Right = bbox.right;
1138   pObj->m_Top = bbox.top;
1139   pObj->m_Bottom = bbox.bottom;
1140   m_pObjectList->m_ObjectList.AddTail(pObj);
1141 }
1142 void CPDF_StreamContentParser::Handle_SetCharSpace() {
1143   m_pCurStates->m_TextState.GetModify()->m_CharSpace = GetNumber(0);
1144 }
1145 void CPDF_StreamContentParser::Handle_MoveTextPoint() {
1146   m_pCurStates->m_TextLineX += GetNumber(1);
1147   m_pCurStates->m_TextLineY += GetNumber(0);
1148   m_pCurStates->m_TextX = m_pCurStates->m_TextLineX;
1149   m_pCurStates->m_TextY = m_pCurStates->m_TextLineY;
1150 }
1151 void CPDF_StreamContentParser::Handle_MoveTextPoint_SetLeading() {
1152   Handle_MoveTextPoint();
1153   m_pCurStates->m_TextLeading = -GetNumber(0);
1154 }
1155 void CPDF_StreamContentParser::Handle_SetFont() {
1156   FX_FLOAT fs = GetNumber(0);
1157   if (fs == 0) {
1158     fs = m_DefFontSize;
1159   }
1160   m_pCurStates->m_TextState.GetModify()->m_FontSize = fs;
1161   CPDF_Font* pFont = FindFont(GetString(1));
1162   if (pFont) {
1163     m_pCurStates->m_TextState.SetFont(pFont);
1164   }
1165 }
1166 CPDF_Object* CPDF_StreamContentParser::FindResourceObj(
1167     const CFX_ByteStringC& type,
1168     const CFX_ByteString& name) {
1169   if (m_pResources == NULL) {
1170     return NULL;
1171   }
1172   if (m_pResources == m_pPageResources) {
1173     CPDF_Dictionary* pList = m_pResources->GetDict(type);
1174     if (pList == NULL) {
1175       return NULL;
1176     }
1177     CPDF_Object* pRes = pList->GetElementValue(name);
1178     return pRes;
1179   }
1180   CPDF_Dictionary* pList = m_pResources->GetDict(type);
1181   if (pList == NULL) {
1182     if (m_pPageResources == NULL) {
1183       return NULL;
1184     }
1185     CPDF_Dictionary* pList = m_pPageResources->GetDict(type);
1186     if (pList == NULL) {
1187       return NULL;
1188     }
1189     CPDF_Object* pRes = pList->GetElementValue(name);
1190     return pRes;
1191   }
1192   CPDF_Object* pRes = pList->GetElementValue(name);
1193   return pRes;
1194 }
1195 CPDF_Font* CPDF_StreamContentParser::FindFont(const CFX_ByteString& name) {
1196   CPDF_Dictionary* pFontDict =
1197       ToDictionary(FindResourceObj(FX_BSTRC("Font"), name));
1198   if (!pFontDict) {
1199     m_bResourceMissing = TRUE;
1200     return CPDF_Font::GetStockFont(m_pDocument, FX_BSTRC("Helvetica"));
1201   }
1202
1203   CPDF_Font* pFont = m_pDocument->LoadFont(pFontDict);
1204   if (pFont && pFont->GetType3Font()) {
1205     pFont->GetType3Font()->SetPageResources(m_pResources);
1206     pFont->GetType3Font()->CheckType3FontMetrics();
1207   }
1208   return pFont;
1209 }
1210 CPDF_ColorSpace* CPDF_StreamContentParser::FindColorSpace(
1211     const CFX_ByteString& name) {
1212   if (name == FX_BSTRC("Pattern")) {
1213     return CPDF_ColorSpace::GetStockCS(PDFCS_PATTERN);
1214   }
1215   if (name == FX_BSTRC("DeviceGray") || name == FX_BSTRC("DeviceCMYK") ||
1216       name == FX_BSTRC("DeviceRGB")) {
1217     CFX_ByteString defname = "Default";
1218     defname += name.Mid(7);
1219     CPDF_Object* pDefObj = FindResourceObj(FX_BSTRC("ColorSpace"), defname);
1220     if (pDefObj == NULL) {
1221       if (name == FX_BSTRC("DeviceGray")) {
1222         return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
1223       }
1224       if (name == FX_BSTRC("DeviceRGB")) {
1225         return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
1226       }
1227       return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
1228     }
1229     return m_pDocument->LoadColorSpace(pDefObj);
1230   }
1231   CPDF_Object* pCSObj = FindResourceObj(FX_BSTRC("ColorSpace"), name);
1232   if (pCSObj == NULL) {
1233     m_bResourceMissing = TRUE;
1234     return NULL;
1235   }
1236   return m_pDocument->LoadColorSpace(pCSObj);
1237 }
1238 CPDF_Pattern* CPDF_StreamContentParser::FindPattern(const CFX_ByteString& name,
1239                                                     FX_BOOL bShading) {
1240   CPDF_Object* pPattern = FindResourceObj(
1241       bShading ? FX_BSTRC("Shading") : FX_BSTRC("Pattern"), name);
1242   if (!pPattern || (!pPattern->IsDictionary() && !pPattern->IsStream())) {
1243     m_bResourceMissing = TRUE;
1244     return NULL;
1245   }
1246   return m_pDocument->LoadPattern(pPattern, bShading,
1247                                   &m_pCurStates->m_ParentMatrix);
1248 }
1249 void CPDF_StreamContentParser::ConvertTextSpace(FX_FLOAT& x, FX_FLOAT& y) {
1250   m_pCurStates->m_TextMatrix.Transform(x, y, x, y);
1251   ConvertUserSpace(x, y);
1252 }
1253 void CPDF_StreamContentParser::ConvertUserSpace(FX_FLOAT& x, FX_FLOAT& y) {
1254   m_pCurStates->m_CTM.Transform(x, y, x, y);
1255   m_mtContentToUser.Transform(x, y, x, y);
1256 }
1257 void CPDF_StreamContentParser::AddTextObject(CFX_ByteString* pStrs,
1258                                              FX_FLOAT fInitKerning,
1259                                              FX_FLOAT* pKerning,
1260                                              int nsegs) {
1261   CPDF_Font* pFont = m_pCurStates->m_TextState.GetFont();
1262   if (pFont == NULL) {
1263     return;
1264   }
1265   if (fInitKerning != 0) {
1266     if (!pFont->IsVertWriting()) {
1267       m_pCurStates->m_TextX -=
1268           FXSYS_Mul(fInitKerning, m_pCurStates->m_TextState.GetFontSize()) /
1269           1000;
1270     } else {
1271       m_pCurStates->m_TextY -=
1272           FXSYS_Mul(fInitKerning, m_pCurStates->m_TextState.GetFontSize()) /
1273           1000;
1274     }
1275   }
1276   if (nsegs == 0) {
1277     return;
1278   }
1279   int textmode;
1280   if (pFont->GetFontType() == PDFFONT_TYPE3) {
1281     textmode = 0;
1282   } else {
1283     textmode = m_pCurStates->m_TextState.GetObject()->m_TextMode;
1284   }
1285   CPDF_TextObject* pText = new CPDF_TextObject;
1286   m_pLastTextObject = pText;
1287   SetGraphicStates(pText, TRUE, TRUE, TRUE);
1288   if (textmode && textmode != 3 && textmode != 4 && textmode != 7) {
1289     FX_FLOAT* pCTM = pText->m_TextState.GetModify()->m_CTM;
1290     pCTM[0] = m_pCurStates->m_CTM.a;
1291     pCTM[1] = m_pCurStates->m_CTM.c;
1292     pCTM[2] = m_pCurStates->m_CTM.b;
1293     pCTM[3] = m_pCurStates->m_CTM.d;
1294   }
1295   pText->SetSegments(pStrs, pKerning, nsegs);
1296   pText->m_PosX = m_pCurStates->m_TextX;
1297   pText->m_PosY = m_pCurStates->m_TextY + m_pCurStates->m_TextRise;
1298   ConvertTextSpace(pText->m_PosX, pText->m_PosY);
1299   FX_FLOAT x_advance, y_advance;
1300   pText->CalcPositionData(&x_advance, &y_advance, m_pCurStates->m_TextHorzScale,
1301                           m_Level);
1302   m_pCurStates->m_TextX += x_advance;
1303   m_pCurStates->m_TextY += y_advance;
1304   if (textmode > 3) {
1305     CPDF_TextObject* pCopy = new CPDF_TextObject;
1306     pCopy->Copy(pText);
1307     m_ClipTextList.Add(pCopy);
1308   }
1309   m_pObjectList->m_ObjectList.AddTail(pText);
1310   if (pKerning && pKerning[nsegs - 1] != 0) {
1311     if (!pFont->IsVertWriting()) {
1312       m_pCurStates->m_TextX -=
1313           FXSYS_Mul(pKerning[nsegs - 1],
1314                     m_pCurStates->m_TextState.GetFontSize()) /
1315           1000;
1316     } else {
1317       m_pCurStates->m_TextY -=
1318           FXSYS_Mul(pKerning[nsegs - 1],
1319                     m_pCurStates->m_TextState.GetFontSize()) /
1320           1000;
1321     }
1322   }
1323 }
1324 void CPDF_StreamContentParser::Handle_ShowText() {
1325   CFX_ByteString str = GetString(0);
1326   if (str.IsEmpty()) {
1327     return;
1328   }
1329   AddTextObject(&str, 0, NULL, 1);
1330 }
1331 void CPDF_StreamContentParser::Handle_ShowText_Positioning() {
1332   CPDF_Array* pArray = GetObject(0) ? GetObject(0)->GetArray() : NULL;
1333   if (pArray == NULL) {
1334     return;
1335   }
1336   int n = pArray->GetCount();
1337   int nsegs = 0;
1338   for (int i = 0; i < n; i++) {
1339     if (pArray->GetElementValue(i)->IsString())
1340       nsegs++;
1341   }
1342   if (nsegs == 0) {
1343     for (int i = 0; i < n; i++) {
1344       m_pCurStates->m_TextX -=
1345           FXSYS_Mul(pArray->GetNumber(i),
1346                     m_pCurStates->m_TextState.GetFontSize()) /
1347           1000;
1348     };
1349     return;
1350   }
1351   CFX_ByteString* pStrs = new CFX_ByteString[nsegs];
1352   FX_FLOAT* pKerning = FX_Alloc(FX_FLOAT, nsegs);
1353   int iSegment = 0;
1354   FX_FLOAT fInitKerning = 0;
1355   for (int i = 0; i < n; i++) {
1356     CPDF_Object* pObj = pArray->GetElementValue(i);
1357     if (pObj->IsString()) {
1358       CFX_ByteString str = pObj->GetString();
1359       if (str.IsEmpty()) {
1360         continue;
1361       }
1362       pStrs[iSegment] = str;
1363       pKerning[iSegment++] = 0;
1364     } else {
1365       FX_FLOAT num = pObj ? pObj->GetNumber() : 0;
1366       if (iSegment == 0) {
1367         fInitKerning += num;
1368       } else {
1369         pKerning[iSegment - 1] += num;
1370       }
1371     }
1372   }
1373   AddTextObject(pStrs, fInitKerning, pKerning, iSegment);
1374   delete[] pStrs;
1375   FX_Free(pKerning);
1376 }
1377 void CPDF_StreamContentParser::Handle_SetTextLeading() {
1378   m_pCurStates->m_TextLeading = GetNumber(0);
1379 }
1380 void CPDF_StreamContentParser::Handle_SetTextMatrix() {
1381   m_pCurStates->m_TextMatrix.Set(GetNumber16(5), GetNumber16(4), GetNumber16(3),
1382                                  GetNumber16(2), GetNumber(1), GetNumber(0));
1383   OnChangeTextMatrix();
1384   m_pCurStates->m_TextX = 0;
1385   m_pCurStates->m_TextY = 0;
1386   m_pCurStates->m_TextLineX = 0;
1387   m_pCurStates->m_TextLineY = 0;
1388 }
1389 void CPDF_StreamContentParser::OnChangeTextMatrix() {
1390   CFX_AffineMatrix text_matrix(m_pCurStates->m_TextHorzScale, 0.0f, 0.0f, 1.0f,
1391                                0.0f, 0.0f);
1392   text_matrix.Concat(m_pCurStates->m_TextMatrix);
1393   text_matrix.Concat(m_pCurStates->m_CTM);
1394   text_matrix.Concat(m_mtContentToUser);
1395   FX_FLOAT* pTextMatrix = m_pCurStates->m_TextState.GetModify()->m_Matrix;
1396   pTextMatrix[0] = text_matrix.a;
1397   pTextMatrix[1] = text_matrix.c;
1398   pTextMatrix[2] = text_matrix.b;
1399   pTextMatrix[3] = text_matrix.d;
1400 }
1401 void CPDF_StreamContentParser::Handle_SetTextRenderMode() {
1402   int mode = GetInteger(0);
1403   if (mode < 0 || mode > 7) {
1404     return;
1405   }
1406   m_pCurStates->m_TextState.GetModify()->m_TextMode = mode;
1407 }
1408 void CPDF_StreamContentParser::Handle_SetTextRise() {
1409   m_pCurStates->m_TextRise = GetNumber(0);
1410 }
1411 void CPDF_StreamContentParser::Handle_SetWordSpace() {
1412   m_pCurStates->m_TextState.GetModify()->m_WordSpace = GetNumber(0);
1413 }
1414 void CPDF_StreamContentParser::Handle_SetHorzScale() {
1415   if (m_ParamCount != 1) {
1416     return;
1417   }
1418   m_pCurStates->m_TextHorzScale = GetNumber(0) / 100;
1419   OnChangeTextMatrix();
1420 }
1421 void CPDF_StreamContentParser::Handle_MoveToNextLine() {
1422   m_pCurStates->m_TextLineY -= m_pCurStates->m_TextLeading;
1423   m_pCurStates->m_TextX = m_pCurStates->m_TextLineX;
1424   m_pCurStates->m_TextY = m_pCurStates->m_TextLineY;
1425 }
1426 void CPDF_StreamContentParser::Handle_CurveTo_23() {
1427   if (m_Options.m_bTextOnly) {
1428     return;
1429   }
1430   AddPathPoint(m_PathCurrentX, m_PathCurrentY, FXPT_BEZIERTO);
1431   AddPathPoint(GetNumber(3), GetNumber(2), FXPT_BEZIERTO);
1432   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
1433 }
1434 void CPDF_StreamContentParser::Handle_SetLineWidth() {
1435   FX_FLOAT width = GetNumber(0);
1436   m_pCurStates->m_GraphState.GetModify()->m_LineWidth = width;
1437 }
1438 void CPDF_StreamContentParser::Handle_Clip() {
1439   m_PathClipType = FXFILL_WINDING;
1440 }
1441 void CPDF_StreamContentParser::Handle_EOClip() {
1442   m_PathClipType = FXFILL_ALTERNATE;
1443 }
1444 void CPDF_StreamContentParser::Handle_CurveTo_13() {
1445   if (m_Options.m_bTextOnly) {
1446     return;
1447   }
1448   AddPathPoint(GetNumber(3), GetNumber(2), FXPT_BEZIERTO);
1449   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
1450   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
1451 }
1452 void CPDF_StreamContentParser::Handle_NextLineShowText() {
1453   Handle_MoveToNextLine();
1454   Handle_ShowText();
1455 }
1456 void CPDF_StreamContentParser::Handle_NextLineShowText_Space() {
1457   m_pCurStates->m_TextState.GetModify()->m_WordSpace = GetNumber(2);
1458   m_pCurStates->m_TextState.GetModify()->m_CharSpace = GetNumber(1);
1459   Handle_NextLineShowText();
1460 }
1461 void CPDF_StreamContentParser::Handle_Invalid() {}
1462 void CPDF_StreamContentParser::AddPathPoint(FX_FLOAT x, FX_FLOAT y, int flag) {
1463   m_PathCurrentX = x;
1464   m_PathCurrentY = y;
1465   if (flag == FXPT_MOVETO) {
1466     m_PathStartX = x;
1467     m_PathStartY = y;
1468     if (m_PathPointCount &&
1469         m_pPathPoints[m_PathPointCount - 1].m_Flag == FXPT_MOVETO) {
1470       m_pPathPoints[m_PathPointCount - 1].m_PointX = x;
1471       m_pPathPoints[m_PathPointCount - 1].m_PointY = y;
1472       return;
1473     }
1474   } else if (m_PathPointCount == 0) {
1475     return;
1476   }
1477   m_PathPointCount++;
1478   if (m_PathPointCount > m_PathAllocSize) {
1479     int newsize = m_PathPointCount + 256;
1480     FX_PATHPOINT* pNewPoints = FX_Alloc(FX_PATHPOINT, newsize);
1481     if (m_PathAllocSize) {
1482       FXSYS_memcpy(pNewPoints, m_pPathPoints,
1483                    m_PathAllocSize * sizeof(FX_PATHPOINT));
1484       FX_Free(m_pPathPoints);
1485     }
1486     m_pPathPoints = pNewPoints;
1487     m_PathAllocSize = newsize;
1488   }
1489   m_pPathPoints[m_PathPointCount - 1].m_Flag = flag;
1490   m_pPathPoints[m_PathPointCount - 1].m_PointX = x;
1491   m_pPathPoints[m_PathPointCount - 1].m_PointY = y;
1492 }
1493 void CPDF_StreamContentParser::AddPathObject(int FillType, FX_BOOL bStroke) {
1494   int PathPointCount = m_PathPointCount, PathClipType = m_PathClipType;
1495   m_PathPointCount = 0;
1496   m_PathClipType = 0;
1497   if (PathPointCount <= 1) {
1498     if (PathPointCount && PathClipType) {
1499       CPDF_Path path;
1500       path.New()->AppendRect(0, 0, 0, 0);
1501       m_pCurStates->m_ClipPath.AppendPath(path, FXFILL_WINDING, TRUE);
1502     }
1503     return;
1504   }
1505   if (PathPointCount &&
1506       m_pPathPoints[PathPointCount - 1].m_Flag == FXPT_MOVETO) {
1507     PathPointCount--;
1508   }
1509   CPDF_Path Path;
1510   CFX_PathData* pPathData = Path.New();
1511   pPathData->SetPointCount(PathPointCount);
1512   FXSYS_memcpy(pPathData->GetPoints(), m_pPathPoints,
1513                sizeof(FX_PATHPOINT) * PathPointCount);
1514   CFX_AffineMatrix matrix = m_pCurStates->m_CTM;
1515   matrix.Concat(m_mtContentToUser);
1516   if (bStroke || FillType) {
1517     CPDF_PathObject* pPathObj = new CPDF_PathObject;
1518     pPathObj->m_bStroke = bStroke;
1519     pPathObj->m_FillType = FillType;
1520     pPathObj->m_Path = Path;
1521     pPathObj->m_Matrix = matrix;
1522     SetGraphicStates(pPathObj, TRUE, FALSE, TRUE);
1523     pPathObj->CalcBoundingBox();
1524     m_pObjectList->m_ObjectList.AddTail(pPathObj);
1525   }
1526   if (PathClipType) {
1527     if (!matrix.IsIdentity()) {
1528       Path.Transform(&matrix);
1529       matrix.SetIdentity();
1530     }
1531     m_pCurStates->m_ClipPath.AppendPath(Path, PathClipType, TRUE);
1532   }
1533 }
1534 CFX_ByteString _FPDF_ByteStringFromHex(CFX_BinaryBuf& src_buf) {
1535   CFX_ByteTextBuf buf;
1536   FX_BOOL bFirst = TRUE;
1537   int code = 0;
1538   const uint8_t* str = src_buf.GetBuffer();
1539   FX_DWORD size = src_buf.GetSize();
1540   for (FX_DWORD i = 0; i < size; i++) {
1541     uint8_t ch = str[i];
1542     if (ch >= '0' && ch <= '9') {
1543       if (bFirst) {
1544         code = (ch - '0') * 16;
1545       } else {
1546         code += ch - '0';
1547         buf.AppendChar((char)code);
1548       }
1549       bFirst = !bFirst;
1550     } else if (ch >= 'A' && ch <= 'F') {
1551       if (bFirst) {
1552         code = (ch - 'A' + 10) * 16;
1553       } else {
1554         code += ch - 'A' + 10;
1555         buf.AppendChar((char)code);
1556       }
1557       bFirst = !bFirst;
1558     } else if (ch >= 'a' && ch <= 'f') {
1559       if (bFirst) {
1560         code = (ch - 'a' + 10) * 16;
1561       } else {
1562         code += ch - 'a' + 10;
1563         buf.AppendChar((char)code);
1564       }
1565       bFirst = !bFirst;
1566     }
1567   }
1568   if (!bFirst) {
1569     buf.AppendChar((char)code);
1570   }
1571   return buf.GetByteString();
1572 }