blob: 055e2f03cb7c0752af274cf180f92abbeb05813c [file] [log] [blame]
// 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_render/cpdf_pagerendercache.h"
#include "core/fpdfapi/fpdf_page/include/cpdf_page.h"
#include "core/fpdfapi/fpdf_page/pageint.h"
#include "core/fpdfapi/fpdf_parser/include/cpdf_document.h"
#include "core/fpdfapi/fpdf_render/include/cpdf_rendercontext.h"
#include "core/fpdfapi/fpdf_render/render_int.h"
#include "core/fxge/include/fx_ge.h"
struct CACHEINFO {
uint32_t time;
CPDF_Stream* pStream;
};
extern "C" {
static int compare(const void* data1, const void* data2) {
return ((CACHEINFO*)data1)->time - ((CACHEINFO*)data2)->time;
}
} // extern "C"
CPDF_PageRenderCache::CPDF_PageRenderCache(CPDF_Page* pPage)
: m_pPage(pPage),
m_pCurImageCacheEntry(nullptr),
m_nTimeCount(0),
m_nCacheSize(0),
m_bCurFindCache(FALSE) {}
CPDF_PageRenderCache::~CPDF_PageRenderCache() {
for (const auto& it : m_ImageCache)
delete it.second;
}
void CPDF_PageRenderCache::CacheOptimization(int32_t dwLimitCacheSize) {
if (m_nCacheSize <= (uint32_t)dwLimitCacheSize)
return;
size_t nCount = m_ImageCache.size();
CACHEINFO* pCACHEINFO = FX_Alloc(CACHEINFO, nCount);
size_t i = 0;
for (const auto& it : m_ImageCache) {
pCACHEINFO[i].time = it.second->GetTimeCount();
pCACHEINFO[i++].pStream = it.second->GetStream();
}
FXSYS_qsort(pCACHEINFO, nCount, sizeof(CACHEINFO), compare);
uint32_t nTimeCount = m_nTimeCount;
// Check if time value is about to roll over and reset all entries.
// The comparision is legal because uint32_t is an unsigned type.
if (nTimeCount + 1 < nTimeCount) {
for (i = 0; i < nCount; i++)
m_ImageCache[pCACHEINFO[i].pStream]->m_dwTimeCount = i;
m_nTimeCount = nCount;
}
i = 0;
while (i + 15 < nCount)
ClearImageCacheEntry(pCACHEINFO[i++].pStream);
while (i < nCount && m_nCacheSize > (uint32_t)dwLimitCacheSize)
ClearImageCacheEntry(pCACHEINFO[i++].pStream);
FX_Free(pCACHEINFO);
}
void CPDF_PageRenderCache::ClearImageCacheEntry(CPDF_Stream* pStream) {
auto it = m_ImageCache.find(pStream);
if (it == m_ImageCache.end())
return;
m_nCacheSize -= it->second->EstimateSize();
delete it->second;
m_ImageCache.erase(it);
}
uint32_t CPDF_PageRenderCache::EstimateSize() {
uint32_t dwSize = 0;
for (const auto& it : m_ImageCache)
dwSize += it.second->EstimateSize();
m_nCacheSize = dwSize;
return dwSize;
}
void CPDF_PageRenderCache::GetCachedBitmap(CPDF_Stream* pStream,
CFX_DIBSource*& pBitmap,
CFX_DIBSource*& pMask,
uint32_t& MatteColor,
FX_BOOL bStdCS,
uint32_t GroupFamily,
FX_BOOL bLoadMask,
CPDF_RenderStatus* pRenderStatus,
int32_t downsampleWidth,
int32_t downsampleHeight) {
CPDF_ImageCacheEntry* pEntry;
const auto it = m_ImageCache.find(pStream);
FX_BOOL bFound = it != m_ImageCache.end();
if (bFound)
pEntry = it->second;
else
pEntry = new CPDF_ImageCacheEntry(m_pPage->m_pDocument, pStream);
m_nTimeCount++;
FX_BOOL bAlreadyCached = pEntry->GetCachedBitmap(
pBitmap, pMask, MatteColor, m_pPage->m_pPageResources, bStdCS,
GroupFamily, bLoadMask, pRenderStatus, downsampleWidth, downsampleHeight);
if (!bFound)
m_ImageCache[pStream] = pEntry;
if (!bAlreadyCached)
m_nCacheSize += pEntry->EstimateSize();
}
FX_BOOL CPDF_PageRenderCache::StartGetCachedBitmap(
CPDF_Stream* pStream,
FX_BOOL bStdCS,
uint32_t GroupFamily,
FX_BOOL bLoadMask,
CPDF_RenderStatus* pRenderStatus,
int32_t downsampleWidth,
int32_t downsampleHeight) {
const auto it = m_ImageCache.find(pStream);
m_bCurFindCache = it != m_ImageCache.end();
if (m_bCurFindCache) {
m_pCurImageCacheEntry = it->second;
} else {
m_pCurImageCacheEntry =
new CPDF_ImageCacheEntry(m_pPage->m_pDocument, pStream);
}
int ret = m_pCurImageCacheEntry->StartGetCachedBitmap(
pRenderStatus->m_pFormResource, m_pPage->m_pPageResources, bStdCS,
GroupFamily, bLoadMask, pRenderStatus, downsampleWidth, downsampleHeight);
if (ret == 2)
return TRUE;
m_nTimeCount++;
if (!m_bCurFindCache)
m_ImageCache[pStream] = m_pCurImageCacheEntry;
if (!ret)
m_nCacheSize += m_pCurImageCacheEntry->EstimateSize();
return FALSE;
}
FX_BOOL CPDF_PageRenderCache::Continue(IFX_Pause* pPause) {
int ret = m_pCurImageCacheEntry->Continue(pPause);
if (ret == 2)
return TRUE;
m_nTimeCount++;
if (!m_bCurFindCache)
m_ImageCache[m_pCurImageCacheEntry->GetStream()] = m_pCurImageCacheEntry;
if (!ret)
m_nCacheSize += m_pCurImageCacheEntry->EstimateSize();
return FALSE;
}
void CPDF_PageRenderCache::ResetBitmap(CPDF_Stream* pStream,
const CFX_DIBitmap* pBitmap) {
CPDF_ImageCacheEntry* pEntry;
const auto it = m_ImageCache.find(pStream);
if (it == m_ImageCache.end()) {
if (!pBitmap)
return;
pEntry = new CPDF_ImageCacheEntry(m_pPage->m_pDocument, pStream);
m_ImageCache[pStream] = pEntry;
} else {
pEntry = it->second;
}
m_nCacheSize -= pEntry->EstimateSize();
pEntry->Reset(pBitmap);
m_nCacheSize += pEntry->EstimateSize();
}
CPDF_ImageCacheEntry::CPDF_ImageCacheEntry(CPDF_Document* pDoc,
CPDF_Stream* pStream)
: m_dwTimeCount(0),
m_pCurBitmap(nullptr),
m_pCurMask(nullptr),
m_MatteColor(0),
m_pRenderStatus(nullptr),
m_pDocument(pDoc),
m_pStream(pStream),
m_pCachedBitmap(nullptr),
m_pCachedMask(nullptr),
m_dwCacheSize(0) {}
CPDF_ImageCacheEntry::~CPDF_ImageCacheEntry() {
delete m_pCachedBitmap;
delete m_pCachedMask;
}
void CPDF_ImageCacheEntry::Reset(const CFX_DIBitmap* pBitmap) {
delete m_pCachedBitmap;
m_pCachedBitmap = nullptr;
if (pBitmap) {
m_pCachedBitmap = pBitmap->Clone();
}
CalcSize();
}
static uint32_t FPDF_ImageCache_EstimateImageSize(const CFX_DIBSource* pDIB) {
return pDIB && pDIB->GetBuffer()
? (uint32_t)pDIB->GetHeight() * pDIB->GetPitch() +
(uint32_t)pDIB->GetPaletteSize() * 4
: 0;
}
FX_BOOL CPDF_ImageCacheEntry::GetCachedBitmap(CFX_DIBSource*& pBitmap,
CFX_DIBSource*& pMask,
uint32_t& MatteColor,
CPDF_Dictionary* pPageResources,
FX_BOOL bStdCS,
uint32_t GroupFamily,
FX_BOOL bLoadMask,
CPDF_RenderStatus* pRenderStatus,
int32_t downsampleWidth,
int32_t downsampleHeight) {
if (m_pCachedBitmap) {
pBitmap = m_pCachedBitmap;
pMask = m_pCachedMask;
MatteColor = m_MatteColor;
return TRUE;
}
if (!pRenderStatus) {
return FALSE;
}
CPDF_RenderContext* pContext = pRenderStatus->GetContext();
CPDF_PageRenderCache* pPageRenderCache = pContext->GetPageCache();
m_dwTimeCount = pPageRenderCache->GetTimeCount();
CPDF_DIBSource* pSrc = new CPDF_DIBSource;
CPDF_DIBSource* pMaskSrc = nullptr;
if (!pSrc->Load(m_pDocument, m_pStream, &pMaskSrc, &MatteColor,
pRenderStatus->m_pFormResource, pPageResources, bStdCS,
GroupFamily, bLoadMask)) {
delete pSrc;
pBitmap = nullptr;
return FALSE;
}
m_MatteColor = MatteColor;
if (pSrc->GetPitch() * pSrc->GetHeight() < FPDF_HUGE_IMAGE_SIZE) {
m_pCachedBitmap = pSrc->Clone();
delete pSrc;
} else {
m_pCachedBitmap = pSrc;
}
if (pMaskSrc) {
m_pCachedMask = pMaskSrc->Clone();
delete pMaskSrc;
}
pBitmap = m_pCachedBitmap;
pMask = m_pCachedMask;
CalcSize();
return FALSE;
}
CFX_DIBSource* CPDF_ImageCacheEntry::DetachBitmap() {
CFX_DIBSource* pDIBSource = m_pCurBitmap;
m_pCurBitmap = nullptr;
return pDIBSource;
}
CFX_DIBSource* CPDF_ImageCacheEntry::DetachMask() {
CFX_DIBSource* pDIBSource = m_pCurMask;
m_pCurMask = nullptr;
return pDIBSource;
}
int CPDF_ImageCacheEntry::StartGetCachedBitmap(CPDF_Dictionary* pFormResources,
CPDF_Dictionary* pPageResources,
FX_BOOL bStdCS,
uint32_t GroupFamily,
FX_BOOL bLoadMask,
CPDF_RenderStatus* pRenderStatus,
int32_t downsampleWidth,
int32_t downsampleHeight) {
if (m_pCachedBitmap) {
m_pCurBitmap = m_pCachedBitmap;
m_pCurMask = m_pCachedMask;
return 1;
}
if (!pRenderStatus) {
return 0;
}
m_pRenderStatus = pRenderStatus;
m_pCurBitmap = new CPDF_DIBSource;
int ret =
((CPDF_DIBSource*)m_pCurBitmap)
->StartLoadDIBSource(m_pDocument, m_pStream, TRUE, pFormResources,
pPageResources, bStdCS, GroupFamily, bLoadMask);
if (ret == 2) {
return ret;
}
if (!ret) {
delete m_pCurBitmap;
m_pCurBitmap = nullptr;
return 0;
}
ContinueGetCachedBitmap();
return 0;
}
void CPDF_ImageCacheEntry::ContinueGetCachedBitmap() {
m_MatteColor = ((CPDF_DIBSource*)m_pCurBitmap)->GetMatteColor();
m_pCurMask = ((CPDF_DIBSource*)m_pCurBitmap)->DetachMask();
CPDF_RenderContext* pContext = m_pRenderStatus->GetContext();
CPDF_PageRenderCache* pPageRenderCache = pContext->GetPageCache();
m_dwTimeCount = pPageRenderCache->GetTimeCount();
if (m_pCurBitmap->GetPitch() * m_pCurBitmap->GetHeight() <
FPDF_HUGE_IMAGE_SIZE) {
m_pCachedBitmap = m_pCurBitmap->Clone();
delete m_pCurBitmap;
m_pCurBitmap = nullptr;
} else {
m_pCachedBitmap = m_pCurBitmap;
}
if (m_pCurMask) {
m_pCachedMask = m_pCurMask->Clone();
delete m_pCurMask;
m_pCurMask = nullptr;
}
m_pCurBitmap = m_pCachedBitmap;
m_pCurMask = m_pCachedMask;
CalcSize();
}
int CPDF_ImageCacheEntry::Continue(IFX_Pause* pPause) {
int ret = ((CPDF_DIBSource*)m_pCurBitmap)->ContinueLoadDIBSource(pPause);
if (ret == 2) {
return ret;
}
if (!ret) {
delete m_pCurBitmap;
m_pCurBitmap = nullptr;
return 0;
}
ContinueGetCachedBitmap();
return 0;
}
void CPDF_ImageCacheEntry::CalcSize() {
m_dwCacheSize = FPDF_ImageCache_EstimateImageSize(m_pCachedBitmap) +
FPDF_ImageCache_EstimateImageSize(m_pCachedMask);
}