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