Clean up CPDF_AnnotList.
[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                              ShadingType type,
1097                              const CFX_AffineMatrix* pMatrix,
1098                              CPDF_Function** pFuncs,
1099                              int nFuncs,
1100                              CPDF_ColorSpace* pCS);
1101
1102 void CPDF_StreamContentParser::Handle_ShadeFill() {
1103   if (m_Options.m_bTextOnly) {
1104     return;
1105   }
1106   CPDF_Pattern* pPattern = FindPattern(GetString(0), TRUE);
1107   if (pPattern == NULL) {
1108     return;
1109   }
1110   if (pPattern->m_PatternType != PATTERN_SHADING) {
1111     return;
1112   }
1113   CPDF_ShadingPattern* pShading = (CPDF_ShadingPattern*)pPattern;
1114   if (!pShading->m_bShadingObj) {
1115     return;
1116   }
1117   if (!pShading->Load()) {
1118     return;
1119   }
1120   CPDF_ShadingObject* pObj = new CPDF_ShadingObject;
1121   pObj->m_pShading = pShading;
1122   SetGraphicStates(pObj, FALSE, FALSE, FALSE);
1123   pObj->m_Matrix = m_pCurStates->m_CTM;
1124   pObj->m_Matrix.Concat(m_mtContentToUser);
1125   CFX_FloatRect bbox;
1126   if (!pObj->m_ClipPath.IsNull()) {
1127     bbox = pObj->m_ClipPath.GetClipBox();
1128   } else {
1129     bbox = m_BBox;
1130   }
1131   if (pShading->IsMeshShading()) {
1132     bbox.Intersect(GetShadingBBox(ToStream(pShading->m_pShadingObj),
1133                                   pShading->m_ShadingType, &pObj->m_Matrix,
1134                                   pShading->m_pFunctions, pShading->m_nFuncs,
1135                                   pShading->m_pCS));
1136   }
1137   pObj->m_Left = bbox.left;
1138   pObj->m_Right = bbox.right;
1139   pObj->m_Top = bbox.top;
1140   pObj->m_Bottom = bbox.bottom;
1141   m_pObjectList->m_ObjectList.AddTail(pObj);
1142 }
1143 void CPDF_StreamContentParser::Handle_SetCharSpace() {
1144   m_pCurStates->m_TextState.GetModify()->m_CharSpace = GetNumber(0);
1145 }
1146 void CPDF_StreamContentParser::Handle_MoveTextPoint() {
1147   m_pCurStates->m_TextLineX += GetNumber(1);
1148   m_pCurStates->m_TextLineY += GetNumber(0);
1149   m_pCurStates->m_TextX = m_pCurStates->m_TextLineX;
1150   m_pCurStates->m_TextY = m_pCurStates->m_TextLineY;
1151 }
1152 void CPDF_StreamContentParser::Handle_MoveTextPoint_SetLeading() {
1153   Handle_MoveTextPoint();
1154   m_pCurStates->m_TextLeading = -GetNumber(0);
1155 }
1156 void CPDF_StreamContentParser::Handle_SetFont() {
1157   FX_FLOAT fs = GetNumber(0);
1158   if (fs == 0) {
1159     fs = m_DefFontSize;
1160   }
1161   m_pCurStates->m_TextState.GetModify()->m_FontSize = fs;
1162   CPDF_Font* pFont = FindFont(GetString(1));
1163   if (pFont) {
1164     m_pCurStates->m_TextState.SetFont(pFont);
1165   }
1166 }
1167 CPDF_Object* CPDF_StreamContentParser::FindResourceObj(
1168     const CFX_ByteStringC& type,
1169     const CFX_ByteString& name) {
1170   if (m_pResources == NULL) {
1171     return NULL;
1172   }
1173   if (m_pResources == m_pPageResources) {
1174     CPDF_Dictionary* pList = m_pResources->GetDict(type);
1175     if (pList == NULL) {
1176       return NULL;
1177     }
1178     CPDF_Object* pRes = pList->GetElementValue(name);
1179     return pRes;
1180   }
1181   CPDF_Dictionary* pList = m_pResources->GetDict(type);
1182   if (pList == NULL) {
1183     if (m_pPageResources == NULL) {
1184       return NULL;
1185     }
1186     CPDF_Dictionary* pList = m_pPageResources->GetDict(type);
1187     if (pList == NULL) {
1188       return NULL;
1189     }
1190     CPDF_Object* pRes = pList->GetElementValue(name);
1191     return pRes;
1192   }
1193   CPDF_Object* pRes = pList->GetElementValue(name);
1194   return pRes;
1195 }
1196 CPDF_Font* CPDF_StreamContentParser::FindFont(const CFX_ByteString& name) {
1197   CPDF_Dictionary* pFontDict =
1198       ToDictionary(FindResourceObj(FX_BSTRC("Font"), name));
1199   if (!pFontDict) {
1200     m_bResourceMissing = TRUE;
1201     return CPDF_Font::GetStockFont(m_pDocument, FX_BSTRC("Helvetica"));
1202   }
1203
1204   CPDF_Font* pFont = m_pDocument->LoadFont(pFontDict);
1205   if (pFont && pFont->GetType3Font()) {
1206     pFont->GetType3Font()->SetPageResources(m_pResources);
1207     pFont->GetType3Font()->CheckType3FontMetrics();
1208   }
1209   return pFont;
1210 }
1211 CPDF_ColorSpace* CPDF_StreamContentParser::FindColorSpace(
1212     const CFX_ByteString& name) {
1213   if (name == FX_BSTRC("Pattern")) {
1214     return CPDF_ColorSpace::GetStockCS(PDFCS_PATTERN);
1215   }
1216   if (name == FX_BSTRC("DeviceGray") || name == FX_BSTRC("DeviceCMYK") ||
1217       name == FX_BSTRC("DeviceRGB")) {
1218     CFX_ByteString defname = "Default";
1219     defname += name.Mid(7);
1220     CPDF_Object* pDefObj = FindResourceObj(FX_BSTRC("ColorSpace"), defname);
1221     if (pDefObj == NULL) {
1222       if (name == FX_BSTRC("DeviceGray")) {
1223         return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
1224       }
1225       if (name == FX_BSTRC("DeviceRGB")) {
1226         return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
1227       }
1228       return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
1229     }
1230     return m_pDocument->LoadColorSpace(pDefObj);
1231   }
1232   CPDF_Object* pCSObj = FindResourceObj(FX_BSTRC("ColorSpace"), name);
1233   if (pCSObj == NULL) {
1234     m_bResourceMissing = TRUE;
1235     return NULL;
1236   }
1237   return m_pDocument->LoadColorSpace(pCSObj);
1238 }
1239 CPDF_Pattern* CPDF_StreamContentParser::FindPattern(const CFX_ByteString& name,
1240                                                     FX_BOOL bShading) {
1241   CPDF_Object* pPattern = FindResourceObj(
1242       bShading ? FX_BSTRC("Shading") : FX_BSTRC("Pattern"), name);
1243   if (!pPattern || (!pPattern->IsDictionary() && !pPattern->IsStream())) {
1244     m_bResourceMissing = TRUE;
1245     return NULL;
1246   }
1247   return m_pDocument->LoadPattern(pPattern, bShading,
1248                                   &m_pCurStates->m_ParentMatrix);
1249 }
1250 void CPDF_StreamContentParser::ConvertTextSpace(FX_FLOAT& x, FX_FLOAT& y) {
1251   m_pCurStates->m_TextMatrix.Transform(x, y, x, y);
1252   ConvertUserSpace(x, y);
1253 }
1254 void CPDF_StreamContentParser::ConvertUserSpace(FX_FLOAT& x, FX_FLOAT& y) {
1255   m_pCurStates->m_CTM.Transform(x, y, x, y);
1256   m_mtContentToUser.Transform(x, y, x, y);
1257 }
1258 void CPDF_StreamContentParser::AddTextObject(CFX_ByteString* pStrs,
1259                                              FX_FLOAT fInitKerning,
1260                                              FX_FLOAT* pKerning,
1261                                              int nsegs) {
1262   CPDF_Font* pFont = m_pCurStates->m_TextState.GetFont();
1263   if (pFont == NULL) {
1264     return;
1265   }
1266   if (fInitKerning != 0) {
1267     if (!pFont->IsVertWriting()) {
1268       m_pCurStates->m_TextX -=
1269           FXSYS_Mul(fInitKerning, m_pCurStates->m_TextState.GetFontSize()) /
1270           1000;
1271     } else {
1272       m_pCurStates->m_TextY -=
1273           FXSYS_Mul(fInitKerning, m_pCurStates->m_TextState.GetFontSize()) /
1274           1000;
1275     }
1276   }
1277   if (nsegs == 0) {
1278     return;
1279   }
1280   int textmode;
1281   if (pFont->GetFontType() == PDFFONT_TYPE3) {
1282     textmode = 0;
1283   } else {
1284     textmode = m_pCurStates->m_TextState.GetObject()->m_TextMode;
1285   }
1286   CPDF_TextObject* pText = new CPDF_TextObject;
1287   m_pLastTextObject = pText;
1288   SetGraphicStates(pText, TRUE, TRUE, TRUE);
1289   if (textmode && textmode != 3 && textmode != 4 && textmode != 7) {
1290     FX_FLOAT* pCTM = pText->m_TextState.GetModify()->m_CTM;
1291     pCTM[0] = m_pCurStates->m_CTM.a;
1292     pCTM[1] = m_pCurStates->m_CTM.c;
1293     pCTM[2] = m_pCurStates->m_CTM.b;
1294     pCTM[3] = m_pCurStates->m_CTM.d;
1295   }
1296   pText->SetSegments(pStrs, pKerning, nsegs);
1297   pText->m_PosX = m_pCurStates->m_TextX;
1298   pText->m_PosY = m_pCurStates->m_TextY + m_pCurStates->m_TextRise;
1299   ConvertTextSpace(pText->m_PosX, pText->m_PosY);
1300   FX_FLOAT x_advance, y_advance;
1301   pText->CalcPositionData(&x_advance, &y_advance, m_pCurStates->m_TextHorzScale,
1302                           m_Level);
1303   m_pCurStates->m_TextX += x_advance;
1304   m_pCurStates->m_TextY += y_advance;
1305   if (textmode > 3) {
1306     CPDF_TextObject* pCopy = new CPDF_TextObject;
1307     pCopy->Copy(pText);
1308     m_ClipTextList.Add(pCopy);
1309   }
1310   m_pObjectList->m_ObjectList.AddTail(pText);
1311   if (pKerning && pKerning[nsegs - 1] != 0) {
1312     if (!pFont->IsVertWriting()) {
1313       m_pCurStates->m_TextX -=
1314           FXSYS_Mul(pKerning[nsegs - 1],
1315                     m_pCurStates->m_TextState.GetFontSize()) /
1316           1000;
1317     } else {
1318       m_pCurStates->m_TextY -=
1319           FXSYS_Mul(pKerning[nsegs - 1],
1320                     m_pCurStates->m_TextState.GetFontSize()) /
1321           1000;
1322     }
1323   }
1324 }
1325 void CPDF_StreamContentParser::Handle_ShowText() {
1326   CFX_ByteString str = GetString(0);
1327   if (str.IsEmpty()) {
1328     return;
1329   }
1330   AddTextObject(&str, 0, NULL, 1);
1331 }
1332 void CPDF_StreamContentParser::Handle_ShowText_Positioning() {
1333   CPDF_Array* pArray = GetObject(0) ? GetObject(0)->GetArray() : NULL;
1334   if (pArray == NULL) {
1335     return;
1336   }
1337   int n = pArray->GetCount();
1338   int nsegs = 0;
1339   for (int i = 0; i < n; i++) {
1340     if (pArray->GetElementValue(i)->IsString())
1341       nsegs++;
1342   }
1343   if (nsegs == 0) {
1344     for (int i = 0; i < n; i++) {
1345       m_pCurStates->m_TextX -=
1346           FXSYS_Mul(pArray->GetNumber(i),
1347                     m_pCurStates->m_TextState.GetFontSize()) /
1348           1000;
1349     };
1350     return;
1351   }
1352   CFX_ByteString* pStrs = new CFX_ByteString[nsegs];
1353   FX_FLOAT* pKerning = FX_Alloc(FX_FLOAT, nsegs);
1354   int iSegment = 0;
1355   FX_FLOAT fInitKerning = 0;
1356   for (int i = 0; i < n; i++) {
1357     CPDF_Object* pObj = pArray->GetElementValue(i);
1358     if (pObj->IsString()) {
1359       CFX_ByteString str = pObj->GetString();
1360       if (str.IsEmpty()) {
1361         continue;
1362       }
1363       pStrs[iSegment] = str;
1364       pKerning[iSegment++] = 0;
1365     } else {
1366       FX_FLOAT num = pObj ? pObj->GetNumber() : 0;
1367       if (iSegment == 0) {
1368         fInitKerning += num;
1369       } else {
1370         pKerning[iSegment - 1] += num;
1371       }
1372     }
1373   }
1374   AddTextObject(pStrs, fInitKerning, pKerning, iSegment);
1375   delete[] pStrs;
1376   FX_Free(pKerning);
1377 }
1378 void CPDF_StreamContentParser::Handle_SetTextLeading() {
1379   m_pCurStates->m_TextLeading = GetNumber(0);
1380 }
1381 void CPDF_StreamContentParser::Handle_SetTextMatrix() {
1382   m_pCurStates->m_TextMatrix.Set(GetNumber16(5), GetNumber16(4), GetNumber16(3),
1383                                  GetNumber16(2), GetNumber(1), GetNumber(0));
1384   OnChangeTextMatrix();
1385   m_pCurStates->m_TextX = 0;
1386   m_pCurStates->m_TextY = 0;
1387   m_pCurStates->m_TextLineX = 0;
1388   m_pCurStates->m_TextLineY = 0;
1389 }
1390 void CPDF_StreamContentParser::OnChangeTextMatrix() {
1391   CFX_AffineMatrix text_matrix(m_pCurStates->m_TextHorzScale, 0.0f, 0.0f, 1.0f,
1392                                0.0f, 0.0f);
1393   text_matrix.Concat(m_pCurStates->m_TextMatrix);
1394   text_matrix.Concat(m_pCurStates->m_CTM);
1395   text_matrix.Concat(m_mtContentToUser);
1396   FX_FLOAT* pTextMatrix = m_pCurStates->m_TextState.GetModify()->m_Matrix;
1397   pTextMatrix[0] = text_matrix.a;
1398   pTextMatrix[1] = text_matrix.c;
1399   pTextMatrix[2] = text_matrix.b;
1400   pTextMatrix[3] = text_matrix.d;
1401 }
1402 void CPDF_StreamContentParser::Handle_SetTextRenderMode() {
1403   int mode = GetInteger(0);
1404   if (mode < 0 || mode > 7) {
1405     return;
1406   }
1407   m_pCurStates->m_TextState.GetModify()->m_TextMode = mode;
1408 }
1409 void CPDF_StreamContentParser::Handle_SetTextRise() {
1410   m_pCurStates->m_TextRise = GetNumber(0);
1411 }
1412 void CPDF_StreamContentParser::Handle_SetWordSpace() {
1413   m_pCurStates->m_TextState.GetModify()->m_WordSpace = GetNumber(0);
1414 }
1415 void CPDF_StreamContentParser::Handle_SetHorzScale() {
1416   if (m_ParamCount != 1) {
1417     return;
1418   }
1419   m_pCurStates->m_TextHorzScale = GetNumber(0) / 100;
1420   OnChangeTextMatrix();
1421 }
1422 void CPDF_StreamContentParser::Handle_MoveToNextLine() {
1423   m_pCurStates->m_TextLineY -= m_pCurStates->m_TextLeading;
1424   m_pCurStates->m_TextX = m_pCurStates->m_TextLineX;
1425   m_pCurStates->m_TextY = m_pCurStates->m_TextLineY;
1426 }
1427 void CPDF_StreamContentParser::Handle_CurveTo_23() {
1428   if (m_Options.m_bTextOnly) {
1429     return;
1430   }
1431   AddPathPoint(m_PathCurrentX, m_PathCurrentY, FXPT_BEZIERTO);
1432   AddPathPoint(GetNumber(3), GetNumber(2), FXPT_BEZIERTO);
1433   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
1434 }
1435 void CPDF_StreamContentParser::Handle_SetLineWidth() {
1436   FX_FLOAT width = GetNumber(0);
1437   m_pCurStates->m_GraphState.GetModify()->m_LineWidth = width;
1438 }
1439 void CPDF_StreamContentParser::Handle_Clip() {
1440   m_PathClipType = FXFILL_WINDING;
1441 }
1442 void CPDF_StreamContentParser::Handle_EOClip() {
1443   m_PathClipType = FXFILL_ALTERNATE;
1444 }
1445 void CPDF_StreamContentParser::Handle_CurveTo_13() {
1446   if (m_Options.m_bTextOnly) {
1447     return;
1448   }
1449   AddPathPoint(GetNumber(3), GetNumber(2), FXPT_BEZIERTO);
1450   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
1451   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
1452 }
1453 void CPDF_StreamContentParser::Handle_NextLineShowText() {
1454   Handle_MoveToNextLine();
1455   Handle_ShowText();
1456 }
1457 void CPDF_StreamContentParser::Handle_NextLineShowText_Space() {
1458   m_pCurStates->m_TextState.GetModify()->m_WordSpace = GetNumber(2);
1459   m_pCurStates->m_TextState.GetModify()->m_CharSpace = GetNumber(1);
1460   Handle_NextLineShowText();
1461 }
1462 void CPDF_StreamContentParser::Handle_Invalid() {}
1463 void CPDF_StreamContentParser::AddPathPoint(FX_FLOAT x, FX_FLOAT y, int flag) {
1464   m_PathCurrentX = x;
1465   m_PathCurrentY = y;
1466   if (flag == FXPT_MOVETO) {
1467     m_PathStartX = x;
1468     m_PathStartY = y;
1469     if (m_PathPointCount &&
1470         m_pPathPoints[m_PathPointCount - 1].m_Flag == FXPT_MOVETO) {
1471       m_pPathPoints[m_PathPointCount - 1].m_PointX = x;
1472       m_pPathPoints[m_PathPointCount - 1].m_PointY = y;
1473       return;
1474     }
1475   } else if (m_PathPointCount == 0) {
1476     return;
1477   }
1478   m_PathPointCount++;
1479   if (m_PathPointCount > m_PathAllocSize) {
1480     int newsize = m_PathPointCount + 256;
1481     FX_PATHPOINT* pNewPoints = FX_Alloc(FX_PATHPOINT, newsize);
1482     if (m_PathAllocSize) {
1483       FXSYS_memcpy(pNewPoints, m_pPathPoints,
1484                    m_PathAllocSize * sizeof(FX_PATHPOINT));
1485       FX_Free(m_pPathPoints);
1486     }
1487     m_pPathPoints = pNewPoints;
1488     m_PathAllocSize = newsize;
1489   }
1490   m_pPathPoints[m_PathPointCount - 1].m_Flag = flag;
1491   m_pPathPoints[m_PathPointCount - 1].m_PointX = x;
1492   m_pPathPoints[m_PathPointCount - 1].m_PointY = y;
1493 }
1494 void CPDF_StreamContentParser::AddPathObject(int FillType, FX_BOOL bStroke) {
1495   int PathPointCount = m_PathPointCount, PathClipType = m_PathClipType;
1496   m_PathPointCount = 0;
1497   m_PathClipType = 0;
1498   if (PathPointCount <= 1) {
1499     if (PathPointCount && PathClipType) {
1500       CPDF_Path path;
1501       path.New()->AppendRect(0, 0, 0, 0);
1502       m_pCurStates->m_ClipPath.AppendPath(path, FXFILL_WINDING, TRUE);
1503     }
1504     return;
1505   }
1506   if (PathPointCount &&
1507       m_pPathPoints[PathPointCount - 1].m_Flag == FXPT_MOVETO) {
1508     PathPointCount--;
1509   }
1510   CPDF_Path Path;
1511   CFX_PathData* pPathData = Path.New();
1512   pPathData->SetPointCount(PathPointCount);
1513   FXSYS_memcpy(pPathData->GetPoints(), m_pPathPoints,
1514                sizeof(FX_PATHPOINT) * PathPointCount);
1515   CFX_AffineMatrix matrix = m_pCurStates->m_CTM;
1516   matrix.Concat(m_mtContentToUser);
1517   if (bStroke || FillType) {
1518     CPDF_PathObject* pPathObj = new CPDF_PathObject;
1519     pPathObj->m_bStroke = bStroke;
1520     pPathObj->m_FillType = FillType;
1521     pPathObj->m_Path = Path;
1522     pPathObj->m_Matrix = matrix;
1523     SetGraphicStates(pPathObj, TRUE, FALSE, TRUE);
1524     pPathObj->CalcBoundingBox();
1525     m_pObjectList->m_ObjectList.AddTail(pPathObj);
1526   }
1527   if (PathClipType) {
1528     if (!matrix.IsIdentity()) {
1529       Path.Transform(&matrix);
1530       matrix.SetIdentity();
1531     }
1532     m_pCurStates->m_ClipPath.AppendPath(Path, PathClipType, TRUE);
1533   }
1534 }
1535 CFX_ByteString _FPDF_ByteStringFromHex(CFX_BinaryBuf& src_buf) {
1536   CFX_ByteTextBuf buf;
1537   FX_BOOL bFirst = TRUE;
1538   int code = 0;
1539   const uint8_t* str = src_buf.GetBuffer();
1540   FX_DWORD size = src_buf.GetSize();
1541   for (FX_DWORD i = 0; i < size; i++) {
1542     uint8_t ch = str[i];
1543     if (ch >= '0' && ch <= '9') {
1544       if (bFirst) {
1545         code = (ch - '0') * 16;
1546       } else {
1547         code += ch - '0';
1548         buf.AppendChar((char)code);
1549       }
1550       bFirst = !bFirst;
1551     } else if (ch >= 'A' && ch <= 'F') {
1552       if (bFirst) {
1553         code = (ch - 'A' + 10) * 16;
1554       } else {
1555         code += ch - 'A' + 10;
1556         buf.AppendChar((char)code);
1557       }
1558       bFirst = !bFirst;
1559     } else if (ch >= 'a' && ch <= 'f') {
1560       if (bFirst) {
1561         code = (ch - 'a' + 10) * 16;
1562       } else {
1563         code += ch - 'a' + 10;
1564         buf.AppendChar((char)code);
1565       }
1566       bFirst = !bFirst;
1567     }
1568   }
1569   if (!bFirst) {
1570     buf.AppendChar((char)code);
1571   }
1572   return buf.GetByteString();
1573 }