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

Add direct getter for GrCaps to GrContext.

Browse Source 
TBR=joshualitt@google.com

Committed: https://skia.googlesource.com/skia/+/9138c46e572085870638b6f7ad7fcdfcdf3cac99

Review URL: https://codereview.chromium.org/1149773005
This commit is contained in:
bsalomon 2015-05-29 08:02:10 -07:00 committed by Commit bot
parent ff2f423d90
commit 7622863095
22 changed files with 55 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
bench/nanobench.cpp
View File

@ -43,6 +43,7 @@
#if SK_SUPPORT_GPU
#include "gl/GrGLDefines.h"
#include "GrCaps.h"
#include "GrContextFactory.h"
SkAutoTDelete<GrContextFactory> gGrFactory;
#endif
@ -372,7 +373,7 @@ static bool is_gpu_config_allowed(const char* name, GrContextFactory::GLContextT
return false;
}
if (const GrContext* ctx = gGrFactory->get(ctxType)) {
return sampleCnt <= ctx->getMaxSampleCount();
return sampleCnt <= ctx->caps()->maxSampleCount();
}
return false;
}

43
include/gpu/GrContext.h
View File

@ -20,6 +20,7 @@
class GrAARectRenderer;
class GrBatchFontCache;
class GrCaps;
struct GrContextOptions;
class GrDrawContext;
class GrDrawTarget;
@ -155,45 +156,8 @@ public:
*/
void purgeAllUnlockedResources();
//////////////////////////////////////////////////////////////////////////
/// Texture and Render Target Queries
/**
* Are shader derivatives supported?
*/
bool shaderDerivativeSupport() const;
/**
* Can the provided configuration act as a texture?
*/
bool isConfigTexturable(GrPixelConfig) const;
/**
* Can non-power-of-two textures be used with tile modes other than clamp?
*/
bool npotTextureTileSupport() const;
/**
* Return the max width or height of a texture supported by the current GPU.
*/
int getMaxTextureSize() const;
/**
* Can the provided configuration act as a color render target?
*/
bool isConfigRenderable(GrPixelConfig config, bool withMSAA) const;
/**
* Return the max width or height of a render target supported by the
* current GPU.
*/
int getMaxRenderTargetSize() const;
/**
* Returns the max sample count for a render target. It will be 0 if MSAA
* is not supported.
*/
int getMaxSampleCount() const;
/** Access the context capabilities */
const GrCaps* caps() const { return fCaps; }
/**
* Returns the recommended sample count for a render target when using this
@ -392,6 +356,7 @@ public:
private:
GrGpu* fGpu;
const GrCaps* fCaps;
GrResourceCache* fResourceCache;
// this union exists because the inheritance of GrTextureProvider->GrResourceProvider
// is in a private header.

3
src/core/SkPictureShader.cpp
View File

@ -17,6 +17,7 @@
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "GrCaps.h"
#endif
namespace {
@ -345,7 +346,7 @@ bool SkPictureShader::asFragmentProcessor(GrContext* context, const SkPaint& pai
GrFragmentProcessor** fp) const {
int maxTextureSize = 0;
if (context) {
maxTextureSize = context->getMaxTextureSize();
maxTextureSize = context->caps()->maxTextureSize();
}
SkAutoTUnref<SkShader> bitmapShader(this->refBitmapShader(viewM, localMatrix, maxTextureSize));
if (!bitmapShader) {

2
src/effects/SkAlphaThresholdFilter.cpp
View File

@ -271,7 +271,7 @@ bool SkAlphaThresholdFilterImpl::asFragmentProcessor(GrFragmentProcessor** fp,
if (fp) {
GrContext* context = texture->getContext();
GrSurfaceDesc maskDesc;
if (context->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
if (context->caps()->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
maskDesc.fConfig = kAlpha_8_GrPixelConfig;
} else {
maskDesc.fConfig = kRGBA_8888_GrPixelConfig;

3
src/effects/SkGpuBlurUtils.cpp
View File

@ -13,6 +13,7 @@
#include "effects/GrConvolutionEffect.h"
#include "effects/GrMatrixConvolutionEffect.h"
#include "GrContext.h"
#include "GrCaps.h"
#include "GrDrawContext.h"
#endif
@ -154,7 +155,7 @@ GrTexture* GaussianBlur(GrContext* context,
SkIRect clearRect;
int scaleFactorX, radiusX;
int scaleFactorY, radiusY;
int maxTextureSize = context->getMaxTextureSize();
int maxTextureSize = context->caps()->maxTextureSize();
sigmaX = adjust_sigma(sigmaX, maxTextureSize, &scaleFactorX, &radiusX);
sigmaY = adjust_sigma(sigmaY, maxTextureSize, &scaleFactorY, &radiusY);

4
src/gpu/GrAddPathRenderers_default.cpp
View File

@ -21,10 +21,10 @@
#endif
void GrPathRenderer::AddPathRenderers(GrContext* ctx, GrPathRendererChain* chain) {
chain->addPathRenderer(SkNEW_ARGS(GrDashLinePathRenderer, (ctx)))->unref();
chain->addPathRenderer(SkNEW(GrDashLinePathRenderer))->unref();
if (GrPathRenderer* pr = GrStencilAndCoverPathRenderer::Create(ctx->resourceProvider(),
*ctx->getGpu()->caps())) {
*ctx->caps())) {
chain->addPathRenderer(pr)->unref();
}
#if GR_TESSELLATING_PATH_RENDERING

2
src/gpu/GrAtlasTextContext.cpp
View File

@ -460,7 +460,7 @@ inline bool GrAtlasTextContext::canDrawAsDistanceFields(const SkPaint& skPaint,
// rasterizers and mask filters modify alpha, which doesn't
// translate well to distance
if (skPaint.getRasterizer() || skPaint.getMaskFilter() ||
!fContext->shaderDerivativeSupport()) {
!fContext->caps()->shaderCaps()->shaderDerivativeSupport()) {
return false;
}

3
src/gpu/GrBlurUtils.cpp
View File

@ -7,6 +7,7 @@
#include "GrBlurUtils.h"
#include "GrDrawContext.h"
#include "GrCaps.h"
#include "GrContext.h"
#include "effects/GrSimpleTextureEffect.h"
#include "GrStrokeInfo.h"
@ -110,7 +111,7 @@ static GrTexture* create_mask_GPU(GrContext* context,
// render target so default to RGBA_8888
desc.fConfig = kRGBA_8888_GrPixelConfig;
if (context->isConfigRenderable(kAlpha_8_GrPixelConfig, desc.fSampleCnt > 0)) {
if (context->caps()->isConfigRenderable(kAlpha_8_GrPixelConfig, desc.fSampleCnt > 0)) {
desc.fConfig = kAlpha_8_GrPixelConfig;
}

5
src/gpu/GrClipMaskManager.cpp
View File

@ -489,7 +489,7 @@ GrTexture* GrClipMaskManager::createTempMask(int width, int height) {
desc.fFlags = kRenderTarget_GrSurfaceFlag;
desc.fWidth = width;
desc.fHeight = height;
if (this->getContext()->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
if (this->getContext()->caps()->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
desc.fConfig = kAlpha_8_GrPixelConfig;
} else {
desc.fConfig = kRGBA_8888_GrPixelConfig;
@ -526,7 +526,8 @@ GrTexture* GrClipMaskManager::allocMaskTexture(int32_t elementsGenID,
desc.fWidth = clipSpaceIBounds.width();
desc.fHeight = clipSpaceIBounds.height();
desc.fConfig = kRGBA_8888_GrPixelConfig;
if (willUpload || this->getContext()->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
if (willUpload ||
this->getContext()->caps()->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
// We would always like A8 but it isn't supported on all platforms
desc.fConfig = kAlpha_8_GrPixelConfig;
}

34
src/gpu/GrContext.cpp
View File

@ -138,6 +138,7 @@ static int32_t next_id() {
GrContext::GrContext() : fUniqueID(next_id()) {
fGpu = NULL;
fCaps = NULL;
fResourceCache = NULL;
fResourceProvider = NULL;
fPathRendererChain = NULL;
@ -159,6 +160,7 @@ bool GrContext::init(GrBackend backend, GrBackendContext backendContext,
}
void GrContext::initCommon() {
fCaps = SkRef(fGpu->caps());
fResourceCache = SkNEW(GrResourceCache);
fResourceCache->setOverBudgetCallback(OverBudgetCB, this);
fResourceProvider = SkNEW_ARGS(GrResourceProvider, (fGpu, fResourceCache));
@ -177,6 +179,7 @@ void GrContext::initCommon() {
GrContext::~GrContext() {
if (!fGpu) {
SkASSERT(!fCaps);
return;
}
@ -191,6 +194,7 @@ GrContext::~GrContext() {
SkDELETE(fBatchFontCache);
fGpu->unref();
fCaps->unref();
SkSafeUnref(fPathRendererChain);
SkSafeUnref(fSoftwarePathRenderer);
}
@ -258,18 +262,6 @@ GrTextContext* GrContext::createTextContext(GrRenderTarget* renderTarget,
////////////////////////////////////////////////////////////////////////////////
bool GrContext::shaderDerivativeSupport() const {
return fGpu->caps()->shaderCaps()->shaderDerivativeSupport();
}
bool GrContext::isConfigTexturable(GrPixelConfig config) const {
return fGpu->caps()->isConfigTexturable(config);
}
bool GrContext::npotTextureTileSupport() const {
return fGpu->caps()->npotTextureTileSupport();
}
void GrContext::OverBudgetCB(void* data) {
SkASSERT(data);
@ -290,18 +282,6 @@ void GrContext::TextBlobCacheOverBudgetCB(void* data) {
context->flush();
}
int GrContext::getMaxTextureSize() const {
return fGpu->caps()->maxTextureSize();
}
int GrContext::getMaxRenderTargetSize() const {
return fGpu->caps()->maxRenderTargetSize();
}
int GrContext::getMaxSampleCount() const {
return fGpu->caps()->maxSampleCount();
}
////////////////////////////////////////////////////////////////////////////////
void GrContext::flush(int flagsBitfield) {
@ -687,13 +667,9 @@ GrPathRenderer* GrContext::getPathRenderer(const GrDrawTarget* target,
}
////////////////////////////////////////////////////////////////////////////////
bool GrContext::isConfigRenderable(GrPixelConfig config, bool withMSAA) const {
return fGpu->caps()->isConfigRenderable(config, withMSAA);
}
int GrContext::getRecommendedSampleCount(GrPixelConfig config,
SkScalar dpi) const {
if (!this->isConfigRenderable(config, true)) {
if (!this->caps()->isConfigRenderable(config, true)) {
return 0;
}
int chosenSampleCount = 0;

2
src/gpu/GrCoordTransform.cpp
View File

@ -27,7 +27,7 @@ void GrCoordTransform::reset(GrCoordSet sourceCoords, const SkMatrix& m, const G
int subPixelThresh = filter > GrTextureParams::kNone_FilterMode ? 4 : 1;
fPrecision = kDefault_GrSLPrecision;
if (texture->getContext()) {
const GrShaderCaps* caps = texture->getContext()->getGpu()->caps()->shaderCaps();
const GrShaderCaps* caps = texture->getContext()->caps()->shaderCaps();
if (caps->floatPrecisionVaries()) {
int maxD = SkTMax(texture->width(), texture->height());
const GrShaderCaps::PrecisionInfo* info;

7
src/gpu/GrDashLinePathRenderer.cpp
View File

@ -10,13 +10,6 @@
#include "GrGpu.h"
#include "effects/GrDashingEffect.h"
GrDashLinePathRenderer::GrDashLinePathRenderer(GrContext* context)
: fGpu(SkRef(context->getGpu())) {
}
GrDashLinePathRenderer::~GrDashLinePathRenderer() {
}
bool GrDashLinePathRenderer::canDrawPath(const GrDrawTarget* target,
const GrPipelineBuilder* pipelineBuilder,
const SkMatrix& viewMatrix,

3
src/gpu/GrDashLinePathRenderer.h
View File

@ -13,9 +13,6 @@
class GrDashLinePathRenderer : public GrPathRenderer {
public:
GrDashLinePathRenderer(GrContext*);
~GrDashLinePathRenderer();
bool canDrawPath(const GrDrawTarget*,
const GrPipelineBuilder*,
const SkMatrix& viewMatrix,

2
src/gpu/GrDrawTarget.cpp
View File

@ -32,7 +32,7 @@
GrDrawTarget::GrDrawTarget(GrContext* context)
: fContext(context)
, fCaps(SkRef(context->getGpu()->caps()))
, fCaps(SkRef(context->caps()))
, fGpuTraceMarkerCount(0)
, fFlushing(false) {
SkASSERT(context);

7
src/gpu/GrInOrderDrawBuffer.cpp
View File

@ -9,15 +9,14 @@
// We will use the reordering buffer, unless we have NVPR.
// TODO move NVPR to batch so we can reorder
static inline bool allow_reordering(const GrGpu* gpu) {
//const GrCaps* caps = gpu->caps();
//return caps && caps->shaderCaps() && !caps->shaderCaps()->pathRenderingSupport();
static inline bool allow_reordering(const GrCaps* caps) {
//return !caps->shaderCaps()->pathRenderingSupport();
return false;
}
GrInOrderDrawBuffer::GrInOrderDrawBuffer(GrContext* context)
: INHERITED(context)
, fCommands(GrCommandBuilder::Create(context->getGpu(), allow_reordering(context->getGpu())))
, fCommands(GrCommandBuilder::Create(context->getGpu(), allow_reordering(context->caps())))
, fPathIndexBuffer(kPathIdxBufferMinReserve * sizeof(char)/4)
, fPathTransformBuffer(kPathXformBufferMinReserve * sizeof(float)/4)
, fPipelineBuffer(kPipelineBufferMinReserve)

6
src/gpu/GrPathRendererChain.cpp
View File

@ -78,9 +78,9 @@ GrPathRenderer* GrPathRendererChain::getPathRenderer(const GrDrawTarget* target,
void GrPathRendererChain::init() {
SkASSERT(!fInit);
GrGpu* gpu = fOwner->getGpu();
bool twoSided = gpu->caps()->twoSidedStencilSupport();
bool wrapOp = gpu->caps()->stencilWrapOpsSupport();
const GrCaps* caps = fOwner->caps();
bool twoSided = caps->twoSidedStencilSupport();
bool wrapOp = caps->stencilWrapOpsSupport();
GrPathRenderer::AddPathRenderers(fOwner, this);
this->addPathRenderer(SkNEW_ARGS(GrDefaultPathRenderer,
(twoSided, wrapOp)))->unref();

8
src/gpu/GrSWMaskHelper.cpp
View File

@ -174,8 +174,8 @@ bool GrSWMaskHelper::init(const SkIRect& resultBounds,
resultBounds.height());
if (allowCompression &&
fContext->getGpu()->caps()->drawPathMasksToCompressedTexturesSupport() &&
choose_compressed_fmt(fContext->getGpu()->caps(), &fCompressedFormat)) {
fContext->caps()->drawPathMasksToCompressedTexturesSupport() &&
choose_compressed_fmt(fContext->caps(), &fCompressedFormat)) {
fCompressionMode = kCompress_CompressionMode;
}
@ -245,7 +245,7 @@ GrTexture* GrSWMaskHelper::createTexture() {
#endif
desc.fConfig = fmt_to_config(fCompressedFormat);
SkASSERT(fContext->getGpu()->caps()->isConfigTexturable(desc.fConfig));
SkASSERT(fContext->caps()->isConfigTexturable(desc.fConfig));
}
return fContext->textureProvider()->refScratchTexture(
@ -256,7 +256,7 @@ void GrSWMaskHelper::sendTextureData(GrTexture *texture, const GrSurfaceDesc& de
const void *data, size_t rowbytes) {
// If we aren't reusing scratch textures we don't need to flush before
// writing since no one else will be using 'texture'
bool reuseScratch = fContext->getGpu()->caps()->reuseScratchTextures();
bool reuseScratch = fContext->caps()->reuseScratchTextures();
// Since we're uploading to it, and it's compressed, 'texture' shouldn't
// have a render target.

8
src/gpu/SkGpuDevice.cpp
View File

@ -910,7 +910,7 @@ void SkGpuDevice::drawBitmapCommon(const SkDraw& draw,
// FIXME: the tiled bitmap code path doesn't currently support
// anti-aliased edges, we work around that for now by drawing directly
// if the image size exceeds maximum texture size.
int maxTextureSize = fContext->getMaxTextureSize();
int maxTextureSize = fContext->caps()->maxTextureSize();
bool directDraw = fRenderTarget->isMultisampled() ||
!paint.isAntiAlias() ||
bitmap.width() > maxTextureSize ||
@ -1034,7 +1034,7 @@ void SkGpuDevice::drawBitmapCommon(const SkDraw& draw,
}
params.setFilterMode(textureFilterMode);
int maxTileSize = fContext->getMaxTextureSize() - 2 * tileFilterPad;
int maxTileSize = fContext->caps()->maxTextureSize() - 2 * tileFilterPad;
int tileSize;
SkIRect clippedSrcRect;
@ -1163,8 +1163,8 @@ void SkGpuDevice::internalDrawBitmap(const SkBitmap& bitmap,
SkCanvas::DrawBitmapRectFlags flags,
bool bicubic,
bool needsTextureDomain) {
SkASSERT(bitmap.width() <= fContext->getMaxTextureSize() &&
bitmap.height() <= fContext->getMaxTextureSize());
SkASSERT(bitmap.width() <= fContext->caps()->maxTextureSize() &&
bitmap.height() <= fContext->caps()->maxTextureSize());
GrTexture* texture;
AutoBitmapTexture abt(fContext, bitmap, &params, &texture);

17
src/gpu/SkGr.cpp
View File

@ -7,6 +7,7 @@
#include "SkGr.h"
#include "GrCaps.h"
#include "GrDrawContext.h"
#include "GrXferProcessor.h"
#include "SkColorFilter.h"
@ -96,7 +97,7 @@ enum Stretch {
static Stretch get_stretch_type(const GrContext* ctx, int width, int height,
const GrTextureParams* params) {
if (params && params->isTiled()) {
if (!ctx->npotTextureTileSupport() && (!SkIsPow2(width) || !SkIsPow2(height))) {
if (!ctx->caps()->npotTextureTileSupport() && (!SkIsPow2(width) || !SkIsPow2(height))) {
switch(params->filterMode()) {
case GrTextureParams::kNone_FilterMode:
return kNearest_Stretch;
@ -198,6 +199,7 @@ GrTexture* stretch_texture_to_next_pot(GrTexture* inputTexture, Stretch stretch,
GrContext* context = inputTexture->getContext();
SkASSERT(context);
const GrCaps* caps = context->caps();
// Either it's a cache miss or the original wasn't cached to begin with.
GrSurfaceDesc rtDesc = inputTexture->desc();
@ -208,18 +210,18 @@ GrTexture* stretch_texture_to_next_pot(GrTexture* inputTexture, Stretch stretch,
// If the config isn't renderable try converting to either A8 or an 32 bit config. Otherwise,
// fail.
if (!context->isConfigRenderable(rtDesc.fConfig, false)) {
if (!caps->isConfigRenderable(rtDesc.fConfig, false)) {
if (GrPixelConfigIsAlphaOnly(rtDesc.fConfig)) {
if (context->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
if (caps->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
rtDesc.fConfig = kAlpha_8_GrPixelConfig;
} else if (context->isConfigRenderable(kSkia8888_GrPixelConfig, false)) {
} else if (caps->isConfigRenderable(kSkia8888_GrPixelConfig, false)) {
rtDesc.fConfig = kSkia8888_GrPixelConfig;
} else {
return NULL;
}
} else if (kRGB_GrColorComponentFlags ==
(kRGB_GrColorComponentFlags & GrPixelConfigComponentMask(rtDesc.fConfig))) {
if (context->isConfigRenderable(kSkia8888_GrPixelConfig, false)) {
if (caps->isConfigRenderable(kSkia8888_GrPixelConfig, false)) {
rtDesc.fConfig = kSkia8888_GrPixelConfig;
} else {
return NULL;
@ -423,9 +425,10 @@ static GrTexture* create_unstretched_bitmap_texture(GrContext* ctx,
GrSurfaceDesc desc;
generate_bitmap_texture_desc(*bitmap, &desc);
const GrCaps* caps = ctx->caps();
if (kIndex_8_SkColorType == bitmap->colorType()) {
if (ctx->isConfigTexturable(kIndex_8_GrPixelConfig)) {
if (caps->isConfigTexturable(kIndex_8_GrPixelConfig)) {
size_t imageSize = GrCompressedFormatDataSize(kIndex_8_GrPixelConfig,
bitmap->width(), bitmap->height());
SkAutoMalloc storage(imageSize);
@ -447,7 +450,7 @@ static GrTexture* create_unstretched_bitmap_texture(GrContext* ctx,
#ifndef SK_IGNORE_ETC1_SUPPORT
// Make sure that the underlying device supports ETC1 textures before we go ahead
// and check the data.
else if (ctx->isConfigTexturable(kETC1_GrPixelConfig)
else if (caps->isConfigTexturable(kETC1_GrPixelConfig)
// If the bitmap had compressed data and was then uncompressed, it'll still return
// compressed data on 'refEncodedData' and upload it. Probably not good, since if
// the bitmap has available pixels, then they might not be what the decompressed

2
tests/GrDrawTargetTest.cpp
View File

@ -29,7 +29,7 @@ DEF_GPUTEST(GrDrawTarget, reporter, factory) {
continue;
}
test_print(reporter, grContext->getGpu()->caps());
test_print(reporter, grContext->caps());
}
}

2
tests/GrPorterDuffTest.cpp
View File

@ -949,7 +949,7 @@ static void test_no_dual_source_blending(skiatest::Reporter* reporter) {
return;
}
const GrCaps& caps = *ctx->getGpu()->caps();
const GrCaps& caps = *ctx->caps();
if (caps.shaderCaps()->dualSourceBlendingSupport()) {
SkFAIL("Null context failed to honor request for no ARB_blend_func_extended.");
return;

5
tests/ResourceCacheTest.cpp
View File

@ -122,7 +122,7 @@ static void test_stencil_buffers(skiatest::Reporter* reporter, GrContext* contex
smallRT0->asRenderTarget()->renderTargetPriv().getStencilAttachment() !=
bigRT->asRenderTarget()->renderTargetPriv().getStencilAttachment());
if (context->getMaxSampleCount() >= 4) {
if (context->caps()->maxSampleCount() >= 4) {
// An RT with a different sample count should not share.
GrSurfaceDesc smallMSAADesc = smallDesc;
smallMSAADesc.fSampleCnt = 4;
@ -154,7 +154,8 @@ static void test_stencil_buffers(skiatest::Reporter* reporter, GrContext* contex
smallMSAART1->asRenderTarget()->renderTargetPriv().getStencilAttachment());
// But not one with a larger sample count should not. (Also check that the request for 4
// samples didn't get rounded up to >= 8 or else they could share.).
if (context->getMaxSampleCount() >= 8 && smallMSAART0 && smallMSAART0->asRenderTarget() &&
if (context->caps()->maxSampleCount() >= 8 &&
smallMSAART0 && smallMSAART0->asRenderTarget() &&
smallMSAART0->asRenderTarget()->numSamples() < 8) {
smallMSAADesc.fSampleCnt = 8;
smallMSAART1.reset(cache->createTexture(smallMSAADesc, false));