Index: core/fpdfapi/fpdf_page/fpdf_page_func.cpp |
diff --git a/core/fpdfapi/fpdf_page/fpdf_page_func.cpp b/core/fpdfapi/fpdf_page/fpdf_page_func.cpp |
deleted file mode 100644 |
index eb487577c8508b1c178bc169a83f899ce5a2022d..0000000000000000000000000000000000000000 |
--- a/core/fpdfapi/fpdf_page/fpdf_page_func.cpp |
+++ /dev/null |
@@ -1,846 +0,0 @@ |
-// 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 "core/fpdfapi/fpdf_page/pageint.h" |
- |
-#include <limits.h> |
- |
-#include <algorithm> |
-#include <memory> |
-#include <utility> |
-#include <vector> |
- |
-#include "core/fpdfapi/fpdf_page/cpdf_psengine.h" |
-#include "core/fpdfapi/fpdf_parser/cpdf_array.h" |
-#include "core/fpdfapi/fpdf_parser/cpdf_dictionary.h" |
-#include "core/fpdfapi/fpdf_parser/cpdf_simple_parser.h" |
-#include "core/fpdfapi/fpdf_parser/cpdf_stream.h" |
-#include "core/fpdfapi/fpdf_parser/cpdf_stream_acc.h" |
-#include "core/fxcrt/fx_safe_types.h" |
-#include "third_party/base/numerics/safe_conversions_impl.h" |
- |
-class CPDF_PSOP { |
- public: |
- explicit CPDF_PSOP(PDF_PSOP op) : m_op(op), m_value(0) { |
- ASSERT(m_op != PSOP_CONST); |
- ASSERT(m_op != PSOP_PROC); |
- } |
- explicit CPDF_PSOP(FX_FLOAT value) : m_op(PSOP_CONST), m_value(value) {} |
- explicit CPDF_PSOP(std::unique_ptr<CPDF_PSProc> proc) |
- : m_op(PSOP_PROC), m_value(0), m_proc(std::move(proc)) {} |
- |
- FX_FLOAT GetFloatValue() const { |
- if (m_op == PSOP_CONST) |
- return m_value; |
- |
- ASSERT(false); |
- return 0; |
- } |
- CPDF_PSProc* GetProc() const { |
- if (m_op == PSOP_PROC) |
- return m_proc.get(); |
- ASSERT(false); |
- return nullptr; |
- } |
- |
- PDF_PSOP GetOp() const { return m_op; } |
- |
- private: |
- const PDF_PSOP m_op; |
- const FX_FLOAT m_value; |
- std::unique_ptr<CPDF_PSProc> m_proc; |
-}; |
- |
-FX_BOOL CPDF_PSEngine::Execute() { |
- return m_MainProc.Execute(this); |
-} |
- |
-CPDF_PSProc::CPDF_PSProc() {} |
-CPDF_PSProc::~CPDF_PSProc() {} |
- |
-FX_BOOL CPDF_PSProc::Execute(CPDF_PSEngine* pEngine) { |
- for (size_t i = 0; i < m_Operators.size(); ++i) { |
- const PDF_PSOP op = m_Operators[i]->GetOp(); |
- if (op == PSOP_PROC) |
- continue; |
- |
- if (op == PSOP_CONST) { |
- pEngine->Push(m_Operators[i]->GetFloatValue()); |
- continue; |
- } |
- |
- if (op == PSOP_IF) { |
- if (i == 0 || m_Operators[i - 1]->GetOp() != PSOP_PROC) |
- return FALSE; |
- |
- if (static_cast<int>(pEngine->Pop())) |
- m_Operators[i - 1]->GetProc()->Execute(pEngine); |
- } else if (op == PSOP_IFELSE) { |
- if (i < 2 || m_Operators[i - 1]->GetOp() != PSOP_PROC || |
- m_Operators[i - 2]->GetOp() != PSOP_PROC) { |
- return FALSE; |
- } |
- size_t offset = static_cast<int>(pEngine->Pop()) ? 2 : 1; |
- m_Operators[i - offset]->GetProc()->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 == PSENGINE_STACKSIZE) { |
- 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}}; |
- |
-FX_BOOL CPDF_PSEngine::Parse(const FX_CHAR* str, int size) { |
- CPDF_SimpleParser parser((uint8_t*)str, size); |
- CFX_ByteStringC word = parser.GetWord(); |
- if (word != "{") { |
- return FALSE; |
- } |
- return m_MainProc.Parse(&parser, 0); |
-} |
- |
-FX_BOOL CPDF_PSProc::Parse(CPDF_SimpleParser* parser, int depth) { |
- if (depth > kMaxDepth) |
- return FALSE; |
- |
- while (1) { |
- CFX_ByteStringC word = parser->GetWord(); |
- if (word.IsEmpty()) { |
- return FALSE; |
- } |
- if (word == "}") { |
- return TRUE; |
- } |
- if (word == "{") { |
- std::unique_ptr<CPDF_PSProc> proc(new CPDF_PSProc); |
- std::unique_ptr<CPDF_PSOP> op(new CPDF_PSOP(std::move(proc))); |
- m_Operators.push_back(std::move(op)); |
- if (!m_Operators.back()->GetProc()->Parse(parser, depth + 1)) { |
- return FALSE; |
- } |
- } else { |
- bool found = false; |
- for (const PDF_PSOpName& op_name : PDF_PSOpNames) { |
- if (word == CFX_ByteStringC(op_name.name)) { |
- std::unique_ptr<CPDF_PSOP> op(new CPDF_PSOP(op_name.op)); |
- m_Operators.push_back(std::move(op)); |
- found = true; |
- break; |
- } |
- } |
- if (!found) { |
- std::unique_ptr<CPDF_PSOP> op(new CPDF_PSOP(FX_atof(word))); |
- m_Operators.push_back(std::move(op)); |
- } |
- } |
- } |
-} |
- |
-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(i2 ? i1 / i2 : 0); |
- break; |
- case PSOP_MOD: |
- i2 = (int)Pop(); |
- i1 = (int)Pop(); |
- Push(i2 ? i1 % i2 : 0); |
- 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 * FX_PI / 180.0f)); |
- break; |
- case PSOP_COS: |
- d1 = Pop(); |
- Push((FX_FLOAT)FXSYS_cos(d1 * FX_PI / 180.0f)); |
- break; |
- case PSOP_ATAN: |
- d2 = Pop(); |
- d1 = Pop(); |
- d1 = (FX_FLOAT)(FXSYS_atan2(d1, d2) * 180.0 / FX_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 = static_cast<int>(Pop()); |
- if (n < 0 || m_StackCount + n > PSENGINE_STACKSIZE || |
- n > static_cast<int>(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 = static_cast<int>(Pop()); |
- if (n < 0 || n >= static_cast<int>(m_StackCount)) |
- break; |
- Push(m_Stack[m_StackCount - n - 1]); |
- break; |
- } |
- case PSOP_ROLL: { |
- int j = static_cast<int>(Pop()); |
- int n = static_cast<int>(Pop()); |
- if (m_StackCount == 0) |
- break; |
- if (n < 0 || n > static_cast<int>(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; |
-} |
- |
-// See PDF Reference 1.7, page 170, table 3.36. |
-bool IsValidBitsPerSample(uint32_t x) { |
- switch (x) { |
- case 1: |
- case 2: |
- case 4: |
- case 8: |
- case 12: |
- case 16: |
- case 24: |
- case 32: |
- return true; |
- default: |
- return false; |
- } |
-} |
- |
-// See PDF Reference 1.7, page 170. |
-FX_FLOAT PDF_Interpolate(FX_FLOAT x, |
- FX_FLOAT xmin, |
- FX_FLOAT xmax, |
- FX_FLOAT ymin, |
- FX_FLOAT ymax) { |
- FX_FLOAT divisor = xmax - xmin; |
- return ymin + (divisor ? (x - xmin) * (ymax - ymin) / divisor : 0); |
-} |
- |
-class CPDF_PSFunc : public CPDF_Function { |
- public: |
- CPDF_PSFunc() : CPDF_Function(Type::kType4PostScript) {} |
- ~CPDF_PSFunc() override {} |
- |
- // CPDF_Function |
- FX_BOOL v_Init(CPDF_Object* pObj) override; |
- FX_BOOL v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const override; |
- |
- private: |
- CPDF_PSEngine m_PS; |
-}; |
- |
-FX_BOOL CPDF_PSFunc::v_Init(CPDF_Object* pObj) { |
- CPDF_StreamAcc acc; |
- acc.LoadAllData(pObj->AsStream(), FALSE); |
- return m_PS.Parse(reinterpret_cast<const FX_CHAR*>(acc.GetData()), |
- acc.GetSize()); |
-} |
- |
-FX_BOOL CPDF_PSFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const { |
- CPDF_PSEngine& PS = const_cast<CPDF_PSEngine&>(m_PS); |
- PS.Reset(); |
- for (uint32_t i = 0; i < m_nInputs; i++) |
- PS.Push(inputs[i]); |
- PS.Execute(); |
- if (PS.GetStackSize() < m_nOutputs) |
- return FALSE; |
- for (uint32_t i = 0; i < m_nOutputs; i++) |
- results[m_nOutputs - i - 1] = PS.Pop(); |
- return TRUE; |
-} |
- |
- |
-CPDF_SampledFunc::CPDF_SampledFunc() : CPDF_Function(Type::kType0Sampled) {} |
- |
-CPDF_SampledFunc::~CPDF_SampledFunc() {} |
- |
-FX_BOOL CPDF_SampledFunc::v_Init(CPDF_Object* pObj) { |
- CPDF_Stream* pStream = pObj->AsStream(); |
- if (!pStream) |
- return false; |
- |
- CPDF_Dictionary* pDict = pStream->GetDict(); |
- CPDF_Array* pSize = pDict->GetArrayFor("Size"); |
- CPDF_Array* pEncode = pDict->GetArrayFor("Encode"); |
- CPDF_Array* pDecode = pDict->GetArrayFor("Decode"); |
- m_nBitsPerSample = pDict->GetIntegerFor("BitsPerSample"); |
- if (!IsValidBitsPerSample(m_nBitsPerSample)) |
- return FALSE; |
- |
- m_SampleMax = 0xffffffff >> (32 - m_nBitsPerSample); |
- m_pSampleStream.reset(new CPDF_StreamAcc); |
- m_pSampleStream->LoadAllData(pStream, FALSE); |
- FX_SAFE_UINT32 nTotalSampleBits = 1; |
- m_EncodeInfo.resize(m_nInputs); |
- for (uint32_t i = 0; i < m_nInputs; i++) { |
- m_EncodeInfo[i].sizes = pSize ? pSize->GetIntegerAt(i) : 0; |
- if (!pSize && i == 0) |
- m_EncodeInfo[i].sizes = pDict->GetIntegerFor("Size"); |
- nTotalSampleBits *= m_EncodeInfo[i].sizes; |
- if (pEncode) { |
- m_EncodeInfo[i].encode_min = pEncode->GetFloatAt(i * 2); |
- m_EncodeInfo[i].encode_max = pEncode->GetFloatAt(i * 2 + 1); |
- } else { |
- m_EncodeInfo[i].encode_min = 0; |
- m_EncodeInfo[i].encode_max = |
- m_EncodeInfo[i].sizes == 1 ? 1 : (FX_FLOAT)m_EncodeInfo[i].sizes - 1; |
- } |
- } |
- nTotalSampleBits *= m_nBitsPerSample; |
- nTotalSampleBits *= m_nOutputs; |
- FX_SAFE_UINT32 nTotalSampleBytes = nTotalSampleBits; |
- nTotalSampleBytes += 7; |
- nTotalSampleBytes /= 8; |
- if (!nTotalSampleBytes.IsValid() || nTotalSampleBytes.ValueOrDie() == 0 || |
- nTotalSampleBytes.ValueOrDie() > m_pSampleStream->GetSize()) { |
- return FALSE; |
- } |
- m_DecodeInfo.resize(m_nOutputs); |
- for (uint32_t i = 0; i < m_nOutputs; i++) { |
- if (pDecode) { |
- m_DecodeInfo[i].decode_min = pDecode->GetFloatAt(2 * i); |
- m_DecodeInfo[i].decode_max = pDecode->GetFloatAt(2 * i + 1); |
- } else { |
- m_DecodeInfo[i].decode_min = m_pRanges[i * 2]; |
- m_DecodeInfo[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<uint32_t, 32> int_buf(m_nInputs * 2); |
- uint32_t* index = int_buf; |
- uint32_t* blocksize = index + m_nInputs; |
- for (uint32_t i = 0; i < m_nInputs; i++) { |
- if (i == 0) |
- blocksize[i] = 1; |
- else |
- blocksize[i] = blocksize[i - 1] * m_EncodeInfo[i - 1].sizes; |
- encoded_input[i] = |
- PDF_Interpolate(inputs[i], m_pDomains[i * 2], m_pDomains[i * 2 + 1], |
- m_EncodeInfo[i].encode_min, m_EncodeInfo[i].encode_max); |
- index[i] = std::min((uint32_t)std::max(0.f, encoded_input[i]), |
- m_EncodeInfo[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 (uint32_t j = 0; j < m_nOutputs; j++) { |
- uint32_t sample = |
- GetBits32(pSampleData, bitpos.ValueOrDie() + j * m_nBitsPerSample, |
- m_nBitsPerSample); |
- FX_FLOAT encoded = (FX_FLOAT)sample; |
- for (uint32_t i = 0; i < m_nInputs; i++) { |
- if (index[i] == m_EncodeInfo[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; |
- uint32_t 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_DecodeInfo[j].decode_min, m_DecodeInfo[j].decode_max); |
- } |
- return TRUE; |
-} |
- |
-CPDF_ExpIntFunc::CPDF_ExpIntFunc() |
- : CPDF_Function(Type::kType2ExpotentialInterpolation), |
- m_pBeginValues(nullptr), |
- m_pEndValues(nullptr) {} |
- |
-CPDF_ExpIntFunc::~CPDF_ExpIntFunc() { |
- FX_Free(m_pBeginValues); |
- FX_Free(m_pEndValues); |
-} |
-FX_BOOL CPDF_ExpIntFunc::v_Init(CPDF_Object* pObj) { |
- CPDF_Dictionary* pDict = pObj->GetDict(); |
- if (!pDict) { |
- return FALSE; |
- } |
- CPDF_Array* pArray0 = pDict->GetArrayFor("C0"); |
- if (m_nOutputs == 0) { |
- m_nOutputs = 1; |
- if (pArray0) { |
- m_nOutputs = pArray0->GetCount(); |
- } |
- } |
- CPDF_Array* pArray1 = pDict->GetArrayFor("C1"); |
- m_pBeginValues = FX_Alloc2D(FX_FLOAT, m_nOutputs, 2); |
- m_pEndValues = FX_Alloc2D(FX_FLOAT, m_nOutputs, 2); |
- for (uint32_t i = 0; i < m_nOutputs; i++) { |
- m_pBeginValues[i] = pArray0 ? pArray0->GetFloatAt(i) : 0.0f; |
- m_pEndValues[i] = pArray1 ? pArray1->GetFloatAt(i) : 1.0f; |
- } |
- m_Exponent = pDict->GetFloatFor("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 (uint32_t i = 0; i < m_nInputs; i++) |
- for (uint32_t 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; |
-} |
- |
-CPDF_StitchFunc::CPDF_StitchFunc() |
- : CPDF_Function(Type::kType3Stitching), |
- m_pBounds(nullptr), |
- m_pEncode(nullptr) {} |
- |
-CPDF_StitchFunc::~CPDF_StitchFunc() { |
- FX_Free(m_pBounds); |
- FX_Free(m_pEncode); |
-} |
- |
-FX_BOOL CPDF_StitchFunc::v_Init(CPDF_Object* pObj) { |
- CPDF_Dictionary* pDict = pObj->GetDict(); |
- if (!pDict) { |
- return FALSE; |
- } |
- if (m_nInputs != kRequiredNumInputs) { |
- return FALSE; |
- } |
- CPDF_Array* pArray = pDict->GetArrayFor("Functions"); |
- if (!pArray) { |
- return FALSE; |
- } |
- uint32_t nSubs = pArray->GetCount(); |
- if (nSubs == 0) |
- return FALSE; |
- m_nOutputs = 0; |
- for (uint32_t i = 0; i < nSubs; i++) { |
- CPDF_Object* pSub = pArray->GetDirectObjectAt(i); |
- if (pSub == pObj) |
- return FALSE; |
- std::unique_ptr<CPDF_Function> pFunc(CPDF_Function::Load(pSub)); |
- if (!pFunc) |
- return FALSE; |
- // Check that the input dimensionality is 1, and that all output |
- // dimensionalities are the same. |
- if (pFunc->CountInputs() != kRequiredNumInputs) |
- return FALSE; |
- if (pFunc->CountOutputs() != m_nOutputs) { |
- if (m_nOutputs) |
- return FALSE; |
- |
- m_nOutputs = pFunc->CountOutputs(); |
- } |
- |
- m_pSubFunctions.push_back(std::move(pFunc)); |
- } |
- m_pBounds = FX_Alloc(FX_FLOAT, nSubs + 1); |
- m_pBounds[0] = m_pDomains[0]; |
- pArray = pDict->GetArrayFor("Bounds"); |
- if (!pArray) |
- return FALSE; |
- for (uint32_t i = 0; i < nSubs - 1; i++) |
- m_pBounds[i + 1] = pArray->GetFloatAt(i); |
- m_pBounds[nSubs] = m_pDomains[1]; |
- m_pEncode = FX_Alloc2D(FX_FLOAT, nSubs, 2); |
- pArray = pDict->GetArrayFor("Encode"); |
- if (!pArray) |
- return FALSE; |
- |
- for (uint32_t i = 0; i < nSubs * 2; i++) |
- m_pEncode[i] = pArray->GetFloatAt(i); |
- return TRUE; |
-} |
- |
-FX_BOOL CPDF_StitchFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* outputs) const { |
- FX_FLOAT input = inputs[0]; |
- size_t i; |
- for (i = 0; i < m_pSubFunctions.size() - 1; i++) { |
- if (input < m_pBounds[i + 1]) |
- break; |
- } |
- 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, kRequiredNumInputs, outputs, nresults); |
- return TRUE; |
-} |
- |
-// static |
-std::unique_ptr<CPDF_Function> CPDF_Function::Load(CPDF_Object* pFuncObj) { |
- std::unique_ptr<CPDF_Function> pFunc; |
- if (!pFuncObj) |
- return pFunc; |
- |
- int iType = -1; |
- if (CPDF_Stream* pStream = pFuncObj->AsStream()) |
- iType = pStream->GetDict()->GetIntegerFor("FunctionType"); |
- else if (CPDF_Dictionary* pDict = pFuncObj->AsDictionary()) |
- iType = pDict->GetIntegerFor("FunctionType"); |
- |
- Type type = IntegerToFunctionType(iType); |
- if (type == Type::kType0Sampled) |
- pFunc.reset(new CPDF_SampledFunc()); |
- else if (type == Type::kType2ExpotentialInterpolation) |
- pFunc.reset(new CPDF_ExpIntFunc()); |
- else if (type == Type::kType3Stitching) |
- pFunc.reset(new CPDF_StitchFunc()); |
- else if (type == Type::kType4PostScript) |
- pFunc.reset(new CPDF_PSFunc()); |
- |
- if (!pFunc || !pFunc->Init(pFuncObj)) |
- return std::unique_ptr<CPDF_Function>(); |
- return pFunc; |
-} |
- |
-// static |
-CPDF_Function::Type CPDF_Function::IntegerToFunctionType(int iType) { |
- switch (iType) { |
- case 0: |
- case 2: |
- case 3: |
- case 4: |
- return static_cast<Type>(iType); |
- default: |
- return Type::kTypeInvalid; |
- } |
-} |
- |
-CPDF_Function::CPDF_Function(Type type) |
- : m_pDomains(nullptr), m_pRanges(nullptr), m_Type(type) {} |
- |
-CPDF_Function::~CPDF_Function() { |
- FX_Free(m_pDomains); |
- FX_Free(m_pRanges); |
-} |
- |
-FX_BOOL CPDF_Function::Init(CPDF_Object* pObj) { |
- CPDF_Stream* pStream = pObj->AsStream(); |
- CPDF_Dictionary* pDict = pStream ? pStream->GetDict() : pObj->AsDictionary(); |
- |
- CPDF_Array* pDomains = pDict->GetArrayFor("Domain"); |
- if (!pDomains) |
- return FALSE; |
- |
- m_nInputs = pDomains->GetCount() / 2; |
- if (m_nInputs == 0) |
- return FALSE; |
- |
- m_pDomains = FX_Alloc2D(FX_FLOAT, m_nInputs, 2); |
- for (uint32_t i = 0; i < m_nInputs * 2; i++) { |
- m_pDomains[i] = pDomains->GetFloatAt(i); |
- } |
- CPDF_Array* pRanges = pDict->GetArrayFor("Range"); |
- m_nOutputs = 0; |
- if (pRanges) { |
- m_nOutputs = pRanges->GetCount() / 2; |
- m_pRanges = FX_Alloc2D(FX_FLOAT, m_nOutputs, 2); |
- for (uint32_t i = 0; i < m_nOutputs * 2; i++) |
- m_pRanges[i] = pRanges->GetFloatAt(i); |
- } |
- uint32_t old_outputs = m_nOutputs; |
- if (!v_Init(pObj)) |
- return FALSE; |
- if (m_pRanges && m_nOutputs > 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, |
- uint32_t ninputs, |
- FX_FLOAT* results, |
- int& nresults) const { |
- if (m_nInputs != ninputs) { |
- return FALSE; |
- } |
- nresults = m_nOutputs; |
- for (uint32_t 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 (uint32_t 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; |
-} |
- |
-const CPDF_SampledFunc* CPDF_Function::ToSampledFunc() const { |
- return m_Type == Type::kType0Sampled |
- ? static_cast<const CPDF_SampledFunc*>(this) |
- : nullptr; |
-} |
- |
-const CPDF_ExpIntFunc* CPDF_Function::ToExpIntFunc() const { |
- return m_Type == Type::kType2ExpotentialInterpolation |
- ? static_cast<const CPDF_ExpIntFunc*>(this) |
- : nullptr; |
-} |
- |
-const CPDF_StitchFunc* CPDF_Function::ToStitchFunc() const { |
- return m_Type == Type::kType3Stitching |
- ? static_cast<const CPDF_StitchFunc*>(this) |
- : nullptr; |
-} |