af22c5649e0d70e7ec3320ba8b7750adc3456ee4
[pdfium.git] / core / src / fpdfapi / fpdf_page / fpdf_page_func.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 "pageint.h"
10 #include <limits.h>
11 class CPDF_PSEngine;
12 typedef enum {PSOP_ADD, PSOP_SUB, PSOP_MUL, PSOP_DIV, PSOP_IDIV, PSOP_MOD,
13               PSOP_NEG, PSOP_ABS, PSOP_CEILING, PSOP_FLOOR, PSOP_ROUND, PSOP_TRUNCATE,
14               PSOP_SQRT, PSOP_SIN, PSOP_COS, PSOP_ATAN, PSOP_EXP, PSOP_LN, PSOP_LOG,
15               PSOP_CVI, PSOP_CVR, PSOP_EQ, PSOP_NE, PSOP_GT, PSOP_GE, PSOP_LT, PSOP_LE,
16               PSOP_AND, PSOP_OR, PSOP_XOR, PSOP_NOT, PSOP_BITSHIFT, PSOP_TRUE, PSOP_FALSE,
17               PSOP_IF, PSOP_IFELSE, PSOP_POP, PSOP_EXCH, PSOP_DUP, PSOP_COPY,
18               PSOP_INDEX, PSOP_ROLL, PSOP_PROC, PSOP_CONST
19              } PDF_PSOP;
20 class CPDF_PSProc : public CFX_Object
21 {
22 public:
23     ~CPDF_PSProc();
24     FX_BOOL     Parse(CPDF_SimpleParser& parser);
25     FX_BOOL     Execute(CPDF_PSEngine* pEngine);
26     CFX_PtrArray                m_Operators;
27 };
28 #define PSENGINE_STACKSIZE 100
29 class CPDF_PSEngine : public CFX_Object
30 {
31 public:
32     CPDF_PSEngine();
33     ~CPDF_PSEngine();
34     FX_BOOL     Parse(const FX_CHAR* string, int size);
35     FX_BOOL     Execute()
36     {
37         return m_MainProc.Execute(this);
38     }
39     FX_BOOL     DoOperator(PDF_PSOP op);
40     void        Reset()
41     {
42         m_StackCount = 0;
43     }
44     void        Push(FX_FLOAT value);
45     void        Push(int value)
46     {
47         Push((FX_FLOAT)value);
48     }
49     FX_FLOAT    Pop();
50     int         GetStackSize()
51     {
52         return m_StackCount;
53     }
54 private:
55     FX_FLOAT    m_Stack[PSENGINE_STACKSIZE];
56     int         m_StackCount;
57     CPDF_PSProc m_MainProc;
58 };
59 CPDF_PSProc::~CPDF_PSProc()
60 {
61     int size = m_Operators.GetSize();
62     for (int i = 0; i < size; i ++) {
63         if (m_Operators[i] == (FX_LPVOID)PSOP_PROC) {
64             delete (CPDF_PSProc*)m_Operators[i + 1];
65             i ++;
66         } else if (m_Operators[i] == (FX_LPVOID)PSOP_CONST) {
67             FX_Free((FX_FLOAT*)m_Operators[i + 1]);
68             i ++;
69         }
70     }
71 }
72 #pragma optimize( "", off )
73 FX_BOOL CPDF_PSProc::Execute(CPDF_PSEngine* pEngine)
74 {
75     int size = m_Operators.GetSize();
76     for (int i = 0; i < size; i ++) {
77         PDF_PSOP op = (PDF_PSOP)(FX_UINTPTR)m_Operators[i];
78         if (op == PSOP_PROC) {
79             i ++;
80         } else if (op == PSOP_CONST) {
81             pEngine->Push(*(FX_FLOAT*)m_Operators[i + 1]);
82             i ++;
83         } else if (op == PSOP_IF) {
84             if (i < 2 || m_Operators[i - 2] != (FX_LPVOID)PSOP_PROC) {
85                 return FALSE;
86             }
87             if ((int)pEngine->Pop()) {
88                 ((CPDF_PSProc*)m_Operators[i - 1])->Execute(pEngine);
89             }
90         } else if (op == PSOP_IFELSE) {
91             if (i < 4 || m_Operators[i - 2] != (FX_LPVOID)PSOP_PROC ||
92                     m_Operators[i - 4] != (FX_LPVOID)PSOP_PROC) {
93                 return FALSE;
94             }
95             if ((int)pEngine->Pop()) {
96                 ((CPDF_PSProc*)m_Operators[i - 3])->Execute(pEngine);
97             } else {
98                 ((CPDF_PSProc*)m_Operators[i - 1])->Execute(pEngine);
99             }
100         } else {
101             pEngine->DoOperator(op);
102         }
103     }
104     return TRUE;
105 }
106 #pragma optimize( "", on )
107 CPDF_PSEngine::CPDF_PSEngine()
108 {
109     m_StackCount = 0;
110 }
111 CPDF_PSEngine::~CPDF_PSEngine()
112 {
113 }
114 void CPDF_PSEngine::Push(FX_FLOAT v)
115 {
116     if (m_StackCount == 100) {
117         return;
118     }
119     m_Stack[m_StackCount++] = v;
120 }
121 FX_FLOAT CPDF_PSEngine::Pop()
122 {
123     if (m_StackCount == 0) {
124         return 0;
125     }
126     return m_Stack[--m_StackCount];
127 }
128 const struct _PDF_PSOpName {
129     const FX_CHAR* name;
130     PDF_PSOP op;
131 } _PDF_PSOpNames[] = {
132     {"add", PSOP_ADD}, {"sub", PSOP_SUB}, {"mul", PSOP_MUL}, {"div", PSOP_DIV},
133     {"idiv", PSOP_IDIV}, {"mod", PSOP_MOD}, {"neg", PSOP_NEG}, {"abs", PSOP_ABS},
134     {"ceiling", PSOP_CEILING}, {"floor", PSOP_FLOOR}, {"round", PSOP_ROUND},
135     {"truncate", PSOP_TRUNCATE}, {"sqrt", PSOP_SQRT}, {"sin", PSOP_SIN},
136     {"cos", PSOP_COS}, {"atan", PSOP_ATAN}, {"exp", PSOP_EXP}, {"ln", PSOP_LN},
137     {"log", PSOP_LOG}, {"cvi", PSOP_CVI}, {"cvr", PSOP_CVR}, {"eq", PSOP_EQ},
138     {"ne", PSOP_NE}, {"gt", PSOP_GT}, {"ge", PSOP_GE}, {"lt", PSOP_LT},
139     {"le", PSOP_LE}, {"and", PSOP_AND}, {"or", PSOP_OR}, {"xor", PSOP_XOR},
140     {"not", PSOP_NOT}, {"bitshift", PSOP_BITSHIFT}, {"true", PSOP_TRUE},
141     {"false", PSOP_FALSE}, {"if", PSOP_IF}, {"ifelse", PSOP_IFELSE},
142     {"pop", PSOP_POP}, {"exch", PSOP_EXCH}, {"dup", PSOP_DUP},
143     {"copy", PSOP_COPY}, {"index", PSOP_INDEX}, {"roll", PSOP_ROLL},
144     {NULL, PSOP_PROC}
145 };
146 FX_BOOL CPDF_PSEngine::Parse(const FX_CHAR* string, int size)
147 {
148     CPDF_SimpleParser parser((FX_LPBYTE)string, size);
149     CFX_ByteStringC word = parser.GetWord();
150     if (word != FX_BSTRC("{")) {
151         return FALSE;
152     }
153     return m_MainProc.Parse(parser);
154 }
155 FX_BOOL CPDF_PSProc::Parse(CPDF_SimpleParser& parser)
156 {
157     while (1) {
158         CFX_ByteStringC word = parser.GetWord();
159         if (word.IsEmpty()) {
160             return FALSE;
161         }
162         if (word == FX_BSTRC("}")) {
163             return TRUE;
164         }
165         if (word == FX_BSTRC("{")) {
166             CPDF_PSProc* pProc = FX_NEW CPDF_PSProc;
167             m_Operators.Add((FX_LPVOID)PSOP_PROC);
168             m_Operators.Add(pProc);
169             if (!pProc->Parse(parser)) {
170                 return FALSE;
171             }
172         } else {
173             int i = 0;
174             while (_PDF_PSOpNames[i].name) {
175                 if (word == CFX_ByteStringC(_PDF_PSOpNames[i].name)) {
176                     m_Operators.Add((FX_LPVOID)_PDF_PSOpNames[i].op);
177                     break;
178                 }
179                 i ++;
180             }
181             if (_PDF_PSOpNames[i].name == NULL) {
182                 FX_FLOAT* pd = FX_Alloc(FX_FLOAT, 1);
183                 *pd = FX_atof(word);
184                 m_Operators.Add((FX_LPVOID)PSOP_CONST);
185                 m_Operators.Add(pd);
186             }
187         }
188     }
189 }
190 #define PI 3.1415926535897932384626433832795f
191 FX_BOOL CPDF_PSEngine::DoOperator(PDF_PSOP op)
192 {
193     int i1, i2;
194     FX_FLOAT d1, d2;
195     switch (op) {
196         case PSOP_ADD:
197             d1 = Pop();
198             d2 = Pop();
199             Push(d1 + d2);
200             break;
201         case PSOP_SUB:
202             d2 = Pop();
203             d1 = Pop();
204             Push(d1 - d2);
205             break;
206         case PSOP_MUL:
207             d1 = Pop();
208             d2 = Pop();
209             Push(d1 * d2);
210             break;
211         case PSOP_DIV:
212             d2 = Pop();
213             d1 = Pop();
214             Push(d1 / d2);
215             break;
216         case PSOP_IDIV:
217             i2 = (int)Pop();
218             i1 = (int)Pop();
219             Push(i1 / i2);
220             break;
221         case PSOP_MOD:
222             i2 = (int)Pop();
223             i1 = (int)Pop();
224             Push(i1 % i2);
225             break;
226         case PSOP_NEG:
227             d1 = Pop();
228             Push(-d1);
229             break;
230         case PSOP_ABS:
231             d1 = Pop();
232             Push((FX_FLOAT)FXSYS_fabs(d1));
233             break;
234         case PSOP_CEILING:
235             d1 = Pop();
236             Push((FX_FLOAT)FXSYS_ceil(d1));
237             break;
238         case PSOP_FLOOR:
239             d1 = Pop();
240             Push((FX_FLOAT)FXSYS_floor(d1));
241             break;
242         case PSOP_ROUND:
243             d1 = Pop();
244             Push(FXSYS_round(d1));
245             break;
246         case PSOP_TRUNCATE:
247             i1 = (int)Pop();
248             Push(i1);
249             break;
250         case PSOP_SQRT:
251             d1 = Pop();
252             Push((FX_FLOAT)FXSYS_sqrt(d1));
253             break;
254         case PSOP_SIN:
255             d1 = Pop();
256             Push((FX_FLOAT)FXSYS_sin(d1 * PI / 180.0f));
257             break;
258         case PSOP_COS:
259             d1 = Pop();
260             Push((FX_FLOAT)FXSYS_cos(d1 * PI / 180.0f));
261             break;
262         case PSOP_ATAN:
263             d2 = Pop();
264             d1 = Pop();
265             d1 = (FX_FLOAT)(FXSYS_atan2(d1, d2) * 180.0 / PI);
266             if (d1 < 0) {
267                 d1 += 360;
268             }
269             Push(d1);
270             break;
271         case PSOP_EXP:
272             d2 = Pop();
273             d1 = Pop();
274             Push((FX_FLOAT)FXSYS_pow(d1, d2));
275             break;
276         case PSOP_LN:
277             d1 = Pop();
278             Push((FX_FLOAT)FXSYS_log(d1));
279             break;
280         case PSOP_LOG:
281             d1 = Pop();
282             Push((FX_FLOAT)FXSYS_log10(d1));
283             break;
284         case PSOP_CVI:
285             i1 = (int)Pop();
286             Push(i1);
287             break;
288         case PSOP_CVR:
289             break;
290         case PSOP_EQ:
291             d2 = Pop();
292             d1 = Pop();
293             Push((int)(d1 == d2));
294             break;
295         case PSOP_NE:
296             d2 = Pop();
297             d1 = Pop();
298             Push((int)(d1 != d2));
299             break;
300         case PSOP_GT:
301             d2 = Pop();
302             d1 = Pop();
303             Push((int)(d1 > d2));
304             break;
305         case PSOP_GE:
306             d2 = Pop();
307             d1 = Pop();
308             Push((int)(d1 >= d2));
309             break;
310         case PSOP_LT:
311             d2 = Pop();
312             d1 = Pop();
313             Push((int)(d1 < d2));
314             break;
315         case PSOP_LE:
316             d2 = Pop();
317             d1 = Pop();
318             Push((int)(d1 <= d2));
319             break;
320         case PSOP_AND:
321             i1 = (int)Pop();
322             i2 = (int)Pop();
323             Push(i1 & i2);
324             break;
325         case PSOP_OR:
326             i1 = (int)Pop();
327             i2 = (int)Pop();
328             Push(i1 | i2);
329             break;
330         case PSOP_XOR:
331             i1 = (int)Pop();
332             i2 = (int)Pop();
333             Push(i1 ^ i2);
334             break;
335         case PSOP_NOT:
336             i1 = (int)Pop();
337             Push((int)!i1);
338             break;
339         case PSOP_BITSHIFT: {
340                 int shift = (int)Pop();
341                 int i = (int)Pop();
342                 if (shift > 0) {
343                     Push(i << shift);
344                 } else {
345                     Push(i >> -shift);
346                 }
347                 break;
348             }
349         case PSOP_TRUE:
350             Push(1);
351             break;
352         case PSOP_FALSE:
353             Push(0);
354             break;
355         case PSOP_POP:
356             Pop();
357             break;
358         case PSOP_EXCH:
359             d2 = Pop();
360             d1 = Pop();
361             Push(d2);
362             Push(d1);
363             break;
364         case PSOP_DUP:
365             d1 = Pop();
366             Push(d1);
367             Push(d1);
368             break;
369         case PSOP_COPY: {
370                 int n = (int)Pop();
371                 if (n < 0 || n > PSENGINE_STACKSIZE || m_StackCount + n > PSENGINE_STACKSIZE || n > m_StackCount) {
372                     break;
373                 }
374                 for (int i = 0; i < n; i ++) {
375                     m_Stack[m_StackCount + i] = m_Stack[m_StackCount + i - n];
376                 }
377                 m_StackCount += n;
378                 break;
379             }
380         case PSOP_INDEX: {
381                 int n = (int)Pop();
382                 if (n < 0 || n >= m_StackCount) {
383                     break;
384                 }
385                 Push(m_Stack[m_StackCount - n - 1]);
386                 break;
387             }
388         case PSOP_ROLL: {
389                 int j = (int)Pop();
390                 int n = (int)Pop();
391                 if (m_StackCount == 0) {
392                     break;
393                 }
394                 if (n < 0 || n > m_StackCount) {
395                     break;
396                 }
397                 if (j < 0)
398                     for (int i = 0; i < -j; i ++) {
399                         FX_FLOAT first = m_Stack[m_StackCount - n];
400                         for (int ii = 0; ii < n - 1; ii ++) {
401                             m_Stack[m_StackCount - n + ii] = m_Stack[m_StackCount - n + ii + 1];
402                         }
403                         m_Stack[m_StackCount - 1] = first;
404                     }
405                 else
406                     for (int i = 0; i < j; i ++) {
407                         FX_FLOAT last = m_Stack[m_StackCount - 1];
408                         int ii;
409                         for (ii = 0; ii < n - 1; ii ++) {
410                             m_Stack[m_StackCount - ii - 1] = m_Stack[m_StackCount - ii - 2];
411                         }
412                         m_Stack[m_StackCount - ii - 1] = last;
413                     }
414                 break;
415             }
416         default:
417             break;
418     }
419     return TRUE;
420 }
421 static FX_FLOAT PDF_Interpolate(FX_FLOAT x, FX_FLOAT xmin, FX_FLOAT xmax, FX_FLOAT ymin, FX_FLOAT ymax)
422 {
423     return ((x - xmin) * (ymax - ymin) / (xmax - xmin)) + ymin;
424 }
425 static FX_DWORD _GetBits32(FX_LPCBYTE pData, int bitpos, int nbits)
426 {
427     int result = 0;
428     for (int i = 0; i < nbits; i ++)
429         if (pData[(bitpos + i) / 8] & (1 << (7 - (bitpos + i) % 8))) {
430             result |= 1 << (nbits - i - 1);
431         }
432     return result;
433 }
434 typedef struct {
435     FX_FLOAT    encode_max, encode_min;
436     int                 sizes;
437 } SampleEncodeInfo;
438 typedef struct {
439     FX_FLOAT    decode_max, decode_min;
440 } SampleDecodeInfo;
441 class CPDF_SampledFunc : public CPDF_Function
442 {
443 public:
444     CPDF_SampledFunc();
445     virtual ~CPDF_SampledFunc();
446     virtual FX_BOOL             v_Init(CPDF_Object* pObj);
447     virtual FX_BOOL             v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
448     SampleEncodeInfo*   m_pEncodeInfo;
449     SampleDecodeInfo*   m_pDecodeInfo;
450     FX_DWORD    m_nBitsPerSample, m_SampleMax;
451     CPDF_StreamAcc*     m_pSampleStream;
452 };
453 CPDF_SampledFunc::CPDF_SampledFunc()
454 {
455     m_pSampleStream = NULL;
456     m_pEncodeInfo = NULL;
457     m_pDecodeInfo = NULL;
458 }
459 CPDF_SampledFunc::~CPDF_SampledFunc()
460 {
461     if (m_pSampleStream) {
462         delete m_pSampleStream;
463     }
464     if (m_pEncodeInfo) {
465         FX_Free(m_pEncodeInfo);
466     }
467     if (m_pDecodeInfo) {
468         FX_Free(m_pDecodeInfo);
469     }
470 }
471 FX_BOOL CPDF_SampledFunc::v_Init(CPDF_Object* pObj)
472 {
473     if (pObj->GetType() != PDFOBJ_STREAM) {
474         return FALSE;
475     }
476     CPDF_Stream* pStream = (CPDF_Stream*)pObj;
477     CPDF_Dictionary* pDict = pStream->GetDict();
478     CPDF_Array* pSize = pDict->GetArray(FX_BSTRC("Size"));
479     CPDF_Array* pEncode = pDict->GetArray(FX_BSTRC("Encode"));
480     CPDF_Array* pDecode = pDict->GetArray(FX_BSTRC("Decode"));
481     m_nBitsPerSample = pDict->GetInteger(FX_BSTRC("BitsPerSample"));
482     m_SampleMax = 0xffffffff >> (32 - m_nBitsPerSample);
483     m_pSampleStream = FX_NEW CPDF_StreamAcc;
484     m_pSampleStream->LoadAllData(pStream, FALSE);
485     m_pEncodeInfo = FX_Alloc(SampleEncodeInfo, m_nInputs);
486     int i;
487     FX_DWORD nTotalSamples = 1;
488     for (i = 0; i < m_nInputs; i ++) {
489         m_pEncodeInfo[i].sizes = pSize ? pSize->GetInteger(i) : 0;
490         if (!pSize && i == 0) {
491             m_pEncodeInfo[i].sizes = pDict->GetInteger(FX_BSTRC("Size"));
492         }
493         if (nTotalSamples > 0 && (FX_UINT32)(m_pEncodeInfo[i].sizes) > UINT_MAX / nTotalSamples) {
494             return FALSE;
495         }
496         nTotalSamples *= m_pEncodeInfo[i].sizes;
497         if (pEncode) {
498             m_pEncodeInfo[i].encode_min = pEncode->GetFloat(i * 2);
499             m_pEncodeInfo[i].encode_max = pEncode->GetFloat(i * 2 + 1);
500         } else {
501             m_pEncodeInfo[i].encode_min = 0;
502             if (m_pEncodeInfo[i].sizes == 1) {
503                 m_pEncodeInfo[i].encode_max = 1;
504             } else {
505                 m_pEncodeInfo[i].encode_max = (FX_FLOAT)m_pEncodeInfo[i].sizes - 1;
506             }
507         }
508     }
509     if (nTotalSamples > 0 && m_nBitsPerSample > UINT_MAX / nTotalSamples) {
510         return FALSE;
511     }
512     nTotalSamples *= m_nBitsPerSample;
513     if (nTotalSamples > 0 && ((FX_UINT32)m_nOutputs) > UINT_MAX / nTotalSamples) {
514         return FALSE;
515     }
516     nTotalSamples *= m_nOutputs;
517     if (nTotalSamples == 0 || m_pSampleStream->GetSize() * 8 < nTotalSamples) {
518         return FALSE;
519     }
520     m_pDecodeInfo = FX_Alloc(SampleDecodeInfo, m_nOutputs);
521     for (i = 0; i < m_nOutputs; i ++) {
522         if (pDecode) {
523             m_pDecodeInfo[i].decode_min = pDecode->GetFloat(2 * i);
524             m_pDecodeInfo[i].decode_max = pDecode->GetFloat(2 * i + 1);
525         } else {
526             m_pDecodeInfo[i].decode_min = m_pRanges[i * 2];
527             m_pDecodeInfo[i].decode_max = m_pRanges[i * 2 + 1];
528         }
529     }
530     return TRUE;
531 }
532 FX_BOOL CPDF_SampledFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const
533 {
534     int pos = 0;
535     CFX_FixedBufGrow<FX_FLOAT, 16> encoded_input_buf(m_nInputs);
536     FX_FLOAT* encoded_input = encoded_input_buf;
537     CFX_FixedBufGrow<int, 32> int_buf(m_nInputs * 2);
538     int* index = int_buf;
539     int* blocksize = index + m_nInputs;
540     for (int i = 0; i < m_nInputs; i ++) {
541         if (i == 0) {
542             blocksize[i] = 1;
543         } else {
544             blocksize[i] = blocksize[i - 1] * m_pEncodeInfo[i - 1].sizes;
545         }
546         encoded_input[i] = PDF_Interpolate(inputs[i], m_pDomains[i * 2], m_pDomains[i * 2 + 1],
547                                            m_pEncodeInfo[i].encode_min, m_pEncodeInfo[i].encode_max);
548         index[i] = (int)encoded_input[i];
549         if (index[i] < 0) {
550             index[i] = 0;
551         } else if (index[i] > m_pEncodeInfo[i].sizes - 1) {
552             index[i] = m_pEncodeInfo[i].sizes - 1;
553         }
554         pos += index[i] * blocksize[i];
555     }
556     int bitpos = pos * m_nBitsPerSample * m_nOutputs;
557     FX_LPCBYTE pSampleData = m_pSampleStream->GetData();
558     if (pSampleData == NULL) {
559         return FALSE;
560     }
561     for (int j = 0; j < m_nOutputs; j ++) {
562         FX_DWORD sample = _GetBits32(pSampleData, bitpos + j * m_nBitsPerSample, m_nBitsPerSample);
563         FX_FLOAT encoded = (FX_FLOAT)sample;
564         for (int i = 0; i < m_nInputs; i ++) {
565             if (index[i] == m_pEncodeInfo[i].sizes - 1) {
566                 if (index[i] == 0) {
567                     encoded = encoded_input[i] * (FX_FLOAT)sample;
568                 }
569             } else {
570                 int bitpos1 = bitpos + m_nBitsPerSample * m_nOutputs * blocksize[i];
571                 FX_DWORD sample1 = _GetBits32(pSampleData, bitpos1 + j * m_nBitsPerSample, m_nBitsPerSample);
572                 encoded += (encoded_input[i] - index[i]) * ((FX_FLOAT)sample1 - (FX_FLOAT)sample);
573             }
574         }
575         results[j] = PDF_Interpolate(encoded, 0, (FX_FLOAT)m_SampleMax,
576                                      m_pDecodeInfo[j].decode_min, m_pDecodeInfo[j].decode_max);
577     }
578     return TRUE;
579 }
580 class CPDF_PSFunc : public CPDF_Function
581 {
582 public:
583     virtual FX_BOOL             v_Init(CPDF_Object* pObj);
584     virtual FX_BOOL             v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
585     CPDF_PSEngine m_PS;
586 };
587 FX_BOOL CPDF_PSFunc::v_Init(CPDF_Object* pObj)
588 {
589     CPDF_Stream* pStream = (CPDF_Stream*)pObj;
590     CPDF_StreamAcc acc;
591     acc.LoadAllData(pStream, FALSE);
592     return m_PS.Parse((const FX_CHAR*)acc.GetData(), acc.GetSize());
593 }
594 FX_BOOL CPDF_PSFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const
595 {
596     CPDF_PSEngine& PS = (CPDF_PSEngine&)m_PS;
597     PS.Reset();
598     int i;
599     for (i = 0; i < m_nInputs; i ++) {
600         PS.Push(inputs[i]);
601     }
602     PS.Execute();
603     if (PS.GetStackSize() < m_nOutputs) {
604         return FALSE;
605     }
606     for (i = 0; i < m_nOutputs; i ++) {
607         results[m_nOutputs - i - 1] = PS.Pop();
608     }
609     return TRUE;
610 }
611 class CPDF_ExpIntFunc : public CPDF_Function
612 {
613 public:
614     CPDF_ExpIntFunc();
615     virtual ~CPDF_ExpIntFunc();
616     virtual FX_BOOL             v_Init(CPDF_Object* pObj);
617     virtual FX_BOOL             v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
618     FX_FLOAT    m_Exponent;
619     FX_FLOAT*   m_pBeginValues;
620     FX_FLOAT*   m_pEndValues;
621     int         m_nOrigOutputs;
622 };
623 CPDF_ExpIntFunc::CPDF_ExpIntFunc()
624 {
625     m_pBeginValues = NULL;
626     m_pEndValues = NULL;
627 }
628 CPDF_ExpIntFunc::~CPDF_ExpIntFunc()
629 {
630     if (m_pBeginValues) {
631         FX_Free(m_pBeginValues);
632     }
633     if (m_pEndValues) {
634         FX_Free(m_pEndValues);
635     }
636 }
637 FX_BOOL CPDF_ExpIntFunc::v_Init(CPDF_Object* pObj)
638 {
639     CPDF_Dictionary* pDict = pObj->GetDict();
640     if (pDict == NULL) {
641         return FALSE;
642     }
643     CPDF_Array* pArray0 = pDict->GetArray(FX_BSTRC("C0"));
644     if (m_nOutputs == 0) {
645         m_nOutputs = 1;
646         if (pArray0) {
647             m_nOutputs = pArray0->GetCount();
648         }
649     }
650     CPDF_Array* pArray1 = pDict->GetArray(FX_BSTRC("C1"));
651     m_pBeginValues = FX_Alloc(FX_FLOAT, m_nOutputs * 2);
652     m_pEndValues = FX_Alloc(FX_FLOAT, m_nOutputs * 2);
653     for (int i = 0; i < m_nOutputs; i ++) {
654         m_pBeginValues[i] = pArray0 ? pArray0->GetFloat(i) : 0.0f;
655         m_pEndValues[i] = pArray1 ? pArray1->GetFloat(i) : 1.0f;
656     }
657     m_Exponent = pDict->GetFloat(FX_BSTRC("N"));
658     m_nOrigOutputs = m_nOutputs;
659     if (m_nOutputs && m_nInputs > INT_MAX / m_nOutputs) {
660         return FALSE;
661     }
662     m_nOutputs *= m_nInputs;
663     return TRUE;
664 }
665 FX_BOOL CPDF_ExpIntFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const
666 {
667     for (int i = 0; i < m_nInputs; i ++)
668         for (int j = 0; j < m_nOrigOutputs; j ++) {
669             results[i * m_nOrigOutputs + j] = m_pBeginValues[j] + (FX_FLOAT)FXSYS_pow(inputs[i], m_Exponent) *
670                                               (m_pEndValues[j] - m_pBeginValues[j]);
671         }
672     return TRUE;
673 }
674 class CPDF_StitchFunc : public CPDF_Function
675 {
676 public:
677     CPDF_StitchFunc();
678     virtual ~CPDF_StitchFunc();
679     virtual FX_BOOL             v_Init(CPDF_Object* pObj);
680     virtual FX_BOOL             v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
681     int                 m_nSubs;
682     CPDF_Function** m_pSubFunctions;
683     FX_FLOAT*   m_pBounds;
684     FX_FLOAT*   m_pEncode;
685 };
686 CPDF_StitchFunc::CPDF_StitchFunc()
687 {
688     m_nSubs = 0;
689     m_pSubFunctions = NULL;
690     m_pBounds = NULL;
691     m_pEncode = NULL;
692 }
693 CPDF_StitchFunc::~CPDF_StitchFunc()
694 {
695     for (int i = 0; i < m_nSubs; i ++)
696         if (m_pSubFunctions[i]) {
697             delete m_pSubFunctions[i];
698         }
699     if (m_pSubFunctions) {
700         FX_Free(m_pSubFunctions);
701     }
702     if (m_pBounds) {
703         FX_Free(m_pBounds);
704     }
705     if (m_pEncode) {
706         FX_Free(m_pEncode);
707     }
708 }
709 FX_BOOL CPDF_StitchFunc::v_Init(CPDF_Object* pObj)
710 {
711     CPDF_Dictionary* pDict = pObj->GetDict();
712     if (pDict == NULL) {
713         return FALSE;
714     }
715     CPDF_Array* pArray = pDict->GetArray(FX_BSTRC("Functions"));
716     if (pArray == NULL) {
717         return FALSE;
718     }
719     m_nSubs = pArray->GetCount();
720     if (m_nSubs == 0) {
721         return FALSE;
722     }
723     m_pSubFunctions = FX_Alloc(CPDF_Function*, m_nSubs);
724     FXSYS_memset32(m_pSubFunctions, 0, sizeof(CPDF_Function*)*m_nSubs);
725     m_nOutputs = 0;
726     int i;
727     for (i = 0; i < m_nSubs; i ++) {
728         CPDF_Object* pSub = pArray->GetElementValue(i);
729         if (pSub == pObj) {
730             return FALSE;
731         }
732         m_pSubFunctions[i] = CPDF_Function::Load(pSub);
733         if (m_pSubFunctions[i] == NULL) {
734             return FALSE;
735         }
736         if (m_pSubFunctions[i]->CountOutputs() > m_nOutputs) {
737             m_nOutputs = m_pSubFunctions[i]->CountOutputs();
738         }
739     }
740     m_pBounds = FX_Alloc(FX_FLOAT, m_nSubs + 1);
741     m_pBounds[0] = m_pDomains[0];
742     pArray = pDict->GetArray(FX_BSTRC("Bounds"));
743     if (pArray == NULL) {
744         return FALSE;
745     }
746     for (i = 0; i < m_nSubs - 1; i ++) {
747         m_pBounds[i + 1] = pArray->GetFloat(i);
748     }
749     m_pBounds[m_nSubs] = m_pDomains[1];
750     m_pEncode = FX_Alloc(FX_FLOAT, m_nSubs * 2);
751     pArray = pDict->GetArray(FX_BSTRC("Encode"));
752     if (pArray == NULL) {
753         return FALSE;
754     }
755     for (i = 0; i < m_nSubs * 2; i ++) {
756         m_pEncode[i] = pArray->GetFloat(i);
757     }
758     return TRUE;
759 }
760 FX_BOOL CPDF_StitchFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* outputs) const
761 {
762     FX_FLOAT input = inputs[0];
763     int i;
764     for (i = 0; i < m_nSubs - 1; i ++)
765         if (input < m_pBounds[i + 1]) {
766             break;
767         }
768     if (m_pSubFunctions[i] == NULL) {
769         return FALSE;
770     }
771     input = PDF_Interpolate(input, m_pBounds[i], m_pBounds[i + 1], m_pEncode[i * 2], m_pEncode[i * 2 + 1]);
772     int nresults;
773     m_pSubFunctions[i]->Call(&input, m_nInputs, outputs, nresults);
774     return TRUE;
775 }
776 CPDF_Function* CPDF_Function::Load(CPDF_Object* pFuncObj)
777 {
778     if (pFuncObj == NULL) {
779         return NULL;
780     }
781     CPDF_Function* pFunc = NULL;
782     int type;
783     if (pFuncObj->GetType() == PDFOBJ_STREAM) {
784         type = ((CPDF_Stream*)pFuncObj)->GetDict()->GetInteger(FX_BSTRC("FunctionType"));
785     } else if (pFuncObj->GetType() == PDFOBJ_DICTIONARY) {
786         type = ((CPDF_Dictionary*)pFuncObj)->GetInteger(FX_BSTRC("FunctionType"));
787     } else {
788         return NULL;
789     }
790     if (type == 0) {
791         pFunc = FX_NEW CPDF_SampledFunc;
792     } else if (type == 2) {
793         pFunc = FX_NEW CPDF_ExpIntFunc;
794     } else if (type == 3) {
795         pFunc = FX_NEW CPDF_StitchFunc;
796     } else if (type == 4) {
797         pFunc = FX_NEW CPDF_PSFunc;
798     } else {
799         return NULL;
800     }
801     if (!pFunc->Init(pFuncObj)) {
802         delete pFunc;
803         return NULL;
804     }
805     return pFunc;
806 }
807 CPDF_Function::CPDF_Function()
808 {
809     m_pDomains = NULL;
810     m_pRanges = NULL;
811 }
812 CPDF_Function::~CPDF_Function()
813 {
814     if (m_pDomains) {
815         FX_Free(m_pDomains);
816         m_pDomains = NULL;
817     }
818     if (m_pRanges) {
819         FX_Free(m_pRanges);
820         m_pRanges = NULL;
821     }
822 }
823 FX_BOOL CPDF_Function::Init(CPDF_Object* pObj)
824 {
825     CPDF_Dictionary* pDict;
826     if (pObj->GetType() == PDFOBJ_STREAM) {
827         pDict = ((CPDF_Stream*)pObj)->GetDict();
828     } else {
829         pDict = (CPDF_Dictionary*)pObj;
830     }
831     CPDF_Array* pDomains = pDict->GetArray(FX_BSTRC("Domain"));
832     if (pDomains == NULL) {
833         return FALSE;
834     }
835     m_nInputs = pDomains->GetCount() / 2;
836     if (m_nInputs == 0) {
837         return FALSE;
838     }
839     m_pDomains = FX_Alloc(FX_FLOAT, m_nInputs * 2);
840     for (int i = 0; i < m_nInputs * 2; i ++) {
841         m_pDomains[i] = pDomains->GetFloat(i);
842     }
843     CPDF_Array* pRanges = pDict->GetArray(FX_BSTRC("Range"));
844     m_nOutputs = 0;
845     if (pRanges) {
846         m_nOutputs = pRanges->GetCount() / 2;
847         m_pRanges = FX_Alloc(FX_FLOAT, m_nOutputs * 2);
848         for (int i = 0; i < m_nOutputs * 2; i ++) {
849             m_pRanges[i] = pRanges->GetFloat(i);
850         }
851     }
852     FX_DWORD old_outputs = m_nOutputs;
853     FX_BOOL ret = v_Init(pObj);
854     if (m_pRanges && m_nOutputs > (int)old_outputs) {
855         m_pRanges = FX_Realloc(FX_FLOAT, m_pRanges, m_nOutputs * 2);
856         if (m_pRanges) {
857             FXSYS_memset32(m_pRanges + (old_outputs * 2), 0, sizeof(FX_FLOAT) * (m_nOutputs - old_outputs) * 2);
858         }
859     }
860     return ret;
861 }
862 FX_BOOL CPDF_Function::Call(FX_FLOAT* inputs, int ninputs, FX_FLOAT* results, int& nresults) const
863 {
864     if (m_nInputs != ninputs) {
865         return FALSE;
866     }
867     nresults = m_nOutputs;
868     for (int i = 0; i < m_nInputs; i ++) {
869         if (inputs[i] < m_pDomains[i * 2]) {
870             inputs[i] = m_pDomains[i * 2];
871         } else if (inputs[i] > m_pDomains[i * 2 + 1]) {
872             inputs[i] = m_pDomains[i * 2] + 1;
873         }
874     }
875     v_Call(inputs, results);
876     if (m_pRanges) {
877         for (int i = 0; i < m_nOutputs; i ++) {
878             if (results[i] < m_pRanges[i * 2]) {
879                 results[i] = m_pRanges[i * 2];
880             } else if (results[i] > m_pRanges[i * 2 + 1]) {
881                 results[i] = m_pRanges[i * 2 + 1];
882             }
883         }
884     }
885     return TRUE;
886 }