Revert "Revert "Redo range check in CPDF_SampledFunc::v_Call().""
[pdfium.git] / core / src / fpdfapi / fpdf_page / fpdf_page_func.cpp
index 335460f..c961f8b 100644 (file)
-// Copyright 2014 PDFium Authors. All rights reserved.\r
-// Use of this source code is governed by a BSD-style license that can be\r
-// found in the LICENSE file.\r
\r
-// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com\r
-\r
-#include "../../../include/fpdfapi/fpdf_page.h"\r
-#include "../../../include/fpdfapi/fpdf_module.h"\r
-#include "pageint.h"\r
-#include <limits.h>\r
-class CPDF_PSEngine;\r
-typedef enum {PSOP_ADD, PSOP_SUB, PSOP_MUL, PSOP_DIV, PSOP_IDIV, PSOP_MOD,\r
-              PSOP_NEG, PSOP_ABS, PSOP_CEILING, PSOP_FLOOR, PSOP_ROUND, PSOP_TRUNCATE,\r
-              PSOP_SQRT, PSOP_SIN, PSOP_COS, PSOP_ATAN, PSOP_EXP, PSOP_LN, PSOP_LOG,\r
-              PSOP_CVI, PSOP_CVR, PSOP_EQ, PSOP_NE, PSOP_GT, PSOP_GE, PSOP_LT, PSOP_LE,\r
-              PSOP_AND, PSOP_OR, PSOP_XOR, PSOP_NOT, PSOP_BITSHIFT, PSOP_TRUE, PSOP_FALSE,\r
-              PSOP_IF, PSOP_IFELSE, PSOP_POP, PSOP_EXCH, PSOP_DUP, PSOP_COPY,\r
-              PSOP_INDEX, PSOP_ROLL, PSOP_PROC, PSOP_CONST\r
-             } PDF_PSOP;\r
-class CPDF_PSProc : public CFX_Object\r
-{\r
-public:\r
-    ~CPDF_PSProc();\r
-    FX_BOOL    Parse(CPDF_SimpleParser& parser);\r
-    FX_BOOL    Execute(CPDF_PSEngine* pEngine);\r
-    CFX_PtrArray               m_Operators;\r
-};\r
-#define PSENGINE_STACKSIZE 100\r
-class CPDF_PSEngine : public CFX_Object\r
-{\r
-public:\r
-    CPDF_PSEngine();\r
-    ~CPDF_PSEngine();\r
-    FX_BOOL    Parse(const FX_CHAR* string, int size);\r
-    FX_BOOL    Execute()\r
-    {\r
-        return m_MainProc.Execute(this);\r
-    }\r
-    FX_BOOL    DoOperator(PDF_PSOP op);\r
-    void       Reset()\r
-    {\r
-        m_StackCount = 0;\r
-    }\r
-    void       Push(FX_FLOAT value);\r
-    void       Push(int value)\r
-    {\r
-        Push((FX_FLOAT)value);\r
-    }\r
-    FX_FLOAT   Pop();\r
-    int                GetStackSize()\r
-    {\r
-        return m_StackCount;\r
-    }\r
-private:\r
-    FX_FLOAT   m_Stack[PSENGINE_STACKSIZE];\r
-    int                m_StackCount;\r
-    CPDF_PSProc        m_MainProc;\r
-};\r
-CPDF_PSProc::~CPDF_PSProc()\r
-{\r
-    int size = m_Operators.GetSize();\r
-    for (int i = 0; i < size; i ++) {\r
-        if (m_Operators[i] == (FX_LPVOID)PSOP_PROC) {\r
-            delete (CPDF_PSProc*)m_Operators[i + 1];\r
-            i ++;\r
-        } else if (m_Operators[i] == (FX_LPVOID)PSOP_CONST) {\r
-            FX_Free((FX_FLOAT*)m_Operators[i + 1]);\r
-            i ++;\r
-        }\r
-    }\r
-}\r
-#pragma optimize( "", off )\r
-FX_BOOL CPDF_PSProc::Execute(CPDF_PSEngine* pEngine)\r
-{\r
-    int size = m_Operators.GetSize();\r
-    for (int i = 0; i < size; i ++) {\r
-        PDF_PSOP op = (PDF_PSOP)(FX_UINTPTR)m_Operators[i];\r
-        if (op == PSOP_PROC) {\r
-            i ++;\r
-        } else if (op == PSOP_CONST) {\r
-            pEngine->Push(*(FX_FLOAT*)m_Operators[i + 1]);\r
-            i ++;\r
-        } else if (op == PSOP_IF) {\r
-            if (i < 2 || m_Operators[i - 2] != (FX_LPVOID)PSOP_PROC) {\r
-                return FALSE;\r
-            }\r
-            if ((int)pEngine->Pop()) {\r
-                ((CPDF_PSProc*)m_Operators[i - 1])->Execute(pEngine);\r
-            }\r
-        } else if (op == PSOP_IFELSE) {\r
-            if (i < 4 || m_Operators[i - 2] != (FX_LPVOID)PSOP_PROC ||\r
-                    m_Operators[i - 4] != (FX_LPVOID)PSOP_PROC) {\r
-                return FALSE;\r
-            }\r
-            if ((int)pEngine->Pop()) {\r
-                ((CPDF_PSProc*)m_Operators[i - 3])->Execute(pEngine);\r
-            } else {\r
-                ((CPDF_PSProc*)m_Operators[i - 1])->Execute(pEngine);\r
-            }\r
-        } else {\r
-            pEngine->DoOperator(op);\r
-        }\r
-    }\r
-    return TRUE;\r
-}\r
-#pragma optimize( "", on )\r
-CPDF_PSEngine::CPDF_PSEngine()\r
-{\r
-    m_StackCount = 0;\r
-}\r
-CPDF_PSEngine::~CPDF_PSEngine()\r
-{\r
-}\r
-void CPDF_PSEngine::Push(FX_FLOAT v)\r
-{\r
-    if (m_StackCount == 100) {\r
-        return;\r
-    }\r
-    m_Stack[m_StackCount++] = v;\r
-}\r
-FX_FLOAT CPDF_PSEngine::Pop()\r
-{\r
-    if (m_StackCount == 0) {\r
-        return 0;\r
-    }\r
-    return m_Stack[--m_StackCount];\r
-}\r
-const struct _PDF_PSOpName {\r
-    const FX_CHAR* name;\r
-    PDF_PSOP op;\r
-} _PDF_PSOpNames[] = {\r
-    {"add", PSOP_ADD}, {"sub", PSOP_SUB}, {"mul", PSOP_MUL}, {"div", PSOP_DIV},\r
-    {"idiv", PSOP_IDIV}, {"mod", PSOP_MOD}, {"neg", PSOP_NEG}, {"abs", PSOP_ABS},\r
-    {"ceiling", PSOP_CEILING}, {"floor", PSOP_FLOOR}, {"round", PSOP_ROUND},\r
-    {"truncate", PSOP_TRUNCATE}, {"sqrt", PSOP_SQRT}, {"sin", PSOP_SIN},\r
-    {"cos", PSOP_COS}, {"atan", PSOP_ATAN}, {"exp", PSOP_EXP}, {"ln", PSOP_LN},\r
-    {"log", PSOP_LOG}, {"cvi", PSOP_CVI}, {"cvr", PSOP_CVR}, {"eq", PSOP_EQ},\r
-    {"ne", PSOP_NE}, {"gt", PSOP_GT}, {"ge", PSOP_GE}, {"lt", PSOP_LT},\r
-    {"le", PSOP_LE}, {"and", PSOP_AND}, {"or", PSOP_OR}, {"xor", PSOP_XOR},\r
-    {"not", PSOP_NOT}, {"bitshift", PSOP_BITSHIFT}, {"true", PSOP_TRUE},\r
-    {"false", PSOP_FALSE}, {"if", PSOP_IF}, {"ifelse", PSOP_IFELSE},\r
-    {"pop", PSOP_POP}, {"exch", PSOP_EXCH}, {"dup", PSOP_DUP},\r
-    {"copy", PSOP_COPY}, {"index", PSOP_INDEX}, {"roll", PSOP_ROLL},\r
-    {NULL, PSOP_PROC}\r
-};\r
-FX_BOOL CPDF_PSEngine::Parse(const FX_CHAR* string, int size)\r
-{\r
-    CPDF_SimpleParser parser((FX_LPBYTE)string, size);\r
-    CFX_ByteStringC word = parser.GetWord();\r
-    if (word != FX_BSTRC("{")) {\r
-        return FALSE;\r
-    }\r
-    return m_MainProc.Parse(parser);\r
-}\r
-FX_BOOL CPDF_PSProc::Parse(CPDF_SimpleParser& parser)\r
-{\r
-    while (1) {\r
-        CFX_ByteStringC word = parser.GetWord();\r
-        if (word.IsEmpty()) {\r
-            return FALSE;\r
-        }\r
-        if (word == FX_BSTRC("}")) {\r
-            return TRUE;\r
-        }\r
-        if (word == FX_BSTRC("{")) {\r
-            CPDF_PSProc* pProc = FX_NEW CPDF_PSProc;\r
-            m_Operators.Add((FX_LPVOID)PSOP_PROC);\r
-            m_Operators.Add(pProc);\r
-            if (!pProc->Parse(parser)) {\r
-                return FALSE;\r
-            }\r
-        } else {\r
-            int i = 0;\r
-            while (_PDF_PSOpNames[i].name) {\r
-                if (word == CFX_ByteStringC(_PDF_PSOpNames[i].name)) {\r
-                    m_Operators.Add((FX_LPVOID)_PDF_PSOpNames[i].op);\r
-                    break;\r
-                }\r
-                i ++;\r
-            }\r
-            if (_PDF_PSOpNames[i].name == NULL) {\r
-                FX_FLOAT* pd = FX_Alloc(FX_FLOAT, 1);\r
-                *pd = FX_atof(word);\r
-                m_Operators.Add((FX_LPVOID)PSOP_CONST);\r
-                m_Operators.Add(pd);\r
-            }\r
-        }\r
-    }\r
-}\r
-#define PI 3.1415926535897932384626433832795f\r
-FX_BOOL CPDF_PSEngine::DoOperator(PDF_PSOP op)\r
-{\r
-    int i1, i2;\r
-    FX_FLOAT d1, d2;\r
-    switch (op) {\r
-        case PSOP_ADD:\r
-            d1 = Pop();\r
-            d2 = Pop();\r
-            Push(d1 + d2);\r
-            break;\r
-        case PSOP_SUB:\r
-            d2 = Pop();\r
-            d1 = Pop();\r
-            Push(d1 - d2);\r
-            break;\r
-        case PSOP_MUL:\r
-            d1 = Pop();\r
-            d2 = Pop();\r
-            Push(d1 * d2);\r
-            break;\r
-        case PSOP_DIV:\r
-            d2 = Pop();\r
-            d1 = Pop();\r
-            Push(d1 / d2);\r
-            break;\r
-        case PSOP_IDIV:\r
-            i2 = (int)Pop();\r
-            i1 = (int)Pop();\r
-            Push(i1 / i2);\r
-            break;\r
-        case PSOP_MOD:\r
-            i2 = (int)Pop();\r
-            i1 = (int)Pop();\r
-            Push(i1 % i2);\r
-            break;\r
-        case PSOP_NEG:\r
-            d1 = Pop();\r
-            Push(-d1);\r
-            break;\r
-        case PSOP_ABS:\r
-            d1 = Pop();\r
-            Push((FX_FLOAT)FXSYS_fabs(d1));\r
-            break;\r
-        case PSOP_CEILING:\r
-            d1 = Pop();\r
-            Push((FX_FLOAT)FXSYS_ceil(d1));\r
-            break;\r
-        case PSOP_FLOOR:\r
-            d1 = Pop();\r
-            Push((FX_FLOAT)FXSYS_floor(d1));\r
-            break;\r
-        case PSOP_ROUND:\r
-            d1 = Pop();\r
-            Push(FXSYS_round(d1));\r
-            break;\r
-        case PSOP_TRUNCATE:\r
-            i1 = (int)Pop();\r
-            Push(i1);\r
-            break;\r
-        case PSOP_SQRT:\r
-            d1 = Pop();\r
-            Push((FX_FLOAT)FXSYS_sqrt(d1));\r
-            break;\r
-        case PSOP_SIN:\r
-            d1 = Pop();\r
-            Push((FX_FLOAT)FXSYS_sin(d1 * PI / 180.0f));\r
-            break;\r
-        case PSOP_COS:\r
-            d1 = Pop();\r
-            Push((FX_FLOAT)FXSYS_cos(d1 * PI / 180.0f));\r
-            break;\r
-        case PSOP_ATAN:\r
-            d2 = Pop();\r
-            d1 = Pop();\r
-            d1 = (FX_FLOAT)(FXSYS_atan2(d1, d2) * 180.0 / PI);\r
-            if (d1 < 0) {\r
-                d1 += 360;\r
-            }\r
-            Push(d1);\r
-            break;\r
-        case PSOP_EXP:\r
-            d2 = Pop();\r
-            d1 = Pop();\r
-            Push((FX_FLOAT)FXSYS_pow(d1, d2));\r
-            break;\r
-        case PSOP_LN:\r
-            d1 = Pop();\r
-            Push((FX_FLOAT)FXSYS_log(d1));\r
-            break;\r
-        case PSOP_LOG:\r
-            d1 = Pop();\r
-            Push((FX_FLOAT)FXSYS_log10(d1));\r
-            break;\r
-        case PSOP_CVI:\r
-            i1 = (int)Pop();\r
-            Push(i1);\r
-            break;\r
-        case PSOP_CVR:\r
-            break;\r
-        case PSOP_EQ:\r
-            d2 = Pop();\r
-            d1 = Pop();\r
-            Push((int)(d1 == d2));\r
-            break;\r
-        case PSOP_NE:\r
-            d2 = Pop();\r
-            d1 = Pop();\r
-            Push((int)(d1 != d2));\r
-            break;\r
-        case PSOP_GT:\r
-            d2 = Pop();\r
-            d1 = Pop();\r
-            Push((int)(d1 > d2));\r
-            break;\r
-        case PSOP_GE:\r
-            d2 = Pop();\r
-            d1 = Pop();\r
-            Push((int)(d1 >= d2));\r
-            break;\r
-        case PSOP_LT:\r
-            d2 = Pop();\r
-            d1 = Pop();\r
-            Push((int)(d1 < d2));\r
-            break;\r
-        case PSOP_LE:\r
-            d2 = Pop();\r
-            d1 = Pop();\r
-            Push((int)(d1 <= d2));\r
-            break;\r
-        case PSOP_AND:\r
-            i1 = (int)Pop();\r
-            i2 = (int)Pop();\r
-            Push(i1 & i2);\r
-            break;\r
-        case PSOP_OR:\r
-            i1 = (int)Pop();\r
-            i2 = (int)Pop();\r
-            Push(i1 | i2);\r
-            break;\r
-        case PSOP_XOR:\r
-            i1 = (int)Pop();\r
-            i2 = (int)Pop();\r
-            Push(i1 ^ i2);\r
-            break;\r
-        case PSOP_NOT:\r
-            i1 = (int)Pop();\r
-            Push((int)!i1);\r
-            break;\r
-        case PSOP_BITSHIFT: {\r
-                int shift = (int)Pop();\r
-                int i = (int)Pop();\r
-                if (shift > 0) {\r
-                    Push(i << shift);\r
-                } else {\r
-                    Push(i >> -shift);\r
-                }\r
-                break;\r
-            }\r
-        case PSOP_TRUE:\r
-            Push(1);\r
-            break;\r
-        case PSOP_FALSE:\r
-            Push(0);\r
-            break;\r
-        case PSOP_POP:\r
-            Pop();\r
-            break;\r
-        case PSOP_EXCH:\r
-            d2 = Pop();\r
-            d1 = Pop();\r
-            Push(d2);\r
-            Push(d1);\r
-            break;\r
-        case PSOP_DUP:\r
-            d1 = Pop();\r
-            Push(d1);\r
-            Push(d1);\r
-            break;\r
-        case PSOP_COPY: {\r
-                int n = (int)Pop();\r
-                if (n < 0 || n > PSENGINE_STACKSIZE || m_StackCount + n > PSENGINE_STACKSIZE || n > m_StackCount) {\r
-                    break;\r
-                }\r
-                for (int i = 0; i < n; i ++) {\r
-                    m_Stack[m_StackCount + i] = m_Stack[m_StackCount + i - n];\r
-                }\r
-                m_StackCount += n;\r
-                break;\r
-            }\r
-        case PSOP_INDEX: {\r
-                int n = (int)Pop();\r
-                if (n < 0 || n >= m_StackCount) {\r
-                    break;\r
-                }\r
-                Push(m_Stack[m_StackCount - n - 1]);\r
-                break;\r
-            }\r
-        case PSOP_ROLL: {\r
-                int j = (int)Pop();\r
-                int n = (int)Pop();\r
-                if (m_StackCount == 0) {\r
-                    break;\r
-                }\r
-                if (n < 0 || n > m_StackCount) {\r
-                    break;\r
-                }\r
-                if (j < 0)\r
-                    for (int i = 0; i < -j; i ++) {\r
-                        FX_FLOAT first = m_Stack[m_StackCount - n];\r
-                        for (int ii = 0; ii < n - 1; ii ++) {\r
-                            m_Stack[m_StackCount - n + ii] = m_Stack[m_StackCount - n + ii + 1];\r
-                        }\r
-                        m_Stack[m_StackCount - 1] = first;\r
-                    }\r
-                else\r
-                    for (int i = 0; i < j; i ++) {\r
-                        FX_FLOAT last = m_Stack[m_StackCount - 1];\r
-                        int ii;\r
-                        for (ii = 0; ii < n - 1; ii ++) {\r
-                            m_Stack[m_StackCount - ii - 1] = m_Stack[m_StackCount - ii - 2];\r
-                        }\r
-                        m_Stack[m_StackCount - ii - 1] = last;\r
-                    }\r
-                break;\r
-            }\r
-        default:\r
-            break;\r
-    }\r
-    return TRUE;\r
-}\r
-static FX_FLOAT PDF_Interpolate(FX_FLOAT x, FX_FLOAT xmin, FX_FLOAT xmax, FX_FLOAT ymin, FX_FLOAT ymax)\r
-{\r
-    return ((x - xmin) * (ymax - ymin) / (xmax - xmin)) + ymin;\r
-}\r
-static FX_DWORD _GetBits32(FX_LPCBYTE pData, int bitpos, int nbits)\r
-{\r
-    int result = 0;\r
-    for (int i = 0; i < nbits; i ++)\r
-        if (pData[(bitpos + i) / 8] & (1 << (7 - (bitpos + i) % 8))) {\r
-            result |= 1 << (nbits - i - 1);\r
-        }\r
-    return result;\r
-}\r
-typedef struct {\r
-    FX_FLOAT   encode_max, encode_min;\r
-    int                        sizes;\r
-} SampleEncodeInfo;\r
-typedef struct {\r
-    FX_FLOAT   decode_max, decode_min;\r
-} SampleDecodeInfo;\r
-class CPDF_SampledFunc : public CPDF_Function\r
-{\r
-public:\r
-    CPDF_SampledFunc();\r
-    virtual ~CPDF_SampledFunc();\r
-    virtual FX_BOOL            v_Init(CPDF_Object* pObj);\r
-    virtual FX_BOOL            v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;\r
-    SampleEncodeInfo*  m_pEncodeInfo;\r
-    SampleDecodeInfo*  m_pDecodeInfo;\r
-    FX_DWORD   m_nBitsPerSample, m_SampleMax;\r
-    CPDF_StreamAcc*    m_pSampleStream;\r
-};\r
-CPDF_SampledFunc::CPDF_SampledFunc()\r
-{\r
-    m_pSampleStream = NULL;\r
-    m_pEncodeInfo = NULL;\r
-    m_pDecodeInfo = NULL;\r
-}\r
-CPDF_SampledFunc::~CPDF_SampledFunc()\r
-{\r
-    if (m_pSampleStream) {\r
-        delete m_pSampleStream;\r
-    }\r
-    if (m_pEncodeInfo) {\r
-        FX_Free(m_pEncodeInfo);\r
-    }\r
-    if (m_pDecodeInfo) {\r
-        FX_Free(m_pDecodeInfo);\r
-    }\r
-}\r
-FX_BOOL CPDF_SampledFunc::v_Init(CPDF_Object* pObj)\r
-{\r
-    if (pObj->GetType() != PDFOBJ_STREAM) {\r
-        return FALSE;\r
-    }\r
-    CPDF_Stream* pStream = (CPDF_Stream*)pObj;\r
-    CPDF_Dictionary* pDict = pStream->GetDict();\r
-    CPDF_Array* pSize = pDict->GetArray(FX_BSTRC("Size"));\r
-    CPDF_Array* pEncode = pDict->GetArray(FX_BSTRC("Encode"));\r
-    CPDF_Array* pDecode = pDict->GetArray(FX_BSTRC("Decode"));\r
-    m_nBitsPerSample = pDict->GetInteger(FX_BSTRC("BitsPerSample"));\r
-    m_SampleMax = 0xffffffff >> (32 - m_nBitsPerSample);\r
-    m_pSampleStream = FX_NEW CPDF_StreamAcc;\r
-    m_pSampleStream->LoadAllData(pStream, FALSE);\r
-    m_pEncodeInfo = FX_Alloc(SampleEncodeInfo, m_nInputs);\r
-    int i;\r
-    FX_DWORD nTotalSamples = 1;\r
-    for (i = 0; i < m_nInputs; i ++) {\r
-        m_pEncodeInfo[i].sizes = pSize->GetInteger(i);\r
-        if (!pSize && i == 0) {\r
-            m_pEncodeInfo[i].sizes = pDict->GetInteger(FX_BSTRC("Size"));\r
-        }\r
-        if (nTotalSamples > 0 && (FX_UINT32)(m_pEncodeInfo[i].sizes) > UINT_MAX / nTotalSamples) {\r
-            return FALSE;\r
-        }\r
-        nTotalSamples *= m_pEncodeInfo[i].sizes;\r
-        if (pEncode) {\r
-            m_pEncodeInfo[i].encode_min = pEncode->GetFloat(i * 2);\r
-            m_pEncodeInfo[i].encode_max = pEncode->GetFloat(i * 2 + 1);\r
-        } else {\r
-            m_pEncodeInfo[i].encode_min = 0;\r
-            if (m_pEncodeInfo[i].sizes == 1) {\r
-                m_pEncodeInfo[i].encode_max = 1;\r
-            } else {\r
-                m_pEncodeInfo[i].encode_max = (FX_FLOAT)m_pEncodeInfo[i].sizes - 1;\r
-            }\r
-        }\r
-    }\r
-    if (nTotalSamples > 0 && m_nBitsPerSample > UINT_MAX / nTotalSamples) {\r
-        return FALSE;\r
-    }\r
-    nTotalSamples *= m_nBitsPerSample;\r
-    if (nTotalSamples > 0 && ((FX_UINT32)m_nOutputs) > UINT_MAX / nTotalSamples) {\r
-        return FALSE;\r
-    }\r
-    nTotalSamples *= m_nOutputs;\r
-    if (nTotalSamples == 0 || m_pSampleStream->GetSize() * 8 < nTotalSamples) {\r
-        return FALSE;\r
-    }\r
-    m_pDecodeInfo = FX_Alloc(SampleDecodeInfo, m_nOutputs);\r
-    for (i = 0; i < m_nOutputs; i ++) {\r
-        if (pDecode) {\r
-            m_pDecodeInfo[i].decode_min = pDecode->GetFloat(2 * i);\r
-            m_pDecodeInfo[i].decode_max = pDecode->GetFloat(2 * i + 1);\r
-        } else {\r
-            m_pDecodeInfo[i].decode_min = m_pRanges[i * 2];\r
-            m_pDecodeInfo[i].decode_max = m_pRanges[i * 2 + 1];\r
-        }\r
-    }\r
-    return TRUE;\r
-}\r
-FX_BOOL CPDF_SampledFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const\r
-{\r
-    int pos = 0;\r
-    CFX_FixedBufGrow<FX_FLOAT, 16> encoded_input_buf(m_nInputs);\r
-    FX_FLOAT* encoded_input = encoded_input_buf;\r
-    CFX_FixedBufGrow<int, 32> int_buf(m_nInputs * 2);\r
-    int* index = int_buf;\r
-    int* blocksize = index + m_nInputs;\r
-    for (int i = 0; i < m_nInputs; i ++) {\r
-        if (i == 0) {\r
-            blocksize[i] = 1;\r
-        } else {\r
-            blocksize[i] = blocksize[i - 1] * m_pEncodeInfo[i - 1].sizes;\r
-        }\r
-        encoded_input[i] = PDF_Interpolate(inputs[i], m_pDomains[i * 2], m_pDomains[i * 2 + 1],\r
-                                           m_pEncodeInfo[i].encode_min, m_pEncodeInfo[i].encode_max);\r
-        index[i] = (int)encoded_input[i];\r
-        if (index[i] < 0) {\r
-            index[i] = 0;\r
-        } else if (index[i] > m_pEncodeInfo[i].sizes - 1) {\r
-            index[i] = m_pEncodeInfo[i].sizes - 1;\r
-        }\r
-        pos += index[i] * blocksize[i];\r
-    }\r
-    int bitpos = pos * m_nBitsPerSample * m_nOutputs;\r
-    FX_LPCBYTE pSampleData = m_pSampleStream->GetData();\r
-    if (pSampleData == NULL) {\r
-        return FALSE;\r
-    }\r
-    for (int j = 0; j < m_nOutputs; j ++) {\r
-        FX_DWORD sample = _GetBits32(pSampleData, bitpos + j * m_nBitsPerSample, m_nBitsPerSample);\r
-        FX_FLOAT encoded = (FX_FLOAT)sample;\r
-        for (int i = 0; i < m_nInputs; i ++) {\r
-            if (index[i] == m_pEncodeInfo[i].sizes - 1) {\r
-                if (index[i] == 0) {\r
-                    encoded = encoded_input[i] * (FX_FLOAT)sample;\r
-                }\r
-            } else {\r
-                int bitpos1 = bitpos + m_nBitsPerSample * m_nOutputs * blocksize[i];\r
-                FX_DWORD sample1 = _GetBits32(pSampleData, bitpos1 + j * m_nBitsPerSample, m_nBitsPerSample);\r
-                encoded += (encoded_input[i] - index[i]) * ((FX_FLOAT)sample1 - (FX_FLOAT)sample);\r
-            }\r
-        }\r
-        results[j] = PDF_Interpolate(encoded, 0, (FX_FLOAT)m_SampleMax,\r
-                                     m_pDecodeInfo[j].decode_min, m_pDecodeInfo[j].decode_max);\r
-    }\r
-    return TRUE;\r
-}\r
-class CPDF_PSFunc : public CPDF_Function\r
-{\r
-public:\r
-    virtual FX_BOOL            v_Init(CPDF_Object* pObj);\r
-    virtual FX_BOOL            v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;\r
-    CPDF_PSEngine m_PS;\r
-};\r
-FX_BOOL CPDF_PSFunc::v_Init(CPDF_Object* pObj)\r
-{\r
-    CPDF_Stream* pStream = (CPDF_Stream*)pObj;\r
-    CPDF_StreamAcc acc;\r
-    acc.LoadAllData(pStream, FALSE);\r
-    return m_PS.Parse((const FX_CHAR*)acc.GetData(), acc.GetSize());\r
-}\r
-FX_BOOL CPDF_PSFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const\r
-{\r
-    CPDF_PSEngine& PS = (CPDF_PSEngine&)m_PS;\r
-    PS.Reset();\r
-    int i;\r
-    for (i = 0; i < m_nInputs; i ++) {\r
-        PS.Push(inputs[i]);\r
-    }\r
-    PS.Execute();\r
-    if (PS.GetStackSize() < m_nOutputs) {\r
-        return FALSE;\r
-    }\r
-    for (i = 0; i < m_nOutputs; i ++) {\r
-        results[m_nOutputs - i - 1] = PS.Pop();\r
-    }\r
-    return TRUE;\r
-}\r
-class CPDF_ExpIntFunc : public CPDF_Function\r
-{\r
-public:\r
-    CPDF_ExpIntFunc();\r
-    virtual ~CPDF_ExpIntFunc();\r
-    virtual FX_BOOL            v_Init(CPDF_Object* pObj);\r
-    virtual FX_BOOL            v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;\r
-    FX_FLOAT   m_Exponent;\r
-    FX_FLOAT*  m_pBeginValues;\r
-    FX_FLOAT*  m_pEndValues;\r
-    int                m_nOrigOutputs;\r
-};\r
-CPDF_ExpIntFunc::CPDF_ExpIntFunc()\r
-{\r
-    m_pBeginValues = NULL;\r
-    m_pEndValues = NULL;\r
-}\r
-CPDF_ExpIntFunc::~CPDF_ExpIntFunc()\r
-{\r
-    if (m_pBeginValues) {\r
-        FX_Free(m_pBeginValues);\r
-    }\r
-    if (m_pEndValues) {\r
-        FX_Free(m_pEndValues);\r
-    }\r
-}\r
-FX_BOOL CPDF_ExpIntFunc::v_Init(CPDF_Object* pObj)\r
-{\r
-    CPDF_Dictionary* pDict = pObj->GetDict();\r
-    if (pDict == NULL) {\r
-        return FALSE;\r
-    }\r
-    CPDF_Array* pArray0 = pDict->GetArray(FX_BSTRC("C0"));\r
-    if (m_nOutputs == 0) {\r
-        m_nOutputs = 1;\r
-        if (pArray0) {\r
-            m_nOutputs = pArray0->GetCount();\r
-        }\r
-    }\r
-    CPDF_Array* pArray1 = pDict->GetArray(FX_BSTRC("C1"));\r
-    m_pBeginValues = FX_Alloc(FX_FLOAT, m_nOutputs * 2);\r
-    m_pEndValues = FX_Alloc(FX_FLOAT, m_nOutputs * 2);\r
-    for (int i = 0; i < m_nOutputs; i ++) {\r
-        m_pBeginValues[i] = pArray0 ? pArray0->GetFloat(i) : 0.0f;\r
-        m_pEndValues[i] = pArray1 ? pArray1->GetFloat(i) : 1.0f;\r
-    }\r
-    m_Exponent = pDict->GetFloat(FX_BSTRC("N"));\r
-    m_nOrigOutputs = m_nOutputs;\r
-    if (m_nOutputs && m_nInputs > INT_MAX / m_nOutputs) {\r
-        return FALSE;\r
-    }\r
-    m_nOutputs *= m_nInputs;\r
-    return TRUE;\r
-}\r
-FX_BOOL CPDF_ExpIntFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const\r
-{\r
-    for (int i = 0; i < m_nInputs; i ++)\r
-        for (int j = 0; j < m_nOrigOutputs; j ++) {\r
-            results[i * m_nOrigOutputs + j] = m_pBeginValues[j] + (FX_FLOAT)FXSYS_pow(inputs[i], m_Exponent) *\r
-                                              (m_pEndValues[j] - m_pBeginValues[j]);\r
-        }\r
-    return TRUE;\r
-}\r
-class CPDF_StitchFunc : public CPDF_Function\r
-{\r
-public:\r
-    CPDF_StitchFunc();\r
-    virtual ~CPDF_StitchFunc();\r
-    virtual FX_BOOL            v_Init(CPDF_Object* pObj);\r
-    virtual FX_BOOL            v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;\r
-    int                        m_nSubs;\r
-    CPDF_Function** m_pSubFunctions;\r
-    FX_FLOAT*  m_pBounds;\r
-    FX_FLOAT*  m_pEncode;\r
-};\r
-CPDF_StitchFunc::CPDF_StitchFunc()\r
-{\r
-    m_nSubs = 0;\r
-    m_pSubFunctions = NULL;\r
-    m_pBounds = NULL;\r
-    m_pEncode = NULL;\r
-}\r
-CPDF_StitchFunc::~CPDF_StitchFunc()\r
-{\r
-    for (int i = 0; i < m_nSubs; i ++)\r
-        if (m_pSubFunctions[i]) {\r
-            delete m_pSubFunctions[i];\r
-        }\r
-    if (m_pSubFunctions) {\r
-        FX_Free(m_pSubFunctions);\r
-    }\r
-    if (m_pBounds) {\r
-        FX_Free(m_pBounds);\r
-    }\r
-    if (m_pEncode) {\r
-        FX_Free(m_pEncode);\r
-    }\r
-}\r
-FX_BOOL CPDF_StitchFunc::v_Init(CPDF_Object* pObj)\r
-{\r
-    CPDF_Dictionary* pDict = pObj->GetDict();\r
-    if (pDict == NULL) {\r
-        return FALSE;\r
-    }\r
-    CPDF_Array* pArray = pDict->GetArray(FX_BSTRC("Functions"));\r
-    if (pArray == NULL) {\r
-        return FALSE;\r
-    }\r
-    m_nSubs = pArray->GetCount();\r
-    if (m_nSubs == 0) {\r
-        return FALSE;\r
-    }\r
-    m_pSubFunctions = FX_Alloc(CPDF_Function*, m_nSubs);\r
-    FXSYS_memset32(m_pSubFunctions, 0, sizeof(CPDF_Function*)*m_nSubs);\r
-    m_nOutputs = 0;\r
-    int i;\r
-    for (i = 0; i < m_nSubs; i ++) {\r
-        CPDF_Object* pSub = pArray->GetElementValue(i);\r
-        if (pSub == pObj) {\r
-            return FALSE;\r
-        }\r
-        m_pSubFunctions[i] = CPDF_Function::Load(pSub);\r
-        if (m_pSubFunctions[i] == NULL) {\r
-            return FALSE;\r
-        }\r
-        if (m_pSubFunctions[i]->CountOutputs() > m_nOutputs) {\r
-            m_nOutputs = m_pSubFunctions[i]->CountOutputs();\r
-        }\r
-    }\r
-    m_pBounds = FX_Alloc(FX_FLOAT, m_nSubs + 1);\r
-    m_pBounds[0] = m_pDomains[0];\r
-    pArray = pDict->GetArray(FX_BSTRC("Bounds"));\r
-    if (pArray == NULL) {\r
-        return FALSE;\r
-    }\r
-    for (i = 0; i < m_nSubs - 1; i ++) {\r
-        m_pBounds[i + 1] = pArray->GetFloat(i);\r
-    }\r
-    m_pBounds[m_nSubs] = m_pDomains[1];\r
-    m_pEncode = FX_Alloc(FX_FLOAT, m_nSubs * 2);\r
-    pArray = pDict->GetArray(FX_BSTRC("Encode"));\r
-    if (pArray == NULL) {\r
-        return FALSE;\r
-    }\r
-    for (i = 0; i < m_nSubs * 2; i ++) {\r
-        m_pEncode[i] = pArray->GetFloat(i);\r
-    }\r
-    return TRUE;\r
-}\r
-FX_BOOL CPDF_StitchFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* outputs) const\r
-{\r
-    FX_FLOAT input = inputs[0];\r
-    int i;\r
-    for (i = 0; i < m_nSubs - 1; i ++)\r
-        if (input < m_pBounds[i + 1]) {\r
-            break;\r
-        }\r
-    if (m_pSubFunctions[i] == NULL) {\r
-        return FALSE;\r
-    }\r
-    input = PDF_Interpolate(input, m_pBounds[i], m_pBounds[i + 1], m_pEncode[i * 2], m_pEncode[i * 2 + 1]);\r
-    int nresults;\r
-    m_pSubFunctions[i]->Call(&input, m_nInputs, outputs, nresults);\r
-    return TRUE;\r
-}\r
-CPDF_Function* CPDF_Function::Load(CPDF_Object* pFuncObj)\r
-{\r
-    if (pFuncObj == NULL) {\r
-        return NULL;\r
-    }\r
-    CPDF_Function* pFunc = NULL;\r
-    int type;\r
-    if (pFuncObj->GetType() == PDFOBJ_STREAM) {\r
-        type = ((CPDF_Stream*)pFuncObj)->GetDict()->GetInteger(FX_BSTRC("FunctionType"));\r
-    } else if (pFuncObj->GetType() == PDFOBJ_DICTIONARY) {\r
-        type = ((CPDF_Dictionary*)pFuncObj)->GetInteger(FX_BSTRC("FunctionType"));\r
-    } else {\r
-        return NULL;\r
-    }\r
-    if (type == 0) {\r
-        pFunc = FX_NEW CPDF_SampledFunc;\r
-    } else if (type == 2) {\r
-        pFunc = FX_NEW CPDF_ExpIntFunc;\r
-    } else if (type == 3) {\r
-        pFunc = FX_NEW CPDF_StitchFunc;\r
-    } else if (type == 4) {\r
-        pFunc = FX_NEW CPDF_PSFunc;\r
-    } else {\r
-        return NULL;\r
-    }\r
-    if (!pFunc->Init(pFuncObj)) {\r
-        delete pFunc;\r
-        return NULL;\r
-    }\r
-    return pFunc;\r
-}\r
-CPDF_Function::CPDF_Function()\r
-{\r
-    m_pDomains = NULL;\r
-    m_pRanges = NULL;\r
-}\r
-CPDF_Function::~CPDF_Function()\r
-{\r
-    if (m_pDomains) {\r
-        FX_Free(m_pDomains);\r
-        m_pDomains = NULL;\r
-    }\r
-    if (m_pRanges) {\r
-        FX_Free(m_pRanges);\r
-        m_pRanges = NULL;\r
-    }\r
-}\r
-FX_BOOL CPDF_Function::Init(CPDF_Object* pObj)\r
-{\r
-    CPDF_Dictionary* pDict;\r
-    if (pObj->GetType() == PDFOBJ_STREAM) {\r
-        pDict = ((CPDF_Stream*)pObj)->GetDict();\r
-    } else {\r
-        pDict = (CPDF_Dictionary*)pObj;\r
-    }\r
-    CPDF_Array* pDomains = pDict->GetArray(FX_BSTRC("Domain"));\r
-    if (pDomains == NULL) {\r
-        return FALSE;\r
-    }\r
-    m_nInputs = pDomains->GetCount() / 2;\r
-    if (m_nInputs == 0) {\r
-        return FALSE;\r
-    }\r
-    m_pDomains = FX_Alloc(FX_FLOAT, m_nInputs * 2);\r
-    for (int i = 0; i < m_nInputs * 2; i ++) {\r
-        m_pDomains[i] = pDomains->GetFloat(i);\r
-    }\r
-    CPDF_Array* pRanges = pDict->GetArray(FX_BSTRC("Range"));\r
-    m_nOutputs = 0;\r
-    if (pRanges) {\r
-        m_nOutputs = pRanges->GetCount() / 2;\r
-        m_pRanges = FX_Alloc(FX_FLOAT, m_nOutputs * 2);\r
-        for (int i = 0; i < m_nOutputs * 2; i ++) {\r
-            m_pRanges[i] = pRanges->GetFloat(i);\r
-        }\r
-    }\r
-    FX_DWORD old_outputs = m_nOutputs;\r
-    FX_BOOL ret = v_Init(pObj);\r
-    if (m_pRanges && m_nOutputs > (int)old_outputs) {\r
-        m_pRanges = FX_Realloc(FX_FLOAT, m_pRanges, m_nOutputs * 2);\r
-        if (m_pRanges) {\r
-            FXSYS_memset32(m_pRanges + (old_outputs * 2), 0, sizeof(FX_FLOAT) * (m_nOutputs - old_outputs) * 2);\r
-        }\r
-    }\r
-    return ret;\r
-}\r
-FX_BOOL CPDF_Function::Call(FX_FLOAT* inputs, int ninputs, FX_FLOAT* results, int& nresults) const\r
-{\r
-    if (m_nInputs != ninputs) {\r
-        return FALSE;\r
-    }\r
-    nresults = m_nOutputs;\r
-    for (int i = 0; i < m_nInputs; i ++) {\r
-        if (inputs[i] < m_pDomains[i * 2]) {\r
-            inputs[i] = m_pDomains[i * 2];\r
-        } else if (inputs[i] > m_pDomains[i * 2 + 1]) {\r
-            inputs[i] = m_pDomains[i * 2] + 1;\r
-        }\r
-    }\r
-    v_Call(inputs, results);\r
-    if (m_pRanges) {\r
-        for (int i = 0; i < m_nOutputs; i ++) {\r
-            if (results[i] < m_pRanges[i * 2]) {\r
-                results[i] = m_pRanges[i * 2];\r
-            } else if (results[i] > m_pRanges[i * 2 + 1]) {\r
-                results[i] = m_pRanges[i * 2 + 1];\r
-            }\r
-        }\r
-    }\r
-    return TRUE;\r
-}\r
+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#include <limits.h>
+
+#include "../../../include/fpdfapi/fpdf_module.h"
+#include "../../../include/fpdfapi/fpdf_page.h"
+#include "../../../include/fxcrt/fx_safe_types.h"
+#include "../../../third_party/base/numerics/safe_conversions_impl.h"
+#include "pageint.h"
+
+class CPDF_PSEngine;
+typedef enum {PSOP_ADD, PSOP_SUB, PSOP_MUL, PSOP_DIV, PSOP_IDIV, PSOP_MOD,
+              PSOP_NEG, PSOP_ABS, PSOP_CEILING, PSOP_FLOOR, PSOP_ROUND, PSOP_TRUNCATE,
+              PSOP_SQRT, PSOP_SIN, PSOP_COS, PSOP_ATAN, PSOP_EXP, PSOP_LN, PSOP_LOG,
+              PSOP_CVI, PSOP_CVR, PSOP_EQ, PSOP_NE, PSOP_GT, PSOP_GE, PSOP_LT, PSOP_LE,
+              PSOP_AND, PSOP_OR, PSOP_XOR, PSOP_NOT, PSOP_BITSHIFT, PSOP_TRUE, PSOP_FALSE,
+              PSOP_IF, PSOP_IFELSE, PSOP_POP, PSOP_EXCH, PSOP_DUP, PSOP_COPY,
+              PSOP_INDEX, PSOP_ROLL, PSOP_PROC, PSOP_CONST
+             } PDF_PSOP;
+class CPDF_PSProc
+{
+public:
+    ~CPDF_PSProc();
+    FX_BOOL    Parse(CPDF_SimpleParser& parser);
+    FX_BOOL    Execute(CPDF_PSEngine* pEngine);
+    CFX_PtrArray               m_Operators;
+};
+#define PSENGINE_STACKSIZE 100
+class CPDF_PSEngine
+{
+public:
+    CPDF_PSEngine();
+    ~CPDF_PSEngine();
+    FX_BOOL    Parse(const FX_CHAR* string, int size);
+    FX_BOOL    Execute()
+    {
+        return m_MainProc.Execute(this);
+    }
+    FX_BOOL    DoOperator(PDF_PSOP op);
+    void       Reset()
+    {
+        m_StackCount = 0;
+    }
+    void       Push(FX_FLOAT value);
+    void       Push(int value)
+    {
+        Push((FX_FLOAT)value);
+    }
+    FX_FLOAT   Pop();
+    int                GetStackSize()
+    {
+        return m_StackCount;
+    }
+private:
+    FX_FLOAT   m_Stack[PSENGINE_STACKSIZE];
+    int                m_StackCount;
+    CPDF_PSProc        m_MainProc;
+};
+CPDF_PSProc::~CPDF_PSProc()
+{
+    int size = m_Operators.GetSize();
+    for (int i = 0; i < size; i ++) {
+        if (m_Operators[i] == (void*)PSOP_PROC) {
+            delete (CPDF_PSProc*)m_Operators[i + 1];
+            i ++;
+        } else if (m_Operators[i] == (void*)PSOP_CONST) {
+            FX_Free((FX_FLOAT*)m_Operators[i + 1]);
+            i ++;
+        }
+    }
+}
+FX_BOOL CPDF_PSProc::Execute(CPDF_PSEngine* pEngine)
+{
+    int size = m_Operators.GetSize();
+    for (int i = 0; i < size; i ++) {
+        PDF_PSOP op = (PDF_PSOP)(uintptr_t)m_Operators[i];
+        if (op == PSOP_PROC) {
+            i ++;
+        } else if (op == PSOP_CONST) {
+            pEngine->Push(*(FX_FLOAT*)m_Operators[i + 1]);
+            i ++;
+        } else if (op == PSOP_IF) {
+            if (i < 2 || m_Operators[i - 2] != (void*)PSOP_PROC) {
+                return FALSE;
+            }
+            if ((int)pEngine->Pop()) {
+                ((CPDF_PSProc*)m_Operators[i - 1])->Execute(pEngine);
+            }
+        } else if (op == PSOP_IFELSE) {
+            if (i < 4 || m_Operators[i - 2] != (void*)PSOP_PROC ||
+                    m_Operators[i - 4] != (void*)PSOP_PROC) {
+                return FALSE;
+            }
+            if ((int)pEngine->Pop()) {
+                ((CPDF_PSProc*)m_Operators[i - 3])->Execute(pEngine);
+            } else {
+                ((CPDF_PSProc*)m_Operators[i - 1])->Execute(pEngine);
+            }
+        } else {
+            pEngine->DoOperator(op);
+        }
+    }
+    return TRUE;
+}
+CPDF_PSEngine::CPDF_PSEngine()
+{
+    m_StackCount = 0;
+}
+CPDF_PSEngine::~CPDF_PSEngine()
+{
+}
+void CPDF_PSEngine::Push(FX_FLOAT v)
+{
+    if (m_StackCount == 100) {
+        return;
+    }
+    m_Stack[m_StackCount++] = v;
+}
+FX_FLOAT CPDF_PSEngine::Pop()
+{
+    if (m_StackCount == 0) {
+        return 0;
+    }
+    return m_Stack[--m_StackCount];
+}
+const struct _PDF_PSOpName {
+    const FX_CHAR* name;
+    PDF_PSOP op;
+} _PDF_PSOpNames[] = {
+    {"add", PSOP_ADD}, {"sub", PSOP_SUB}, {"mul", PSOP_MUL}, {"div", PSOP_DIV},
+    {"idiv", PSOP_IDIV}, {"mod", PSOP_MOD}, {"neg", PSOP_NEG}, {"abs", PSOP_ABS},
+    {"ceiling", PSOP_CEILING}, {"floor", PSOP_FLOOR}, {"round", PSOP_ROUND},
+    {"truncate", PSOP_TRUNCATE}, {"sqrt", PSOP_SQRT}, {"sin", PSOP_SIN},
+    {"cos", PSOP_COS}, {"atan", PSOP_ATAN}, {"exp", PSOP_EXP}, {"ln", PSOP_LN},
+    {"log", PSOP_LOG}, {"cvi", PSOP_CVI}, {"cvr", PSOP_CVR}, {"eq", PSOP_EQ},
+    {"ne", PSOP_NE}, {"gt", PSOP_GT}, {"ge", PSOP_GE}, {"lt", PSOP_LT},
+    {"le", PSOP_LE}, {"and", PSOP_AND}, {"or", PSOP_OR}, {"xor", PSOP_XOR},
+    {"not", PSOP_NOT}, {"bitshift", PSOP_BITSHIFT}, {"true", PSOP_TRUE},
+    {"false", PSOP_FALSE}, {"if", PSOP_IF}, {"ifelse", PSOP_IFELSE},
+    {"pop", PSOP_POP}, {"exch", PSOP_EXCH}, {"dup", PSOP_DUP},
+    {"copy", PSOP_COPY}, {"index", PSOP_INDEX}, {"roll", PSOP_ROLL},
+    {NULL, PSOP_PROC}
+};
+FX_BOOL CPDF_PSEngine::Parse(const FX_CHAR* string, int size)
+{
+    CPDF_SimpleParser parser((uint8_t*)string, size);
+    CFX_ByteStringC word = parser.GetWord();
+    if (word != FX_BSTRC("{")) {
+        return FALSE;
+    }
+    return m_MainProc.Parse(parser);
+}
+FX_BOOL CPDF_PSProc::Parse(CPDF_SimpleParser& parser)
+{
+    while (1) {
+        CFX_ByteStringC word = parser.GetWord();
+        if (word.IsEmpty()) {
+            return FALSE;
+        }
+        if (word == FX_BSTRC("}")) {
+            return TRUE;
+        }
+        if (word == FX_BSTRC("{")) {
+            CPDF_PSProc* pProc = new CPDF_PSProc;
+            m_Operators.Add((void*)PSOP_PROC);
+            m_Operators.Add(pProc);
+            if (!pProc->Parse(parser)) {
+                return FALSE;
+            }
+        } else {
+            int i = 0;
+            while (_PDF_PSOpNames[i].name) {
+                if (word == CFX_ByteStringC(_PDF_PSOpNames[i].name)) {
+                    m_Operators.Add((void*)_PDF_PSOpNames[i].op);
+                    break;
+                }
+                i ++;
+            }
+            if (_PDF_PSOpNames[i].name == NULL) {
+                FX_FLOAT* pd = FX_Alloc(FX_FLOAT, 1);
+                *pd = FX_atof(word);
+                m_Operators.Add((void*)PSOP_CONST);
+                m_Operators.Add(pd);
+            }
+        }
+    }
+}
+#define PI 3.1415926535897932384626433832795f
+FX_BOOL CPDF_PSEngine::DoOperator(PDF_PSOP op)
+{
+    int i1, i2;
+    FX_FLOAT d1, d2;
+    switch (op) {
+        case PSOP_ADD:
+            d1 = Pop();
+            d2 = Pop();
+            Push(d1 + d2);
+            break;
+        case PSOP_SUB:
+            d2 = Pop();
+            d1 = Pop();
+            Push(d1 - d2);
+            break;
+        case PSOP_MUL:
+            d1 = Pop();
+            d2 = Pop();
+            Push(d1 * d2);
+            break;
+        case PSOP_DIV:
+            d2 = Pop();
+            d1 = Pop();
+            Push(d1 / d2);
+            break;
+        case PSOP_IDIV:
+            i2 = (int)Pop();
+            i1 = (int)Pop();
+            Push(i1 / i2);
+            break;
+        case PSOP_MOD:
+            i2 = (int)Pop();
+            i1 = (int)Pop();
+            Push(i1 % i2);
+            break;
+        case PSOP_NEG:
+            d1 = Pop();
+            Push(-d1);
+            break;
+        case PSOP_ABS:
+            d1 = Pop();
+            Push((FX_FLOAT)FXSYS_fabs(d1));
+            break;
+        case PSOP_CEILING:
+            d1 = Pop();
+            Push((FX_FLOAT)FXSYS_ceil(d1));
+            break;
+        case PSOP_FLOOR:
+            d1 = Pop();
+            Push((FX_FLOAT)FXSYS_floor(d1));
+            break;
+        case PSOP_ROUND:
+            d1 = Pop();
+            Push(FXSYS_round(d1));
+            break;
+        case PSOP_TRUNCATE:
+            i1 = (int)Pop();
+            Push(i1);
+            break;
+        case PSOP_SQRT:
+            d1 = Pop();
+            Push((FX_FLOAT)FXSYS_sqrt(d1));
+            break;
+        case PSOP_SIN:
+            d1 = Pop();
+            Push((FX_FLOAT)FXSYS_sin(d1 * PI / 180.0f));
+            break;
+        case PSOP_COS:
+            d1 = Pop();
+            Push((FX_FLOAT)FXSYS_cos(d1 * PI / 180.0f));
+            break;
+        case PSOP_ATAN:
+            d2 = Pop();
+            d1 = Pop();
+            d1 = (FX_FLOAT)(FXSYS_atan2(d1, d2) * 180.0 / PI);
+            if (d1 < 0) {
+                d1 += 360;
+            }
+            Push(d1);
+            break;
+        case PSOP_EXP:
+            d2 = Pop();
+            d1 = Pop();
+            Push((FX_FLOAT)FXSYS_pow(d1, d2));
+            break;
+        case PSOP_LN:
+            d1 = Pop();
+            Push((FX_FLOAT)FXSYS_log(d1));
+            break;
+        case PSOP_LOG:
+            d1 = Pop();
+            Push((FX_FLOAT)FXSYS_log10(d1));
+            break;
+        case PSOP_CVI:
+            i1 = (int)Pop();
+            Push(i1);
+            break;
+        case PSOP_CVR:
+            break;
+        case PSOP_EQ:
+            d2 = Pop();
+            d1 = Pop();
+            Push((int)(d1 == d2));
+            break;
+        case PSOP_NE:
+            d2 = Pop();
+            d1 = Pop();
+            Push((int)(d1 != d2));
+            break;
+        case PSOP_GT:
+            d2 = Pop();
+            d1 = Pop();
+            Push((int)(d1 > d2));
+            break;
+        case PSOP_GE:
+            d2 = Pop();
+            d1 = Pop();
+            Push((int)(d1 >= d2));
+            break;
+        case PSOP_LT:
+            d2 = Pop();
+            d1 = Pop();
+            Push((int)(d1 < d2));
+            break;
+        case PSOP_LE:
+            d2 = Pop();
+            d1 = Pop();
+            Push((int)(d1 <= d2));
+            break;
+        case PSOP_AND:
+            i1 = (int)Pop();
+            i2 = (int)Pop();
+            Push(i1 & i2);
+            break;
+        case PSOP_OR:
+            i1 = (int)Pop();
+            i2 = (int)Pop();
+            Push(i1 | i2);
+            break;
+        case PSOP_XOR:
+            i1 = (int)Pop();
+            i2 = (int)Pop();
+            Push(i1 ^ i2);
+            break;
+        case PSOP_NOT:
+            i1 = (int)Pop();
+            Push((int)!i1);
+            break;
+        case PSOP_BITSHIFT: {
+                int shift = (int)Pop();
+                int i = (int)Pop();
+                if (shift > 0) {
+                    Push(i << shift);
+                } else {
+                    Push(i >> -shift);
+                }
+                break;
+            }
+        case PSOP_TRUE:
+            Push(1);
+            break;
+        case PSOP_FALSE:
+            Push(0);
+            break;
+        case PSOP_POP:
+            Pop();
+            break;
+        case PSOP_EXCH:
+            d2 = Pop();
+            d1 = Pop();
+            Push(d2);
+            Push(d1);
+            break;
+        case PSOP_DUP:
+            d1 = Pop();
+            Push(d1);
+            Push(d1);
+            break;
+        case PSOP_COPY: {
+                int n = (int)Pop();
+                if (n < 0 || n > PSENGINE_STACKSIZE || m_StackCount + n > PSENGINE_STACKSIZE || n > m_StackCount) {
+                    break;
+                }
+                for (int i = 0; i < n; i ++) {
+                    m_Stack[m_StackCount + i] = m_Stack[m_StackCount + i - n];
+                }
+                m_StackCount += n;
+                break;
+            }
+        case PSOP_INDEX: {
+                int n = (int)Pop();
+                if (n < 0 || n >= m_StackCount) {
+                    break;
+                }
+                Push(m_Stack[m_StackCount - n - 1]);
+                break;
+            }
+        case PSOP_ROLL: {
+                int j = (int)Pop();
+                int n = (int)Pop();
+                if (m_StackCount == 0) {
+                    break;
+                }
+                if (n < 0 || n > m_StackCount) {
+                    break;
+                }
+                if (j < 0)
+                    for (int i = 0; i < -j; i ++) {
+                        FX_FLOAT first = m_Stack[m_StackCount - n];
+                        for (int ii = 0; ii < n - 1; ii ++) {
+                            m_Stack[m_StackCount - n + ii] = m_Stack[m_StackCount - n + ii + 1];
+                        }
+                        m_Stack[m_StackCount - 1] = first;
+                    }
+                else
+                    for (int i = 0; i < j; i ++) {
+                        FX_FLOAT last = m_Stack[m_StackCount - 1];
+                        int ii;
+                        for (ii = 0; ii < n - 1; ii ++) {
+                            m_Stack[m_StackCount - ii - 1] = m_Stack[m_StackCount - ii - 2];
+                        }
+                        m_Stack[m_StackCount - ii - 1] = last;
+                    }
+                break;
+            }
+        default:
+            break;
+    }
+    return TRUE;
+}
+static FX_FLOAT PDF_Interpolate(FX_FLOAT x, FX_FLOAT xmin, FX_FLOAT xmax, FX_FLOAT ymin, FX_FLOAT ymax)
+{
+    return ((x - xmin) * (ymax - ymin) / (xmax - xmin)) + ymin;
+}
+static FX_DWORD _GetBits32(const uint8_t* pData, int bitpos, int nbits)
+{
+    int result = 0;
+    for (int i = 0; i < nbits; i ++)
+        if (pData[(bitpos + i) / 8] & (1 << (7 - (bitpos + i) % 8))) {
+            result |= 1 << (nbits - i - 1);
+        }
+    return result;
+}
+typedef struct {
+    FX_FLOAT   encode_max, encode_min;
+    int                        sizes;
+} SampleEncodeInfo;
+typedef struct {
+    FX_FLOAT   decode_max, decode_min;
+} SampleDecodeInfo;
+class CPDF_SampledFunc : public CPDF_Function
+{
+public:
+    CPDF_SampledFunc();
+    virtual ~CPDF_SampledFunc();
+    virtual FX_BOOL            v_Init(CPDF_Object* pObj);
+    virtual FX_BOOL            v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
+    SampleEncodeInfo*  m_pEncodeInfo;
+    SampleDecodeInfo*  m_pDecodeInfo;
+    FX_DWORD   m_nBitsPerSample;
+    FX_DWORD   m_SampleMax;
+    CPDF_StreamAcc*    m_pSampleStream;
+};
+CPDF_SampledFunc::CPDF_SampledFunc()
+{
+    m_pSampleStream = NULL;
+    m_pEncodeInfo = NULL;
+    m_pDecodeInfo = NULL;
+}
+CPDF_SampledFunc::~CPDF_SampledFunc()
+{
+    delete m_pSampleStream;
+    if (m_pEncodeInfo) {
+        FX_Free(m_pEncodeInfo);
+    }
+    if (m_pDecodeInfo) {
+        FX_Free(m_pDecodeInfo);
+    }
+}
+FX_BOOL CPDF_SampledFunc::v_Init(CPDF_Object* pObj)
+{
+    if (pObj->GetType() != PDFOBJ_STREAM) {
+        return FALSE;
+    }
+    CPDF_Stream* pStream = (CPDF_Stream*)pObj;
+    CPDF_Dictionary* pDict = pStream->GetDict();
+    CPDF_Array* pSize = pDict->GetArray(FX_BSTRC("Size"));
+    CPDF_Array* pEncode = pDict->GetArray(FX_BSTRC("Encode"));
+    CPDF_Array* pDecode = pDict->GetArray(FX_BSTRC("Decode"));
+    m_nBitsPerSample = pDict->GetInteger(FX_BSTRC("BitsPerSample"));
+    if (m_nBitsPerSample > 32) {
+        return FALSE;
+    }
+    m_SampleMax = 0xffffffff >> (32 - m_nBitsPerSample);
+    m_pSampleStream = new CPDF_StreamAcc;
+    m_pSampleStream->LoadAllData(pStream, FALSE);
+    m_pEncodeInfo = FX_Alloc(SampleEncodeInfo, m_nInputs);
+    FX_SAFE_DWORD nTotalSampleBits = 1;
+    for (int i = 0; i < m_nInputs; i ++) {
+        m_pEncodeInfo[i].sizes = pSize ? pSize->GetInteger(i) : 0;
+        if (!pSize && i == 0) {
+            m_pEncodeInfo[i].sizes = pDict->GetInteger(FX_BSTRC("Size"));
+        }
+        nTotalSampleBits *= m_pEncodeInfo[i].sizes;
+        if (pEncode) {
+            m_pEncodeInfo[i].encode_min = pEncode->GetFloat(i * 2);
+            m_pEncodeInfo[i].encode_max = pEncode->GetFloat(i * 2 + 1);
+        } else {
+            m_pEncodeInfo[i].encode_min = 0;
+            if (m_pEncodeInfo[i].sizes == 1) {
+                m_pEncodeInfo[i].encode_max = 1;
+            } else {
+                m_pEncodeInfo[i].encode_max = (FX_FLOAT)m_pEncodeInfo[i].sizes - 1;
+            }
+        }
+    }
+    nTotalSampleBits *= m_nBitsPerSample;
+    nTotalSampleBits *= m_nOutputs;
+    FX_SAFE_DWORD nTotalSampleBytes = nTotalSampleBits;
+    nTotalSampleBytes += 7;
+    nTotalSampleBytes /= 8;
+    if (!nTotalSampleBytes.IsValid() ||
+        nTotalSampleBytes.ValueOrDie() == 0 ||
+        nTotalSampleBytes.ValueOrDie() > m_pSampleStream->GetSize()) {
+        return FALSE;
+    }
+    m_pDecodeInfo = FX_Alloc(SampleDecodeInfo, m_nOutputs);
+    for (int i = 0; i < m_nOutputs; i ++) {
+        if (pDecode) {
+            m_pDecodeInfo[i].decode_min = pDecode->GetFloat(2 * i);
+            m_pDecodeInfo[i].decode_max = pDecode->GetFloat(2 * i + 1);
+        } else {
+            m_pDecodeInfo[i].decode_min = m_pRanges[i * 2];
+            m_pDecodeInfo[i].decode_max = m_pRanges[i * 2 + 1];
+        }
+    }
+    return TRUE;
+}
+FX_BOOL CPDF_SampledFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const
+{
+    int pos = 0;
+    CFX_FixedBufGrow<FX_FLOAT, 16> encoded_input_buf(m_nInputs);
+    FX_FLOAT* encoded_input = encoded_input_buf;
+    CFX_FixedBufGrow<int, 32> int_buf(m_nInputs * 2);
+    int* index = int_buf;
+    int* blocksize = index + m_nInputs;
+    for (int i = 0; i < m_nInputs; i ++) {
+        if (i == 0) {
+            blocksize[i] = 1;
+        } else {
+            blocksize[i] = blocksize[i - 1] * m_pEncodeInfo[i - 1].sizes;
+        }
+        encoded_input[i] = PDF_Interpolate(inputs[i], m_pDomains[i * 2], m_pDomains[i * 2 + 1],
+                                           m_pEncodeInfo[i].encode_min, m_pEncodeInfo[i].encode_max);
+        index[i] = (int)encoded_input[i];
+        if (index[i] < 0) {
+            index[i] = 0;
+        } else if (index[i] > m_pEncodeInfo[i].sizes - 1) {
+            index[i] = m_pEncodeInfo[i].sizes - 1;
+        }
+        pos += index[i] * blocksize[i];
+    }
+    FX_SAFE_INT32 bits_to_output = m_nOutputs;
+    bits_to_output *= m_nBitsPerSample;
+    if (!bits_to_output.IsValid()) {
+        return FALSE;
+    }
+    FX_SAFE_INT32 bitpos = pos;
+    bitpos *= bits_to_output.ValueOrDie();
+    if (!bitpos.IsValid()) {
+        return FALSE;
+    }
+    FX_SAFE_INT32 range_check = bitpos;
+    range_check += bits_to_output.ValueOrDie();
+    if (!range_check.IsValid()) {
+        return FALSE;
+    }
+    const uint8_t* pSampleData = m_pSampleStream->GetData();
+    if (!pSampleData) {
+        return FALSE;
+    }
+    for (int j = 0; j < m_nOutputs; j ++) {
+        FX_DWORD sample = _GetBits32(pSampleData, bitpos.ValueOrDie() + j * m_nBitsPerSample, m_nBitsPerSample);
+        FX_FLOAT encoded = (FX_FLOAT)sample;
+        for (int i = 0; i < m_nInputs; i ++) {
+            if (index[i] == m_pEncodeInfo[i].sizes - 1) {
+                if (index[i] == 0) {
+                    encoded = encoded_input[i] * (FX_FLOAT)sample;
+                }
+            } else {
+                FX_SAFE_INT32 bitpos2 = blocksize[i];
+                bitpos2 += pos;
+                bitpos2 *= m_nOutputs;
+                bitpos2 += j;
+                bitpos2 *= m_nBitsPerSample;
+                if (!bitpos2.IsValid()) {
+                    return FALSE;
+                }
+                FX_DWORD sample1 = _GetBits32(pSampleData, bitpos2.ValueOrDie(), m_nBitsPerSample);
+                encoded += (encoded_input[i] - index[i]) * ((FX_FLOAT)sample1 - (FX_FLOAT)sample);
+            }
+        }
+        results[j] = PDF_Interpolate(encoded, 0, (FX_FLOAT)m_SampleMax,
+                                     m_pDecodeInfo[j].decode_min, m_pDecodeInfo[j].decode_max);
+    }
+    return TRUE;
+}
+class CPDF_PSFunc : public CPDF_Function
+{
+public:
+    virtual FX_BOOL            v_Init(CPDF_Object* pObj);
+    virtual FX_BOOL            v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
+    CPDF_PSEngine m_PS;
+};
+FX_BOOL CPDF_PSFunc::v_Init(CPDF_Object* pObj)
+{
+    CPDF_Stream* pStream = (CPDF_Stream*)pObj;
+    CPDF_StreamAcc acc;
+    acc.LoadAllData(pStream, FALSE);
+    return m_PS.Parse((const FX_CHAR*)acc.GetData(), acc.GetSize());
+}
+FX_BOOL CPDF_PSFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const
+{
+    CPDF_PSEngine& PS = (CPDF_PSEngine&)m_PS;
+    PS.Reset();
+    int i;
+    for (i = 0; i < m_nInputs; i ++) {
+        PS.Push(inputs[i]);
+    }
+    PS.Execute();
+    if (PS.GetStackSize() < m_nOutputs) {
+        return FALSE;
+    }
+    for (i = 0; i < m_nOutputs; i ++) {
+        results[m_nOutputs - i - 1] = PS.Pop();
+    }
+    return TRUE;
+}
+class CPDF_ExpIntFunc : public CPDF_Function
+{
+public:
+    CPDF_ExpIntFunc();
+    virtual ~CPDF_ExpIntFunc();
+    virtual FX_BOOL            v_Init(CPDF_Object* pObj);
+    virtual FX_BOOL            v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
+    FX_FLOAT   m_Exponent;
+    FX_FLOAT*  m_pBeginValues;
+    FX_FLOAT*  m_pEndValues;
+    int                m_nOrigOutputs;
+};
+CPDF_ExpIntFunc::CPDF_ExpIntFunc()
+{
+    m_pBeginValues = NULL;
+    m_pEndValues = NULL;
+}
+CPDF_ExpIntFunc::~CPDF_ExpIntFunc()
+{
+    if (m_pBeginValues) {
+        FX_Free(m_pBeginValues);
+    }
+    if (m_pEndValues) {
+        FX_Free(m_pEndValues);
+    }
+}
+FX_BOOL CPDF_ExpIntFunc::v_Init(CPDF_Object* pObj)
+{
+    CPDF_Dictionary* pDict = pObj->GetDict();
+    if (pDict == NULL) {
+        return FALSE;
+    }
+    CPDF_Array* pArray0 = pDict->GetArray(FX_BSTRC("C0"));
+    if (m_nOutputs == 0) {
+        m_nOutputs = 1;
+        if (pArray0) {
+            m_nOutputs = pArray0->GetCount();
+        }
+    }
+    CPDF_Array* pArray1 = pDict->GetArray(FX_BSTRC("C1"));
+    m_pBeginValues = FX_Alloc2D(FX_FLOAT, m_nOutputs, 2);
+    m_pEndValues = FX_Alloc2D(FX_FLOAT, m_nOutputs, 2);
+    for (int i = 0; i < m_nOutputs; i ++) {
+        m_pBeginValues[i] = pArray0 ? pArray0->GetFloat(i) : 0.0f;
+        m_pEndValues[i] = pArray1 ? pArray1->GetFloat(i) : 1.0f;
+    }
+    m_Exponent = pDict->GetFloat(FX_BSTRC("N"));
+    m_nOrigOutputs = m_nOutputs;
+    if (m_nOutputs && m_nInputs > INT_MAX / m_nOutputs) {
+        return FALSE;
+    }
+    m_nOutputs *= m_nInputs;
+    return TRUE;
+}
+FX_BOOL CPDF_ExpIntFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const
+{
+    for (int i = 0; i < m_nInputs; i ++)
+        for (int j = 0; j < m_nOrigOutputs; j ++) {
+            results[i * m_nOrigOutputs + j] = m_pBeginValues[j] + (FX_FLOAT)FXSYS_pow(inputs[i], m_Exponent) *
+                                              (m_pEndValues[j] - m_pBeginValues[j]);
+        }
+    return TRUE;
+}
+class CPDF_StitchFunc : public CPDF_Function
+{
+public:
+    CPDF_StitchFunc();
+    virtual ~CPDF_StitchFunc();
+    virtual FX_BOOL            v_Init(CPDF_Object* pObj);
+    virtual FX_BOOL            v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
+    int                        m_nSubs;
+    CPDF_Function** m_pSubFunctions;
+    FX_FLOAT*  m_pBounds;
+    FX_FLOAT*  m_pEncode;
+};
+CPDF_StitchFunc::CPDF_StitchFunc()
+{
+    m_nSubs = 0;
+    m_pSubFunctions = NULL;
+    m_pBounds = NULL;
+    m_pEncode = NULL;
+}
+CPDF_StitchFunc::~CPDF_StitchFunc()
+{
+    for (int i = 0; i < m_nSubs; i ++)
+        delete m_pSubFunctions[i];
+    if (m_pSubFunctions) {
+        FX_Free(m_pSubFunctions);
+    }
+    if (m_pBounds) {
+        FX_Free(m_pBounds);
+    }
+    if (m_pEncode) {
+        FX_Free(m_pEncode);
+    }
+}
+FX_BOOL CPDF_StitchFunc::v_Init(CPDF_Object* pObj)
+{
+    CPDF_Dictionary* pDict = pObj->GetDict();
+    if (pDict == NULL) {
+        return FALSE;
+    }
+    CPDF_Array* pArray = pDict->GetArray(FX_BSTRC("Functions"));
+    if (pArray == NULL) {
+        return FALSE;
+    }
+    m_nSubs = pArray->GetCount();
+    if (m_nSubs == 0) {
+        return FALSE;
+    }
+    m_pSubFunctions = FX_Alloc(CPDF_Function*, m_nSubs);
+    m_nOutputs = 0;
+    int i;
+    for (i = 0; i < m_nSubs; i ++) {
+        CPDF_Object* pSub = pArray->GetElementValue(i);
+        if (pSub == pObj) {
+            return FALSE;
+        }
+        m_pSubFunctions[i] = CPDF_Function::Load(pSub);
+        if (m_pSubFunctions[i] == NULL) {
+            return FALSE;
+        }
+        if (m_pSubFunctions[i]->CountOutputs() > m_nOutputs) {
+            m_nOutputs = m_pSubFunctions[i]->CountOutputs();
+        }
+    }
+    m_pBounds = FX_Alloc(FX_FLOAT, m_nSubs + 1);
+    m_pBounds[0] = m_pDomains[0];
+    pArray = pDict->GetArray(FX_BSTRC("Bounds"));
+    if (pArray == NULL) {
+        return FALSE;
+    }
+    for (i = 0; i < m_nSubs - 1; i ++) {
+        m_pBounds[i + 1] = pArray->GetFloat(i);
+    }
+    m_pBounds[m_nSubs] = m_pDomains[1];
+    m_pEncode = FX_Alloc2D(FX_FLOAT, m_nSubs, 2);
+    pArray = pDict->GetArray(FX_BSTRC("Encode"));
+    if (pArray == NULL) {
+        return FALSE;
+    }
+    for (i = 0; i < m_nSubs * 2; i ++) {
+        m_pEncode[i] = pArray->GetFloat(i);
+    }
+    return TRUE;
+}
+FX_BOOL CPDF_StitchFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* outputs) const
+{
+    FX_FLOAT input = inputs[0];
+    int i;
+    for (i = 0; i < m_nSubs - 1; i ++)
+        if (input < m_pBounds[i + 1]) {
+            break;
+        }
+    if (m_pSubFunctions[i] == NULL) {
+        return FALSE;
+    }
+    input = PDF_Interpolate(input, m_pBounds[i], m_pBounds[i + 1], m_pEncode[i * 2], m_pEncode[i * 2 + 1]);
+    int nresults;
+    m_pSubFunctions[i]->Call(&input, m_nInputs, outputs, nresults);
+    return TRUE;
+}
+CPDF_Function* CPDF_Function::Load(CPDF_Object* pFuncObj)
+{
+    if (pFuncObj == NULL) {
+        return NULL;
+    }
+    CPDF_Function* pFunc = NULL;
+    int type;
+    if (pFuncObj->GetType() == PDFOBJ_STREAM) {
+        type = ((CPDF_Stream*)pFuncObj)->GetDict()->GetInteger(FX_BSTRC("FunctionType"));
+    } else if (pFuncObj->GetType() == PDFOBJ_DICTIONARY) {
+        type = ((CPDF_Dictionary*)pFuncObj)->GetInteger(FX_BSTRC("FunctionType"));
+    } else {
+        return NULL;
+    }
+    if (type == 0) {
+        pFunc = new CPDF_SampledFunc;
+    } else if (type == 2) {
+        pFunc = new CPDF_ExpIntFunc;
+    } else if (type == 3) {
+        pFunc = new CPDF_StitchFunc;
+    } else if (type == 4) {
+        pFunc = new CPDF_PSFunc;
+    } else {
+        return NULL;
+    }
+    if (!pFunc->Init(pFuncObj)) {
+        delete pFunc;
+        return NULL;
+    }
+    return pFunc;
+}
+CPDF_Function::CPDF_Function()
+{
+    m_pDomains = NULL;
+    m_pRanges = NULL;
+}
+CPDF_Function::~CPDF_Function()
+{
+    if (m_pDomains) {
+        FX_Free(m_pDomains);
+        m_pDomains = NULL;
+    }
+    if (m_pRanges) {
+        FX_Free(m_pRanges);
+        m_pRanges = NULL;
+    }
+}
+FX_BOOL CPDF_Function::Init(CPDF_Object* pObj)
+{
+    CPDF_Dictionary* pDict;
+    if (pObj->GetType() == PDFOBJ_STREAM) {
+        pDict = ((CPDF_Stream*)pObj)->GetDict();
+    } else {
+        pDict = (CPDF_Dictionary*)pObj;
+    }
+    CPDF_Array* pDomains = pDict->GetArray(FX_BSTRC("Domain"));
+    if (pDomains == NULL) {
+        return FALSE;
+    }
+    m_nInputs = pDomains->GetCount() / 2;
+    if (m_nInputs == 0) {
+        return FALSE;
+    }
+    m_pDomains = FX_Alloc2D(FX_FLOAT, m_nInputs, 2);
+    for (int i = 0; i < m_nInputs * 2; i ++) {
+        m_pDomains[i] = pDomains->GetFloat(i);
+    }
+    CPDF_Array* pRanges = pDict->GetArray(FX_BSTRC("Range"));
+    m_nOutputs = 0;
+    if (pRanges) {
+        m_nOutputs = pRanges->GetCount() / 2;
+        m_pRanges = FX_Alloc2D(FX_FLOAT, m_nOutputs, 2);
+        for (int i = 0; i < m_nOutputs * 2; i ++) {
+            m_pRanges[i] = pRanges->GetFloat(i);
+        }
+    }
+    FX_DWORD old_outputs = m_nOutputs;
+    if (!v_Init(pObj)) {
+        return FALSE;
+    }
+    if (m_pRanges && m_nOutputs > (int)old_outputs) {
+        m_pRanges = FX_Realloc(FX_FLOAT, m_pRanges, m_nOutputs * 2);
+        if (m_pRanges) {
+            FXSYS_memset(m_pRanges + (old_outputs * 2), 0, sizeof(FX_FLOAT) * (m_nOutputs - old_outputs) * 2);
+        }
+    }
+    return TRUE;
+}
+FX_BOOL CPDF_Function::Call(FX_FLOAT* inputs, int ninputs, FX_FLOAT* results, int& nresults) const
+{
+    if (m_nInputs != ninputs) {
+        return FALSE;
+    }
+    nresults = m_nOutputs;
+    for (int i = 0; i < m_nInputs; i ++) {
+        if (inputs[i] < m_pDomains[i * 2]) {
+            inputs[i] = m_pDomains[i * 2];
+        } else if (inputs[i] > m_pDomains[i * 2 + 1]) {
+            inputs[i] = m_pDomains[i * 2] + 1;
+        }
+    }
+    v_Call(inputs, results);
+    if (m_pRanges) {
+        for (int i = 0; i < m_nOutputs; i ++) {
+            if (results[i] < m_pRanges[i * 2]) {
+                results[i] = m_pRanges[i * 2];
+            } else if (results[i] > m_pRanges[i * 2 + 1]) {
+                results[i] = m_pRanges[i * 2 + 1];
+            }
+        }
+    }
+    return TRUE;
+}