AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Move GrProcessorDataManager to GrMemoryPool

Browse Source 
TBR=bsalomon@google.com
BUG=skia:

Review URL: https://codereview.chromium.org/1225363002
This commit is contained in:
joshualitt 2015-07-10 07:26:21 -07:00 committed by Commit bot
parent 9764c40cd3
commit 5b4f05f709
6 changed files with 79 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
include/gpu/GrPaint.h
View File

@ -125,6 +125,7 @@ public:
fCoverageStages = paint.fCoverageStages;
fXPFactory.reset(SkRef(paint.getXPFactory()));
fProcDataManager.reset(SkNEW_ARGS(GrProcessorDataManager, (*paint.processorDataManager())));
return *this;
}
@ -137,18 +138,20 @@ public:
*/
bool isConstantBlendedColor(GrColor* constantColor) const;
GrProcessorDataManager* getProcessorDataManager() { return &fProcDataManager; }
GrProcessorDataManager* getProcessorDataManager() { return fProcDataManager.get(); }
const GrProcessorDataManager* processorDataManager() const { return fProcDataManager.get(); }
private:
mutable SkAutoTUnref<const GrXPFactory> fXPFactory;
SkSTArray<4, GrFragmentStage> fColorStages;
SkSTArray<2, GrFragmentStage> fCoverageStages;
SkSTArray<4, GrFragmentStage> fColorStages;
SkSTArray<2, GrFragmentStage> fCoverageStages;
bool fAntiAlias;
bool fDither;
bool fAntiAlias;
bool fDither;
GrColor fColor;
GrProcessorDataManager fProcDataManager;
GrColor fColor;
SkAutoTUnref<GrProcessorDataManager> fProcDataManager;
};
#endif

39
include/gpu/GrProcessorDataManager.h
View File

@ -8,6 +8,43 @@
#ifndef GrProcessorDataManager_DEFINED
#define GrProcessorDataManager_DEFINED
class GrProcessorDataManager {};
#include "SkRefCnt.h"
#include "SkTArray.h"
class GrProcessorDataManager : public SkRefCnt {
public:
GrProcessorDataManager() {}
GrProcessorDataManager(const GrProcessorDataManager& procDataManager) {
fIndices = procDataManager.fIndices;
fStorage = procDataManager.fStorage;
}
void* operator new(size_t size);
void operator delete(void* target);
void* operator new(size_t size, void* placement) {
return ::operator new(size, placement);
}
void operator delete(void* target, void* placement) {
::operator delete(target, placement);
}
private:
static const uint32_t kNumProcessor = 1;
static const uint32_t kDataIndicesPerProcessor = 1;
static const uint32_t kPreAllocDataPerProcessor = 1;
/*static const size_t kPreAllocStorage = kNumProcessor * kPreAllocDataPerProcessor;
static const uint32_t kNumProcessor = 8;
static const uint32_t kDataIndicesPerProcessor = 4;
static const uint32_t kPreAllocDataPerProcessor = kDataIndicesPerProcessor *
sizeof(GrCoordTransform);*/
static const size_t kPreAllocIndices = kNumProcessor * kDataIndicesPerProcessor;
static const size_t kPreAllocStorage = kNumProcessor * kPreAllocDataPerProcessor;
SkSTArray<kPreAllocIndices, uint32_t, true> fIndices;
SkSTArray<kPreAllocStorage, unsigned char, true> fStorage;
typedef SkRefCnt INHERITED;
};
#endif

11
src/gpu/GrPaint.cpp
View File

