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