blob: f998a928ccfbae1c99927cd03e3e9329e337f273 [file] [log] [blame]
/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkMaskCache.h"
#define CHECK_LOCAL(localCache, localName, globalName, ...) \
((localCache) ? localCache->localName(__VA_ARGS__) : SkResourceCache::globalName(__VA_ARGS__))
struct MaskValue {
SkMask fMask;
SkCachedData* fData;
};
namespace {
static unsigned gRRectBlurKeyNamespaceLabel;
struct RRectBlurKey : public SkResourceCache::Key {
public:
RRectBlurKey(SkScalar sigma, const SkRRect& rrect, SkBlurStyle style, SkBlurQuality quality)
: fSigma(sigma)
, fStyle(style)
, fQuality(quality)
, fRRect(rrect)
{
this->init(&gRRectBlurKeyNamespaceLabel, 0,
sizeof(fSigma) + sizeof(fStyle) + sizeof(fQuality) + sizeof(fRRect));
}
SkScalar fSigma;
int32_t fStyle;
int32_t fQuality;
SkRRect fRRect;
};
struct RRectBlurRec : public SkResourceCache::Rec {
RRectBlurRec(RRectBlurKey key, const SkMask& mask, SkCachedData* data)
: fKey(key)
{
fValue.fMask = mask;
fValue.fData = data;
fValue.fData->attachToCacheAndRef();
}
~RRectBlurRec() override {
fValue.fData->detachFromCacheAndUnref();
}
RRectBlurKey fKey;
MaskValue fValue;
const Key& getKey() const override { return fKey; }
size_t bytesUsed() const override { return sizeof(*this) + fValue.fData->size(); }
const char* getCategory() const override { return "rrect-blur"; }
SkDiscardableMemory* diagnostic_only_getDiscardable() const override {
return fValue.fData->diagnostic_only_getDiscardable();
}
static bool Visitor(const SkResourceCache::Rec& baseRec, void* contextData) {
const RRectBlurRec& rec = static_cast<const RRectBlurRec&>(baseRec);
MaskValue* result = (MaskValue*)contextData;
SkCachedData* tmpData = rec.fValue.fData;
tmpData->ref();
if (nullptr == tmpData->data()) {
tmpData->unref();
return false;
}
*result = rec.fValue;
return true;
}
};
} // namespace
SkCachedData* SkMaskCache::FindAndRef(SkScalar sigma, SkBlurStyle style, SkBlurQuality quality,
const SkRRect& rrect, SkMask* mask, SkResourceCache* localCache) {
MaskValue result;
RRectBlurKey key(sigma, rrect, style, quality);
if (!CHECK_LOCAL(localCache, find, Find, key, RRectBlurRec::Visitor, &result)) {
return nullptr;
}
*mask = result.fMask;
mask->fImage = (uint8_t*)(result.fData->data());
return result.fData;
}
void SkMaskCache::Add(SkScalar sigma, SkBlurStyle style, SkBlurQuality quality,
const SkRRect& rrect, const SkMask& mask, SkCachedData* data,
SkResourceCache* localCache) {
RRectBlurKey key(sigma, rrect, style, quality);
return CHECK_LOCAL(localCache, add, Add, new RRectBlurRec(key, mask, data));
}
//////////////////////////////////////////////////////////////////////////////////////////
namespace {
static unsigned gRectsBlurKeyNamespaceLabel;
struct RectsBlurKey : public SkResourceCache::Key {
public:
RectsBlurKey(SkScalar sigma, SkBlurStyle style, SkBlurQuality quality,
const SkRect rects[], int count)
: fSigma(sigma)
, fStyle(style)
, fQuality(quality)
{
SkASSERT(1 == count || 2 == count);
SkIRect ir;
rects[0].roundOut(&ir);
fSizes[0] = SkSize{rects[0].width(), rects[0].height()};
if (2 == count) {
fSizes[1] = SkSize{rects[1].width(), rects[1].height()};
fSizes[2] = SkSize{rects[0].x() - rects[1].x(), rects[0].y() - rects[1].y()};
} else {
fSizes[1] = SkSize{0, 0};
fSizes[2] = SkSize{0, 0};
}
fSizes[3] = SkSize{rects[0].x() - ir.x(), rects[0].y() - ir.y()};
this->init(&gRectsBlurKeyNamespaceLabel, 0,
sizeof(fSigma) + sizeof(fStyle) + sizeof(fQuality) + sizeof(fSizes));
}
SkScalar fSigma;
int32_t fStyle;
int32_t fQuality;
SkSize fSizes[4];
};
struct RectsBlurRec : public SkResourceCache::Rec {
RectsBlurRec(RectsBlurKey key, const SkMask& mask, SkCachedData* data)
: fKey(key)
{
fValue.fMask = mask;
fValue.fData = data;
fValue.fData->attachToCacheAndRef();
}
~RectsBlurRec() override {
fValue.fData->detachFromCacheAndUnref();
}
RectsBlurKey fKey;
MaskValue fValue;
const Key& getKey() const override { return fKey; }
size_t bytesUsed() const override { return sizeof(*this) + fValue.fData->size(); }
const char* getCategory() const override { return "rects-blur"; }
SkDiscardableMemory* diagnostic_only_getDiscardable() const override {
return fValue.fData->diagnostic_only_getDiscardable();
}
static bool Visitor(const SkResourceCache::Rec& baseRec, void* contextData) {
const RectsBlurRec& rec = static_cast<const RectsBlurRec&>(baseRec);
MaskValue* result = static_cast<MaskValue*>(contextData);
SkCachedData* tmpData = rec.fValue.fData;
tmpData->ref();
if (nullptr == tmpData->data()) {
tmpData->unref();
return false;
}
*result = rec.fValue;
return true;
}
};
} // namespace
SkCachedData* SkMaskCache::FindAndRef(SkScalar sigma, SkBlurStyle style, SkBlurQuality quality,
const SkRect rects[], int count, SkMask* mask,
SkResourceCache* localCache) {
MaskValue result;
RectsBlurKey key(sigma, style, quality, rects, count);
if (!CHECK_LOCAL(localCache, find, Find, key, RectsBlurRec::Visitor, &result)) {
return nullptr;
}
*mask = result.fMask;
mask->fImage = (uint8_t*)(result.fData->data());
return result.fData;
}
void SkMaskCache::Add(SkScalar sigma, SkBlurStyle style, SkBlurQuality quality,
const SkRect rects[], int count, const SkMask& mask, SkCachedData* data,
SkResourceCache* localCache) {
RectsBlurKey key(sigma, style, quality, rects, count);
return CHECK_LOCAL(localCache, add, Add, new RectsBlurRec(key, mask, data));
}