flesh out gradient shaders

core/fpdfapi/fpdf_page/fpdf_page_func.cpp

 // 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>
 
@@ skipping 473 matching lines @@
   return ((x - xmin) * (ymax - ymin) / (xmax - xmin)) + ymin;
 }
 static uint32_t _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 {
+class CPDF_PSFunc : public CPDF_Function {
  public:
-  CPDF_SampledFunc();
-  ~CPDF_SampledFunc() override;
-
+  CPDF_PSFunc() : CPDF_Function(Type::kType4PostScript) {}
   // CPDF_Function
   FX_BOOL v_Init(CPDF_Object* pObj) override;
   FX_BOOL v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const override;
 
-  SampleEncodeInfo* m_pEncodeInfo;
-  SampleDecodeInfo* m_pDecodeInfo;
-  uint32_t m_nBitsPerSample;
-  uint32_t m_SampleMax;
-  CPDF_StreamAcc* m_pSampleStream;
+ 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;
+}
+
+}  // namespace
+
 CPDF_SampledFunc::CPDF_SampledFunc() : CPDF_Function(Type::kType0Sampled) {
   m_pSampleStream = NULL;
   m_pEncodeInfo = NULL;
   m_pDecodeInfo = NULL;
 }
 
 CPDF_SampledFunc::~CPDF_SampledFunc() {
   delete m_pSampleStream;
   FX_Free(m_pEncodeInfo);
   FX_Free(m_pDecodeInfo);
 }
+
 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->GetArrayBy("Size");
   CPDF_Array* pEncode = pDict->GetArrayBy("Encode");
   CPDF_Array* pDecode = pDict->GetArrayBy("Decode");
   m_nBitsPerSample = pDict->GetIntegerBy("BitsPerSample");
@@ skipping 35 matching lines @@
     if (pDecode) {
       m_pDecodeInfo[i].decode_min = pDecode->GetFloatAt(2 * i);
       m_pDecodeInfo[i].decode_max = pDecode->GetFloatAt(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;
+  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_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;
+    index[i] = std::min((uint32_t)std::max(0.f, encoded_input[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()) {
@@ skipping 31 matching lines @@
                    ((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:
-  // CPDF_Function
-  CPDF_PSFunc() : CPDF_Function(Type::kType4PostScript) {}
-  FX_BOOL v_Init(CPDF_Object* pObj) override;
-  FX_BOOL v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const override;
-
-  CPDF_PSEngine m_PS;
-};
-
-FX_BOOL CPDF_PSFunc::v_Init(CPDF_Object* pObj) {
-  CPDF_Stream* pStream = pObj->AsStream();
-  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();
-  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;
-}
-
-}  // namespace
-
 CPDF_ExpIntFunc::CPDF_ExpIntFunc()
     : CPDF_Function(Type::kType2ExpotentialInterpolation) {
   m_pBeginValues = NULL;
   m_pEndValues = NULL;
 }
 
 CPDF_ExpIntFunc::~CPDF_ExpIntFunc() {
   FX_Free(m_pBeginValues);
   FX_Free(m_pEndValues);
 }
@@ skipping 211 matching lines @@
   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;
 }