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