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