core/src/fpdfapi/fpdf_page/fpdf_page_func.cpp

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