ded6c878ea909fa283f8291cf89e3db5f393b0f5
[pdfium.git] / core / src / fpdfapi / fpdf_page / fpdf_page_pattern.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 "../../../include/fpdfapi/fpdf_page.h"
8 #include "pageint.h"
9
10 CPDF_Pattern::CPDF_Pattern(const CFX_AffineMatrix* pParentMatrix)
11     : m_pPatternObj(NULL),
12       m_PatternType(PATTERN_TILING),
13       m_pDocument(NULL),
14       m_bForceClear(FALSE) {
15   if (pParentMatrix) {
16     m_ParentMatrix = *pParentMatrix;
17   }
18 }
19 CPDF_Pattern::~CPDF_Pattern() {}
20 CPDF_TilingPattern::CPDF_TilingPattern(CPDF_Document* pDoc,
21                                        CPDF_Object* pPatternObj,
22                                        const CFX_AffineMatrix* parentMatrix)
23     : CPDF_Pattern(parentMatrix) {
24   m_PatternType = PATTERN_TILING;
25   m_pPatternObj = pPatternObj;
26   m_pDocument = pDoc;
27   CPDF_Dictionary* pDict = m_pPatternObj->GetDict();
28   ASSERT(pDict != NULL);
29   m_Pattern2Form = pDict->GetMatrix(FX_BSTRC("Matrix"));
30   m_bColored = pDict->GetInteger(FX_BSTRC("PaintType")) == 1;
31   if (parentMatrix) {
32     m_Pattern2Form.Concat(*parentMatrix);
33   }
34   m_pForm = NULL;
35 }
36 CPDF_TilingPattern::~CPDF_TilingPattern() {
37   delete m_pForm;
38   m_pForm = NULL;
39 }
40 FX_BOOL CPDF_TilingPattern::Load() {
41   if (m_pForm)
42     return TRUE;
43
44   CPDF_Dictionary* pDict = m_pPatternObj->GetDict();
45   if (!pDict)
46     return FALSE;
47
48   m_bColored = pDict->GetInteger(FX_BSTRC("PaintType")) == 1;
49   m_XStep = (FX_FLOAT)FXSYS_fabs(pDict->GetNumber(FX_BSTRC("XStep")));
50   m_YStep = (FX_FLOAT)FXSYS_fabs(pDict->GetNumber(FX_BSTRC("YStep")));
51
52   CPDF_Stream* pStream = m_pPatternObj->AsStream();
53   if (!pStream)
54     return FALSE;
55
56   m_pForm = new CPDF_Form(m_pDocument, NULL, pStream);
57   m_pForm->ParseContent(NULL, &m_ParentMatrix, NULL, NULL);
58   m_BBox = pDict->GetRect(FX_BSTRC("BBox"));
59   return TRUE;
60 }
61 CPDF_ShadingPattern::CPDF_ShadingPattern(CPDF_Document* pDoc,
62                                          CPDF_Object* pPatternObj,
63                                          FX_BOOL bShading,
64                                          const CFX_AffineMatrix* parentMatrix)
65     : CPDF_Pattern(parentMatrix) {
66   m_PatternType = PATTERN_SHADING;
67   m_pPatternObj = bShading ? NULL : pPatternObj;
68   m_pDocument = pDoc;
69   m_bShadingObj = bShading;
70   if (!bShading) {
71     CPDF_Dictionary* pDict = m_pPatternObj->GetDict();
72     ASSERT(pDict != NULL);
73     m_Pattern2Form = pDict->GetMatrix(FX_BSTRC("Matrix"));
74     m_pShadingObj = pDict->GetElementValue(FX_BSTRC("Shading"));
75     if (parentMatrix) {
76       m_Pattern2Form.Concat(*parentMatrix);
77     }
78   } else {
79     m_pShadingObj = pPatternObj;
80   }
81   m_ShadingType = 0;
82   m_pCS = NULL;
83   m_nFuncs = 0;
84   for (int i = 0; i < 4; i++) {
85     m_pFunctions[i] = NULL;
86   }
87   m_pCountedCS = NULL;
88 }
89 CPDF_ShadingPattern::~CPDF_ShadingPattern() {
90   Clear();
91 }
92 void CPDF_ShadingPattern::Clear() {
93   for (int i = 0; i < m_nFuncs; i++) {
94     delete m_pFunctions[i];
95     m_pFunctions[i] = NULL;
96   }
97   CPDF_ColorSpace* pCS = m_pCountedCS ? m_pCountedCS->get() : NULL;
98   if (pCS && m_pDocument) {
99     m_pDocument->GetPageData()->ReleaseColorSpace(pCS->GetArray());
100   }
101   m_ShadingType = 0;
102   m_pCS = NULL;
103   m_pCountedCS = NULL;
104   m_nFuncs = 0;
105 }
106 FX_BOOL CPDF_ShadingPattern::Load() {
107   if (m_ShadingType != 0) {
108     return TRUE;
109   }
110   CPDF_Dictionary* pShadingDict =
111       m_pShadingObj ? m_pShadingObj->GetDict() : NULL;
112   if (pShadingDict == NULL) {
113     return FALSE;
114   }
115   if (m_nFuncs) {
116     for (int i = 0; i < m_nFuncs; i++)
117       delete m_pFunctions[i];
118     m_nFuncs = 0;
119   }
120   CPDF_Object* pFunc = pShadingDict->GetElementValue(FX_BSTRC("Function"));
121   if (pFunc) {
122     if (CPDF_Array* pArray = pFunc->AsArray()) {
123       m_nFuncs = std::min<int>(pArray->GetCount(), 4);
124
125       for (int i = 0; i < m_nFuncs; i++) {
126         m_pFunctions[i] = CPDF_Function::Load(pArray->GetElementValue(i));
127       }
128     } else {
129       m_pFunctions[0] = CPDF_Function::Load(pFunc);
130       m_nFuncs = 1;
131     }
132   }
133   CPDF_Object* pCSObj = pShadingDict->GetElementValue(FX_BSTRC("ColorSpace"));
134   if (pCSObj == NULL) {
135     return FALSE;
136   }
137   CPDF_DocPageData* pDocPageData = m_pDocument->GetPageData();
138   m_pCS = pDocPageData->GetColorSpace(pCSObj, NULL);
139   if (m_pCS) {
140     m_pCountedCS = pDocPageData->FindColorSpacePtr(m_pCS->GetArray());
141   }
142   m_ShadingType = pShadingDict->GetInteger(FX_BSTRC("ShadingType"));
143
144   // We expect to have a stream if our shading type is a mesh.
145   if (m_ShadingType >= 4 && !ToStream(m_pShadingObj))
146     return FALSE;
147
148   return TRUE;
149 }
150 FX_BOOL CPDF_ShadingPattern::Reload() {
151   Clear();
152   return Load();
153 }
154 FX_BOOL CPDF_MeshStream::Load(CPDF_Stream* pShadingStream,
155                               CPDF_Function** pFuncs,
156                               int nFuncs,
157                               CPDF_ColorSpace* pCS) {
158   m_Stream.LoadAllData(pShadingStream);
159   m_BitStream.Init(m_Stream.GetData(), m_Stream.GetSize());
160   m_pFuncs = pFuncs;
161   m_nFuncs = nFuncs;
162   m_pCS = pCS;
163   CPDF_Dictionary* pDict = pShadingStream->GetDict();
164   m_nCoordBits = pDict->GetInteger(FX_BSTRC("BitsPerCoordinate"));
165   m_nCompBits = pDict->GetInteger(FX_BSTRC("BitsPerComponent"));
166   m_nFlagBits = pDict->GetInteger(FX_BSTRC("BitsPerFlag"));
167   if (!m_nCoordBits || !m_nCompBits) {
168     return FALSE;
169   }
170   int nComps = pCS->CountComponents();
171   if (nComps > 8) {
172     return FALSE;
173   }
174   m_nComps = nFuncs ? 1 : nComps;
175   if (((int)m_nComps < 0) || m_nComps > 8) {
176     return FALSE;
177   }
178   m_CoordMax = m_nCoordBits == 32 ? -1 : (1 << m_nCoordBits) - 1;
179   m_CompMax = (1 << m_nCompBits) - 1;
180   CPDF_Array* pDecode = pDict->GetArray(FX_BSTRC("Decode"));
181   if (pDecode == NULL || pDecode->GetCount() != 4 + m_nComps * 2) {
182     return FALSE;
183   }
184   m_xmin = pDecode->GetNumber(0);
185   m_xmax = pDecode->GetNumber(1);
186   m_ymin = pDecode->GetNumber(2);
187   m_ymax = pDecode->GetNumber(3);
188   for (FX_DWORD i = 0; i < m_nComps; i++) {
189     m_ColorMin[i] = pDecode->GetNumber(i * 2 + 4);
190     m_ColorMax[i] = pDecode->GetNumber(i * 2 + 5);
191   }
192   return TRUE;
193 }
194 FX_DWORD CPDF_MeshStream::GetFlag() {
195   return m_BitStream.GetBits(m_nFlagBits) & 0x03;
196 }
197 void CPDF_MeshStream::GetCoords(FX_FLOAT& x, FX_FLOAT& y) {
198   if (m_nCoordBits == 32) {
199     x = m_xmin + (FX_FLOAT)(m_BitStream.GetBits(m_nCoordBits) *
200                             (m_xmax - m_xmin) / (double)m_CoordMax);
201     y = m_ymin + (FX_FLOAT)(m_BitStream.GetBits(m_nCoordBits) *
202                             (m_ymax - m_ymin) / (double)m_CoordMax);
203   } else {
204     x = m_xmin +
205         m_BitStream.GetBits(m_nCoordBits) * (m_xmax - m_xmin) / m_CoordMax;
206     y = m_ymin +
207         m_BitStream.GetBits(m_nCoordBits) * (m_ymax - m_ymin) / m_CoordMax;
208   }
209 }
210 void CPDF_MeshStream::GetColor(FX_FLOAT& r, FX_FLOAT& g, FX_FLOAT& b) {
211   FX_DWORD i;
212   FX_FLOAT color_value[8];
213   for (i = 0; i < m_nComps; i++) {
214     color_value[i] = m_ColorMin[i] +
215                      m_BitStream.GetBits(m_nCompBits) *
216                          (m_ColorMax[i] - m_ColorMin[i]) / m_CompMax;
217   }
218   if (m_nFuncs) {
219     static const int kMaxResults = 8;
220     FX_FLOAT result[kMaxResults];
221     int nResults;
222     FXSYS_memset(result, 0, sizeof(result));
223     for (FX_DWORD i = 0; i < m_nFuncs; i++) {
224       if (m_pFuncs[i] && m_pFuncs[i]->CountOutputs() <= kMaxResults) {
225         m_pFuncs[i]->Call(color_value, 1, result, nResults);
226       }
227     }
228     m_pCS->GetRGB(result, r, g, b);
229   } else {
230     m_pCS->GetRGB(color_value, r, g, b);
231   }
232 }
233 FX_DWORD CPDF_MeshStream::GetVertex(CPDF_MeshVertex& vertex,
234                                     CFX_AffineMatrix* pObject2Bitmap) {
235   FX_DWORD flag = GetFlag();
236   GetCoords(vertex.x, vertex.y);
237   pObject2Bitmap->Transform(vertex.x, vertex.y);
238   GetColor(vertex.r, vertex.g, vertex.b);
239   m_BitStream.ByteAlign();
240   return flag;
241 }
242 FX_BOOL CPDF_MeshStream::GetVertexRow(CPDF_MeshVertex* vertex,
243                                       int count,
244                                       CFX_AffineMatrix* pObject2Bitmap) {
245   for (int i = 0; i < count; i++) {
246     if (m_BitStream.IsEOF()) {
247       return FALSE;
248     }
249     GetCoords(vertex[i].x, vertex[i].y);
250     pObject2Bitmap->Transform(vertex[i].x, vertex[i].y);
251     GetColor(vertex[i].r, vertex[i].g, vertex[i].b);
252     m_BitStream.ByteAlign();
253   }
254   return TRUE;
255 }
256 CFX_FloatRect _GetShadingBBox(CPDF_Stream* pStream,
257                               int type,
258                               const CFX_AffineMatrix* pMatrix,
259                               CPDF_Function** pFuncs,
260                               int nFuncs,
261                               CPDF_ColorSpace* pCS) {
262   if (!pStream || !pStream->IsStream() || !pFuncs || !pCS)
263     return CFX_FloatRect(0, 0, 0, 0);
264
265   CPDF_MeshStream stream;
266   if (!stream.Load(pStream, pFuncs, nFuncs, pCS))
267     return CFX_FloatRect(0, 0, 0, 0);
268
269   CFX_FloatRect rect;
270   FX_BOOL bStarted = FALSE;
271   FX_BOOL bGouraud = type == 4 || type == 5;
272   int full_point_count = type == 7 ? 16 : (type == 6 ? 12 : 1);
273   int full_color_count = (type == 6 || type == 7) ? 4 : 1;
274   while (!stream.m_BitStream.IsEOF()) {
275     FX_DWORD flag = 0;
276     if (type != 5) {
277       flag = stream.GetFlag();
278     }
279     int point_count = full_point_count, color_count = full_color_count;
280     if (!bGouraud && flag) {
281       point_count -= 4;
282       color_count -= 2;
283     }
284     for (int i = 0; i < point_count; i++) {
285       FX_FLOAT x, y;
286       stream.GetCoords(x, y);
287       if (bStarted) {
288         rect.UpdateRect(x, y);
289       } else {
290         rect.InitRect(x, y);
291         bStarted = TRUE;
292       }
293     }
294     stream.m_BitStream.SkipBits(stream.m_nComps * stream.m_nCompBits *
295                                 color_count);
296     if (bGouraud)
297       stream.m_BitStream.ByteAlign();
298   }
299   rect.Transform(pMatrix);
300   return rect;
301 }