Fix a few more warnings in chromium_code mode.
[pdfium.git] / core / src / fpdfapi / fpdf_render / fpdf_render_cache.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_render.h"
8 #include "../../../include/fpdfapi/fpdf_pageobj.h"
9 #include "../../../include/fxge/fx_ge.h"
10 #include "../fpdf_page/pageint.h"
11 #include "render_int.h"
12 struct CACHEINFO {
13     FX_DWORD time;
14     CPDF_Stream* pStream;
15 };
16 extern "C" {
17     static int compare(const void* data1, const void* data2)
18     {
19         return ((CACHEINFO*)data1)->time - ((CACHEINFO*)data2)->time;
20     }
21 };
22 void CPDF_Page::ClearRenderCache()
23 {
24     if (m_pPageRender) {
25         m_pPageRender->ClearAll();
26     }
27 }
28 void CPDF_PageRenderCache::ClearAll()
29 {
30     FX_POSITION pos = m_ImageCaches.GetStartPosition();
31     while (pos) {
32         FX_LPVOID key, value;
33         m_ImageCaches.GetNextAssoc(pos, key, value);
34         delete (CPDF_ImageCache*)value;
35     }
36     m_ImageCaches.RemoveAll();
37     m_nCacheSize = 0;
38     m_nTimeCount = 0;
39 }
40 void CPDF_PageRenderCache::CacheOptimization(FX_INT32 dwLimitCacheSize)
41 {
42     if (m_nCacheSize <= (FX_DWORD)dwLimitCacheSize) {
43         return;
44     }
45     int nCount = m_ImageCaches.GetCount();
46     CACHEINFO* pCACHEINFO = (CACHEINFO*)FX_Alloc(FX_BYTE, (sizeof (CACHEINFO)) * nCount);
47     FX_POSITION pos = m_ImageCaches.GetStartPosition();
48     int i = 0;
49     while (pos) {
50         FX_LPVOID key, value;
51         m_ImageCaches.GetNextAssoc(pos, key, value);
52         pCACHEINFO[i].time = ((CPDF_ImageCache*)value)->GetTimeCount();
53         pCACHEINFO[i++].pStream = ((CPDF_ImageCache*)value)->GetStream();
54     }
55     FXSYS_qsort(pCACHEINFO, nCount, sizeof (CACHEINFO), compare);
56     FX_DWORD nTimeCount = m_nTimeCount;
57     if (nTimeCount + 1 < nTimeCount) {
58         for (i = 0; i < nCount; i ++) {
59             ((CPDF_ImageCache*)(m_ImageCaches[pCACHEINFO[i].pStream]))->m_dwTimeCount = i;
60         }
61         m_nTimeCount = nCount;
62     }
63     i = 0;
64     while(nCount > 15) {
65         ClearImageCache(pCACHEINFO[i++].pStream);
66         nCount--;
67     }
68     while (m_nCacheSize > (FX_DWORD)dwLimitCacheSize) {
69         ClearImageCache(pCACHEINFO[i++].pStream);
70     }
71     FX_Free(pCACHEINFO);
72 }
73 void CPDF_PageRenderCache::ClearImageCache(CPDF_Stream* pStream)
74 {
75     FX_LPVOID value = m_ImageCaches.GetValueAt(pStream);
76     if (value == NULL)  {
77         m_ImageCaches.RemoveKey(pStream);
78         return;
79     }
80     m_nCacheSize -= ((CPDF_ImageCache*)value)->EstimateSize();
81     delete (CPDF_ImageCache*)value;
82     m_ImageCaches.RemoveKey(pStream);
83 }
84 FX_DWORD CPDF_PageRenderCache::EstimateSize()
85 {
86     FX_DWORD dwSize = 0;
87     FX_POSITION pos = m_ImageCaches.GetStartPosition();
88     while (pos) {
89         FX_LPVOID key, value;
90         m_ImageCaches.GetNextAssoc(pos, key, value);
91         dwSize += ((CPDF_ImageCache*)value)->EstimateSize();
92     }
93     m_nCacheSize = dwSize;
94     return dwSize;
95 }
96 FX_DWORD CPDF_PageRenderCache::GetCachedSize(CPDF_Stream* pStream) const
97 {
98     if (pStream == NULL) {
99         return m_nCacheSize;
100     }
101     CPDF_ImageCache* pImageCache;
102     if (!m_ImageCaches.Lookup(pStream, (FX_LPVOID&)pImageCache)) {
103         return 0;
104     }
105     return pImageCache->EstimateSize();
106 }
107 void CPDF_PageRenderCache::GetCachedBitmap(CPDF_Stream* pStream, CFX_DIBSource*& pBitmap, CFX_DIBSource*& pMask, FX_DWORD& MatteColor,
108         FX_BOOL bStdCS, FX_DWORD GroupFamily, FX_BOOL bLoadMask, CPDF_RenderStatus* pRenderStatus,
109         FX_INT32 downsampleWidth, FX_INT32 downsampleHeight)
110 {
111     CPDF_ImageCache* pImageCache;
112     FX_BOOL bFind = m_ImageCaches.Lookup(pStream, (FX_LPVOID&)pImageCache);
113     if (!bFind) {
114         pImageCache = FX_NEW CPDF_ImageCache(m_pPage->m_pDocument, pStream);
115     }
116     m_nTimeCount ++;
117     FX_BOOL bCached = pImageCache->GetCachedBitmap(pBitmap, pMask, MatteColor, m_pPage->m_pPageResources, bStdCS, GroupFamily, bLoadMask, pRenderStatus, downsampleWidth, downsampleHeight);
118     if (!bFind) {
119         m_ImageCaches.SetAt(pStream, pImageCache);
120     }
121     if (!bCached) {
122         m_nCacheSize += pImageCache->EstimateSize();
123     }
124 }
125 FX_BOOL CPDF_PageRenderCache::StartGetCachedBitmap(CPDF_Stream* pStream, FX_BOOL bStdCS, FX_DWORD GroupFamily, FX_BOOL bLoadMask, CPDF_RenderStatus* pRenderStatus, FX_INT32 downsampleWidth, FX_INT32 downsampleHeight)
126 {
127     m_bCurFindCache = m_ImageCaches.Lookup(pStream, (FX_LPVOID&)m_pCurImageCache);
128     if (!m_bCurFindCache) {
129         m_pCurImageCache = FX_NEW CPDF_ImageCache(m_pPage->m_pDocument, pStream);
130     }
131     int ret = m_pCurImageCache->StartGetCachedBitmap(pRenderStatus->m_pFormResource, m_pPage->m_pPageResources, bStdCS, GroupFamily, bLoadMask, pRenderStatus, downsampleWidth, downsampleHeight);
132     if (ret == 2) {
133         return TRUE;
134     }
135     m_nTimeCount ++;
136     if (!m_bCurFindCache) {
137         m_ImageCaches.SetAt(pStream, m_pCurImageCache);
138     }
139     if (!ret) {
140         m_nCacheSize += m_pCurImageCache->EstimateSize();
141     }
142     return FALSE;
143 }
144 FX_BOOL CPDF_PageRenderCache::Continue(IFX_Pause* pPause)
145 {
146     int ret = m_pCurImageCache->Continue(pPause);
147     if (ret == 2) {
148         return TRUE;
149     }
150     m_nTimeCount ++;
151     if (!m_bCurFindCache) {
152         m_ImageCaches.SetAt(m_pCurImageCache->GetStream(), m_pCurImageCache);
153     }
154     if (!ret) {
155         m_nCacheSize += m_pCurImageCache->EstimateSize();
156     }
157     return FALSE;
158 }
159 void CPDF_PageRenderCache::ResetBitmap(CPDF_Stream* pStream, const CFX_DIBitmap* pBitmap)
160 {
161     CPDF_ImageCache* pImageCache;
162     if (!m_ImageCaches.Lookup(pStream, (FX_LPVOID&)pImageCache)) {
163         if (pBitmap == NULL) {
164             return;
165         }
166         pImageCache = FX_NEW CPDF_ImageCache(m_pPage->m_pDocument, pStream);
167         m_ImageCaches.SetAt(pStream, pImageCache);
168     }
169     int oldsize = pImageCache->EstimateSize();
170     pImageCache->Reset(pBitmap);
171     m_nCacheSize = pImageCache->EstimateSize() - oldsize;
172 }
173 CPDF_ImageCache::CPDF_ImageCache(CPDF_Document* pDoc, CPDF_Stream* pStream)
174     : m_dwTimeCount(0)
175     , m_pCurBitmap(NULL)
176     , m_pCurMask(NULL)
177     , m_MatteColor(0)
178     , m_pRenderStatus(NULL)
179     , m_pDocument(pDoc)
180     , m_pStream(pStream)
181     , m_pCachedBitmap(NULL)
182     , m_pCachedMask(NULL)
183     , m_dwCacheSize(0)
184 {
185 }
186 CPDF_ImageCache::~CPDF_ImageCache()
187 {
188     if (m_pCachedBitmap) {
189         delete m_pCachedBitmap;
190         m_pCachedBitmap = NULL;
191     }
192     if (m_pCachedMask) {
193         delete m_pCachedMask;
194         m_pCachedMask = NULL;
195     }
196 }
197 void CPDF_ImageCache::Reset(const CFX_DIBitmap* pBitmap)
198 {
199     if (m_pCachedBitmap) {
200         delete m_pCachedBitmap;
201     }
202     m_pCachedBitmap = NULL;
203     if (pBitmap) {
204         m_pCachedBitmap = pBitmap->Clone();
205     }
206     CalcSize();
207 }
208 void CPDF_PageRenderCache::ClearImageData()
209 {
210     FX_POSITION pos = m_ImageCaches.GetStartPosition();
211     while (pos) {
212         FX_LPVOID key, value;
213         m_ImageCaches.GetNextAssoc(pos, key, value);
214         ((CPDF_ImageCache*)value)->ClearImageData();
215     }
216 }
217 void CPDF_ImageCache::ClearImageData()
218 {
219     if (m_pCachedBitmap && m_pCachedBitmap->GetBuffer() == NULL) {
220         ((CPDF_DIBSource*)m_pCachedBitmap)->ClearImageData();
221     }
222 }
223 static FX_DWORD FPDF_ImageCache_EstimateImageSize(const CFX_DIBSource* pDIB)
224 {
225     return pDIB && pDIB->GetBuffer() ? (FX_DWORD)pDIB->GetHeight() * pDIB->GetPitch() + (FX_DWORD)pDIB->GetPaletteSize() * 4 : 0;
226 }
227 FX_BOOL CPDF_ImageCache::GetCachedBitmap(CFX_DIBSource*& pBitmap, CFX_DIBSource*& pMask, FX_DWORD& MatteColor, CPDF_Dictionary* pPageResources,
228         FX_BOOL bStdCS, FX_DWORD GroupFamily, FX_BOOL bLoadMask, CPDF_RenderStatus* pRenderStatus,
229         FX_INT32 downsampleWidth, FX_INT32 downsampleHeight)
230 {
231     if (m_pCachedBitmap) {
232         pBitmap = m_pCachedBitmap;
233         pMask = m_pCachedMask;
234         MatteColor = m_MatteColor;
235         return TRUE;
236     }
237     if (!pRenderStatus) {
238         return FALSE;
239     }
240     CPDF_RenderContext*pContext = pRenderStatus->GetContext();
241     CPDF_PageRenderCache* pPageRenderCache = pContext->m_pPageCache;
242     m_dwTimeCount = pPageRenderCache->GetTimeCount();
243     CPDF_DIBSource* pSrc = FX_NEW CPDF_DIBSource;
244     CPDF_DIBSource* pMaskSrc = NULL;
245     if (!pSrc->Load(m_pDocument, m_pStream, &pMaskSrc, &MatteColor, pRenderStatus->m_pFormResource, pPageResources, bStdCS, GroupFamily, bLoadMask)) {
246         delete pSrc;
247         pBitmap = NULL;
248         return FALSE;
249     }
250     m_MatteColor = MatteColor;
251 #if !defined(_FPDFAPI_MINI_)
252     if (pSrc->GetPitch() * pSrc->GetHeight() < FPDF_HUGE_IMAGE_SIZE) {
253         m_pCachedBitmap = pSrc->Clone();
254         delete pSrc;
255     } else {
256         m_pCachedBitmap = pSrc;
257     }
258     if (pMaskSrc) {
259         m_pCachedMask = pMaskSrc->Clone();
260         delete pMaskSrc;
261     }
262 #else
263     if (pSrc->GetFormat() == FXDIB_8bppRgb && pSrc->GetPalette() &&
264             pSrc->GetHeight() * pSrc->GetWidth() * 3 < 1024) {
265 #if _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_
266         m_pCachedBitmap = pSrc->CloneConvert(FXDIB_Rgb32);
267 #else
268         m_pCachedBitmap = pSrc->CloneConvert(FXDIB_Rgb);
269 #endif
270         delete pSrc;
271     } else if (pSrc->GetPitch() * pSrc->GetHeight() < 102400) {
272         m_pCachedBitmap = pSrc->Clone();
273         delete pSrc;
274     } else {
275         m_pCachedBitmap = pSrc;
276     }
277     m_pCachedMask = pMaskSrc;
278 #endif
279     pBitmap = m_pCachedBitmap;
280     pMask = m_pCachedMask;
281     CalcSize();
282     return FALSE;
283 }
284 CFX_DIBSource* CPDF_ImageCache::DetachBitmap()
285 {
286     CFX_DIBSource* pDIBSource = m_pCurBitmap;
287     m_pCurBitmap = NULL;
288     return pDIBSource;
289 }
290 CFX_DIBSource* CPDF_ImageCache::DetachMask()
291 {
292     CFX_DIBSource* pDIBSource = m_pCurMask;
293     m_pCurMask = NULL;
294     return pDIBSource;
295 }
296 int     CPDF_ImageCache::StartGetCachedBitmap(CPDF_Dictionary* pFormResources, CPDF_Dictionary* pPageResources, FX_BOOL bStdCS,
297         FX_DWORD GroupFamily, FX_BOOL bLoadMask, CPDF_RenderStatus* pRenderStatus,
298         FX_INT32 downsampleWidth, FX_INT32 downsampleHeight)
299 {
300     if (m_pCachedBitmap) {
301         m_pCurBitmap = m_pCachedBitmap;
302         m_pCurMask = m_pCachedMask;
303         return 1;
304     }
305     if (!pRenderStatus) {
306         return 0;
307     }
308     m_pRenderStatus = pRenderStatus;
309     m_pCurBitmap = FX_NEW CPDF_DIBSource;
310     int ret = ((CPDF_DIBSource*)m_pCurBitmap)->StartLoadDIBSource(m_pDocument, m_pStream, TRUE, pFormResources, pPageResources, bStdCS, GroupFamily, bLoadMask);
311     if (ret == 2) {
312         return ret;
313     }
314     if (!ret) {
315         delete m_pCurBitmap;
316         m_pCurBitmap = NULL;
317         return 0;
318     }
319     ContinueGetCachedBitmap();
320     return 0;
321 }
322 int CPDF_ImageCache::ContinueGetCachedBitmap()
323 {
324     m_MatteColor = ((CPDF_DIBSource*)m_pCurBitmap)->m_MatteColor;
325     m_pCurMask = ((CPDF_DIBSource*)m_pCurBitmap)->DetachMask();
326     CPDF_RenderContext*pContext = m_pRenderStatus->GetContext();
327     CPDF_PageRenderCache* pPageRenderCache = pContext->m_pPageCache;
328     m_dwTimeCount = pPageRenderCache->GetTimeCount();
329 #if !defined(_FPDFAPI_MINI_)
330     if (m_pCurBitmap->GetPitch() * m_pCurBitmap->GetHeight() < FPDF_HUGE_IMAGE_SIZE) {
331         m_pCachedBitmap = m_pCurBitmap->Clone();
332         delete m_pCurBitmap;
333         m_pCurBitmap = NULL;
334     } else {
335         m_pCachedBitmap = m_pCurBitmap;
336     }
337     if (m_pCurMask) {
338         m_pCachedMask = m_pCurMask->Clone();
339         delete m_pCurMask;
340         m_pCurMask = NULL;
341     }
342 #else
343     if (m_pCurBitmap->GetFormat() == FXDIB_8bppRgb && m_pCurBitmap->GetPalette() &&
344             m_pCurBitmap->GetHeight() * m_pCurBitmap->GetWidth() * 3 < 1024) {
345         m_pCachedBitmap = m_pCurBitmap->CloneConvert(FXDIB_Rgb32);
346         m_pCachedBitmap = m_pCurBitmap->CloneConvert(FXDIB_Rgb);
347         delete m_pCurBitmap;
348         m_pCurBitmap = NULL;
349     } else if (m_pCurBitmap->GetPitch() * m_pCurBitmap->GetHeight() < 102400) {
350         m_pCachedBitmap = m_pCurBitmap->Clone();
351         delete m_pCurBitmap;
352         m_pCurBitmap = NULL;
353     } else {
354         m_pCachedBitmap = m_pCurBitmap;
355     }
356     m_pCachedMask = m_pCurMask;
357 #endif
358     m_pCurBitmap = m_pCachedBitmap;
359     m_pCurMask = m_pCachedMask;
360     CalcSize();
361     return 0;
362 }
363 int     CPDF_ImageCache::Continue(IFX_Pause* pPause)
364 {
365     int ret = ((CPDF_DIBSource*)m_pCurBitmap)->ContinueLoadDIBSource(pPause);
366     if (ret == 2) {
367         return ret;
368     }
369     if (!ret) {
370         delete m_pCurBitmap;
371         m_pCurBitmap = NULL;
372         return 0;
373     }
374     ContinueGetCachedBitmap();
375     return 0;
376 }
377 void CPDF_ImageCache::CalcSize()
378 {
379     m_dwCacheSize = FPDF_ImageCache_EstimateImageSize(m_pCachedBitmap) + FPDF_ImageCache_EstimateImageSize(m_pCachedMask);
380 }
381 void CPDF_Document::ClearRenderFont()
382 {
383     if (m_pDocRender) {
384         CFX_FontCache* pCache = m_pDocRender->GetFontCache();
385         if (pCache) {
386             pCache->FreeCache(FALSE);
387         }
388     }
389 }