@ -16,7 +16,8 @@
GrPaint::GrPaint()
: fAntiAlias(false)
, fDither(false)
, fColor(GrColor_WHITE) {
, fColor(GrColor_WHITE)
, fProcDataManager(SkNEW(GrProcessorDataManager)) {
}
void GrPaint::setCoverageSetOpXPFactory(SkRegion::Op regionOp, bool invertCoverage) {
@ -24,26 +25,26 @@ void GrPaint::setCoverageSetOpXPFactory(SkRegion::Op regionOp, bool invertCovera
}
void GrPaint::addColorTextureProcessor(GrTexture* texture, const SkMatrix& matrix) {
this->addColorProcessor(GrSimpleTextureEffect::Create(&fProcDataManager, texture,
this->addColorProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture,
matrix))->unref();
}
void GrPaint::addCoverageTextureProcessor(GrTexture* texture, const SkMatrix& matrix) {
this->addCoverageProcessor(GrSimpleTextureEffect::Create(&fProcDataManager, texture,
this->addCoverageProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture,
matrix))->unref();
}
void GrPaint::addColorTextureProcessor(GrTexture* texture,
const SkMatrix& matrix,
const GrTextureParams& params) {
this->addColorProcessor(GrSimpleTextureEffect::Create(&fProcDataManager, texture, matrix,
this->addColorProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture, matrix,
params))->unref();
}
void GrPaint::addCoverageTextureProcessor(GrTexture* texture,
const SkMatrix& matrix,
const GrTextureParams& params) {
this->addCoverageProcessor(GrSimpleTextureEffect::Create(&fProcDataManager, texture, matrix,
this->addCoverageProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture, matrix,
params))->unref();
}

8
src/gpu/GrPipelineBuilder.cpp
View File

@ -16,7 +16,8 @@
#include "effects/GrPorterDuffXferProcessor.h"
GrPipelineBuilder::GrPipelineBuilder()
: fFlags(0x0)
: fProcDataManager(SkNEW(GrProcessorDataManager))
, fFlags(0x0)
, fDrawFace(kBoth_DrawFace)
, fColorProcInfoValid(false)
, fCoverageProcInfoValid(false)
@ -26,6 +27,7 @@ GrPipelineBuilder::GrPipelineBuilder()
}
GrPipelineBuilder& GrPipelineBuilder::operator=(const GrPipelineBuilder& that) {
fProcDataManager.reset(SkNEW_ARGS(GrProcessorDataManager, (*that.processorDataManager())));
fRenderTarget.reset(SkSafeRef(that.fRenderTarget.get()));
fFlags = that.fFlags;
fStencilSettings = that.fStencilSettings;
@ -51,6 +53,10 @@ GrPipelineBuilder& GrPipelineBuilder::operator=(const GrPipelineBuilder& that) {
GrPipelineBuilder::GrPipelineBuilder(const GrPaint& paint, GrRenderTarget* rt, const GrClip& clip) {
SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
// TODO keep this logically const using an AutoReset
fProcDataManager.reset(
const_cast<GrProcessorDataManager*>(SkRef(paint.processorDataManager())));
fColorStages.reset();
fCoverageStages.reset();

13
src/gpu/GrPipelineBuilder.h
View File

@ -84,26 +84,26 @@ public:
* Creates a GrSimpleTextureEffect that uses local coords as texture coordinates.
*/
void addColorTextureProcessor(GrTexture* texture, const SkMatrix& matrix) {
this->addColorProcessor(GrSimpleTextureEffect::Create(&fProcDataManager, texture,
this->addColorProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture,
matrix))->unref();
}
void addCoverageTextureProcessor(GrTexture* texture, const SkMatrix& matrix) {
this->addCoverageProcessor(GrSimpleTextureEffect::Create(&fProcDataManager, texture,
this->addCoverageProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture,
matrix))->unref();
}
void addColorTextureProcessor(GrTexture* texture,
const SkMatrix& matrix,
const GrTextureParams& params) {
this->addColorProcessor(GrSimpleTextureEffect::Create(&fProcDataManager, texture, matrix,
this->addColorProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture, matrix,
params))->unref();
}
void addCoverageTextureProcessor(GrTexture* texture,
const SkMatrix& matrix,
const GrTextureParams& params) {
this->addCoverageProcessor(GrSimpleTextureEffect::Create(&fProcDataManager, texture, matrix,
this->addCoverageProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture, matrix,
params))->unref();
}
@ -396,7 +396,8 @@ public:
void setClip(const GrClip& clip) { fClip = clip; }
const GrClip& clip() const { return fClip; }
GrProcessorDataManager* getProcessorDataManager() { return &fProcDataManager; }
GrProcessorDataManager* getProcessorDataManager() { return fProcDataManager.get(); }
const GrProcessorDataManager* processorDataManager() const { return fProcDataManager.get(); }
private:
// Calculating invariant color / coverage information is expensive, so we partially cache the
@ -438,7 +439,7 @@ private:
typedef SkSTArray<4, GrFragmentStage> FragmentStageArray;
GrProcessorDataManager fProcDataManager;
SkAutoTUnref<GrProcessorDataManager> fProcDataManager;
SkAutoTUnref<GrRenderTarget> fRenderTarget;
uint32_t fFlags;
GrStencilSettings fStencilSettings;

11
src/gpu/GrProcessor.cpp
View File

@ -157,3 +157,14 @@ void GrFragmentProcessor::computeInvariantOutput(GrInvariantOutput* inout) const
// Initial static variable from GrXPFactory
int32_t GrXPFactory::gCurrXPFClassID =
GrXPFactory::kIllegalXPFClassID;
///////////////////////////////////////////////////////////////////////////////////////////////////
// GrProcessorDataManager lives in the same pool
void* GrProcessorDataManager::operator new(size_t size) {
return MemoryPoolAccessor().pool()->allocate(size);
}
void GrProcessorDataManager::operator delete(void* target) {
return MemoryPoolAccessor().pool()->release(target);
}