From 9837740dd59fa2461e5d6e6cd36cdc93567b5717 Mon Sep 17 00:00:00 2001 From: robertphillips Date: Fri, 13 May 2016 05:47:23 -0700 Subject: Simplify GrSWMaskHelper GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1974943002 Review-Url: https://codereview.chromium.org/1974943002 --- bench/nanobench.cpp | 3 - include/gpu/GrCaps.h | 5 - include/gpu/GrContextOptions.h | 8 +- src/gpu/GrCaps.cpp | 1 - src/gpu/GrClipMaskManager.cpp | 12 +-- src/gpu/GrSWMaskHelper.cpp | 205 +++++------------------------------------ src/gpu/GrSWMaskHelper.h | 44 ++------- src/gpu/SkGr.cpp | 1 - 8 files changed, 35 insertions(+), 244 deletions(-) diff --git a/bench/nanobench.cpp b/bench/nanobench.cpp index 69f1c4f988..8bc40cc460 100644 --- a/bench/nanobench.cpp +++ b/bench/nanobench.cpp @@ -98,8 +98,6 @@ DEFINE_double(overheadGoal, 0.0001, "Loop until timer overhead is at most this fraction of our measurments."); DEFINE_double(gpuMs, 5, "Target bench time in millseconds for GPU."); DEFINE_int32(gpuFrameLag, 5, "If unknown, estimated maximum number of frames GPU allows to lag."); -DEFINE_bool(gpuCompressAlphaMasks, false, "Compress masks generated from falling back to " - "software path rendering."); DEFINE_string(outResultsFile, "", "If given, write results here as JSON."); DEFINE_int32(maxCalibrationAttempts, 3, @@ -1036,7 +1034,6 @@ int nanobench_main() { #if SK_SUPPORT_GPU GrContextOptions grContextOpts; - grContextOpts.fDrawPathToCompressedTexture = FLAGS_gpuCompressAlphaMasks; gGrFactory.reset(new GrContextFactory(grContextOpts)); #endif diff --git a/include/gpu/GrCaps.h b/include/gpu/GrCaps.h index e28b49488a..9fe727c425 100644 --- a/include/gpu/GrCaps.h +++ b/include/gpu/GrCaps.h @@ -255,10 +255,6 @@ public: bool immediateFlush() const { return fImmediateFlush; } - bool drawPathMasksToCompressedTexturesSupport() const { - return fDrawPathMasksToCompressedTextureSupport; - } - size_t bufferMapThreshold() const { SkASSERT(fBufferMapThreshold >= 0); return fBufferMapThreshold; @@ -333,7 +329,6 @@ private: bool fSuppressPrints : 1; bool fImmediateFlush: 1; - bool fDrawPathMasksToCompressedTextureSupport : 1; typedef SkRefCnt INHERITED; }; diff --git a/include/gpu/GrContextOptions.h b/include/gpu/GrContextOptions.h index 4e763405e1..7b62c94a44 100644 --- a/include/gpu/GrContextOptions.h +++ b/include/gpu/GrContextOptions.h @@ -12,8 +12,7 @@ struct GrContextOptions { GrContextOptions() - : fDrawPathToCompressedTexture(false) - , fSuppressPrints(false) + : fSuppressPrints(false) , fMaxTextureSizeOverride(SK_MaxS32) , fMaxTileSizeOverride(0) , fSuppressDualSourceBlending(false) @@ -26,11 +25,6 @@ struct GrContextOptions { , fMaxBatchLookahead(-1) , fUseShaderSwizzling(false) {} - // EXPERIMENTAL - // May be removed in the future, or may become standard depending - // on the outcomes of a variety of internal tests. - bool fDrawPathToCompressedTexture; - // Suppress prints for the GrContext. bool fSuppressPrints; diff --git a/src/gpu/GrCaps.cpp b/src/gpu/GrCaps.cpp index cdc9ba7057..b524e3ff11 100644 --- a/src/gpu/GrCaps.cpp +++ b/src/gpu/GrCaps.cpp @@ -118,7 +118,6 @@ GrCaps::GrCaps(const GrContextOptions& options) { fSuppressPrints = options.fSuppressPrints; fImmediateFlush = options.fImmediateMode; - fDrawPathMasksToCompressedTextureSupport = options.fDrawPathToCompressedTexture; fBufferMapThreshold = options.fBufferMapThreshold; fUseDrawInsteadOfPartialRenderTargetWrite = options.fUseDrawInsteadOfPartialRenderTargetWrite; fUseDrawInsteadOfAllRenderTargetWrites = false; diff --git a/src/gpu/GrClipMaskManager.cpp b/src/gpu/GrClipMaskManager.cpp index 08a69205d7..da128fb5c0 100644 --- a/src/gpu/GrClipMaskManager.cpp +++ b/src/gpu/GrClipMaskManager.cpp @@ -861,7 +861,7 @@ GrTexture* GrClipMaskManager::CreateSoftwareClipMask(GrContext* context, SkMatrix translate; translate.setTranslate(clipToMaskOffset); - helper.init(maskSpaceIBounds, &translate, false); + helper.init(maskSpaceIBounds, &translate); helper.clear(GrReducedClip::kAllIn_InitialState == initialState ? 0xFF : 0x00); for (GrReducedClip::ElementList::Iter iter(elements.headIter()) ; iter.get(); iter.next()) { @@ -876,24 +876,24 @@ GrTexture* GrClipMaskManager::CreateSoftwareClipMask(GrContext* context, if (SkRegion::kReverseDifference_Op == op) { SkRect temp = SkRect::Make(clipSpaceIBounds); // invert the entire scene - helper.draw(temp, SkRegion::kXOR_Op, false, 0xFF); + helper.drawRect(temp, SkRegion::kXOR_Op, false, 0xFF); } SkPath clipPath; element->asPath(&clipPath); clipPath.toggleInverseFillType(); - helper.draw(clipPath, GrStyle::SimpleFill(), SkRegion::kReplace_Op, element->isAA(), - 0x00); + helper.drawPath(clipPath, GrStyle::SimpleFill(), SkRegion::kReplace_Op, + element->isAA(), 0x00); continue; } // The other ops (union, xor, diff) only affect pixels inside // the geometry so they can just be drawn normally if (Element::kRect_Type == element->getType()) { - helper.draw(element->getRect(), op, element->isAA(), 0xFF); + helper.drawRect(element->getRect(), op, element->isAA(), 0xFF); } else { SkPath path; element->asPath(&path); - helper.draw(path, GrStyle::SimpleFill(), op, element->isAA(), 0xFF); + helper.drawPath(path, GrStyle::SimpleFill(), op, element->isAA(), 0xFF); } } diff --git a/src/gpu/GrSWMaskHelper.cpp b/src/gpu/GrSWMaskHelper.cpp index c89c58ee35..4486bb079c 100644 --- a/src/gpu/GrSWMaskHelper.cpp +++ b/src/gpu/GrSWMaskHelper.cpp @@ -19,12 +19,10 @@ #include "batches/GrRectBatchFactory.h" -namespace { - /* * Convert a boolean operation into a transfer mode code */ -SkXfermode::Mode op_to_mode(SkRegion::Op op) { +static SkXfermode::Mode op_to_mode(SkRegion::Op op) { static const SkXfermode::Mode modeMap[] = { SkXfermode::kDstOut_Mode, // kDifference_Op @@ -38,76 +36,13 @@ SkXfermode::Mode op_to_mode(SkRegion::Op op) { return modeMap[op]; } -static inline GrPixelConfig fmt_to_config(SkTextureCompressor::Format fmt) { - - GrPixelConfig config; - switch (fmt) { - case SkTextureCompressor::kLATC_Format: - config = kLATC_GrPixelConfig; - break; - - case SkTextureCompressor::kR11_EAC_Format: - config = kR11_EAC_GrPixelConfig; - break; - - case SkTextureCompressor::kASTC_12x12_Format: - config = kASTC_12x12_GrPixelConfig; - break; - - case SkTextureCompressor::kETC1_Format: - config = kETC1_GrPixelConfig; - break; - - default: - SkDEBUGFAIL("No GrPixelConfig for compression format!"); - // Best guess - config = kAlpha_8_GrPixelConfig; - break; - } - - return config; -} - -static bool choose_compressed_fmt(const GrCaps* caps, - SkTextureCompressor::Format *fmt) { - if (nullptr == fmt) { - return false; - } - - // We can't use scratch textures without the ability to update - // compressed textures... - if (!(caps->compressedTexSubImageSupport())) { - return false; - } - - // Figure out what our preferred texture type is. If ASTC is available, that always - // gives the biggest win. Otherwise, in terms of compression speed and accuracy, - // LATC has a slight edge over R11 EAC. - if (caps->isConfigTexturable(kASTC_12x12_GrPixelConfig)) { - *fmt = SkTextureCompressor::kASTC_12x12_Format; - return true; - } else if (caps->isConfigTexturable(kLATC_GrPixelConfig)) { - *fmt = SkTextureCompressor::kLATC_Format; - return true; - } else if (caps->isConfigTexturable(kR11_EAC_GrPixelConfig)) { - *fmt = SkTextureCompressor::kR11_EAC_Format; - return true; - } - - return false; -} - -} - /** * Draw a single rect element of the clip stack into the accumulation bitmap */ -void GrSWMaskHelper::draw(const SkRect& rect, SkRegion::Op op, - bool antiAlias, uint8_t alpha) { +void GrSWMaskHelper::drawRect(const SkRect& rect, SkRegion::Op op, + bool antiAlias, uint8_t alpha) { SkPaint paint; - SkASSERT(kNone_CompressionMode == fCompressionMode); - paint.setXfermode(SkXfermode::Make(op_to_mode(op))); paint.setAntiAlias(antiAlias); paint.setColor(SkColorSetARGB(alpha, alpha, alpha, alpha)); @@ -118,35 +53,24 @@ void GrSWMaskHelper::draw(const SkRect& rect, SkRegion::Op op, /** * Draw a single path element of the clip stack into the accumulation bitmap */ -void GrSWMaskHelper::draw(const SkPath& path, const GrStyle& style, SkRegion::Op op, - bool antiAlias, uint8_t alpha) { +void GrSWMaskHelper::drawPath(const SkPath& path, const GrStyle& style, SkRegion::Op op, + bool antiAlias, uint8_t alpha) { SkPaint paint; paint.setPathEffect(sk_ref_sp(style.pathEffect())); style.strokeRec().applyToPaint(&paint); paint.setAntiAlias(antiAlias); - SkTBlitterAllocator allocator; - SkBlitter* blitter = nullptr; - if (kBlitter_CompressionMode == fCompressionMode) { - SkASSERT(fCompressedBuffer.get()); - blitter = SkTextureCompressor::CreateBlitterForFormat( - fPixels.width(), fPixels.height(), fCompressedBuffer.get(), &allocator, - fCompressedFormat); - } - if (SkRegion::kReplace_Op == op && 0xFF == alpha) { SkASSERT(0xFF == paint.getAlpha()); - fDraw.drawPathCoverage(path, paint, blitter); + fDraw.drawPathCoverage(path, paint); } else { paint.setXfermodeMode(op_to_mode(op)); paint.setColor(SkColorSetARGB(alpha, alpha, alpha, alpha)); - fDraw.drawPath(path, paint, blitter); + fDraw.drawPath(path, paint); } } -bool GrSWMaskHelper::init(const SkIRect& resultBounds, - const SkMatrix* matrix, - bool allowCompression) { +bool GrSWMaskHelper::init(const SkIRect& resultBounds, const SkMatrix* matrix) { if (matrix) { fMatrix = *matrix; } else { @@ -154,54 +78,16 @@ bool GrSWMaskHelper::init(const SkIRect& resultBounds, } // Now translate so the bound's UL corner is at the origin - fMatrix.postTranslate(-resultBounds.fLeft * SK_Scalar1, - -resultBounds.fTop * SK_Scalar1); - SkIRect bounds = SkIRect::MakeWH(resultBounds.width(), - resultBounds.height()); - - if (allowCompression && - fContext->caps()->drawPathMasksToCompressedTexturesSupport() && - choose_compressed_fmt(fContext->caps(), &fCompressedFormat)) { - fCompressionMode = kCompress_CompressionMode; - } + fMatrix.postTranslate(-SkIntToScalar(resultBounds.fLeft), -SkIntToScalar(resultBounds.fTop)); + SkIRect bounds = SkIRect::MakeWH(resultBounds.width(), resultBounds.height()); - // Make sure that the width is a multiple of the desired block dimensions - // to allow for specialized SIMD instructions that compress multiple blocks at a time. - int cmpWidth = bounds.fRight; - int cmpHeight = bounds.fBottom; - if (kCompress_CompressionMode == fCompressionMode) { - int dimX, dimY; - SkTextureCompressor::GetBlockDimensions(fCompressedFormat, &dimX, &dimY); - cmpWidth = dimX * ((cmpWidth + (dimX - 1)) / dimX); - cmpHeight = dimY * ((cmpHeight + (dimY - 1)) / dimY); - - // Can we create a blitter? - if (SkTextureCompressor::ExistsBlitterForFormat(fCompressedFormat)) { - int cmpSz = SkTextureCompressor::GetCompressedDataSize( - fCompressedFormat, cmpWidth, cmpHeight); - - SkASSERT(cmpSz > 0); - SkASSERT(nullptr == fCompressedBuffer.get()); - fCompressedBuffer.reset(cmpSz); - fCompressionMode = kBlitter_CompressionMode; - } + const SkImageInfo bmImageInfo = SkImageInfo::MakeA8(bounds.width(), bounds.height()); + if (!fPixels.tryAlloc(bmImageInfo)) { + return false; } + fPixels.erase(0); sk_bzero(&fDraw, sizeof(fDraw)); - - // If we don't have a custom blitter, then we either need a bitmap to compress - // from or a bitmap that we're going to use as a texture. In any case, we should - // allocate the pixels for a bitmap - const SkImageInfo bmImageInfo = SkImageInfo::MakeA8(cmpWidth, cmpHeight); - if (kBlitter_CompressionMode != fCompressionMode) { - if (!fPixels.tryAlloc(bmImageInfo)) { - return false; - } - fPixels.erase(0); - } else { - // Otherwise, we just need to remember how big the buffer is... - fPixels.reset(bmImageInfo); - } fDraw.fDst = fPixels; fRasterClip.setRect(bounds); fDraw.fRC = &fRasterClip; @@ -218,67 +104,20 @@ GrTexture* GrSWMaskHelper::createTexture() { desc.fHeight = fPixels.height(); desc.fConfig = kAlpha_8_GrPixelConfig; - if (kNone_CompressionMode != fCompressionMode) { - -#ifdef SK_DEBUG - int dimX, dimY; - SkTextureCompressor::GetBlockDimensions(fCompressedFormat, &dimX, &dimY); - SkASSERT((desc.fWidth % dimX) == 0); - SkASSERT((desc.fHeight % dimY) == 0); -#endif - - desc.fConfig = fmt_to_config(fCompressedFormat); - SkASSERT(fContext->caps()->isConfigTexturable(desc.fConfig)); - } - return fContext->textureProvider()->createApproxTexture(desc); } -void GrSWMaskHelper::sendTextureData(GrTexture *texture, const GrSurfaceDesc& desc, - const void *data, size_t rowbytes) { - // Since we're uploading to it, and it's compressed, 'texture' shouldn't - // have a render target. - SkASSERT(nullptr == texture->asRenderTarget()); - - texture->writePixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig, data, rowbytes); -} - -void GrSWMaskHelper::compressTextureData(GrTexture *texture, const GrSurfaceDesc& desc) { - - SkASSERT(GrPixelConfigIsCompressed(desc.fConfig)); - SkASSERT(fmt_to_config(fCompressedFormat) == desc.fConfig); - - SkAutoDataUnref cmpData(SkTextureCompressor::CompressBitmapToFormat(fPixels, - fCompressedFormat)); - SkASSERT(cmpData); - - this->sendTextureData(texture, desc, cmpData->data(), 0); -} - /** * Move the result of the software mask generation back to the gpu */ void GrSWMaskHelper::toTexture(GrTexture *texture) { - GrSurfaceDesc desc; - desc.fWidth = fPixels.width(); - desc.fHeight = fPixels.height(); - desc.fConfig = texture->config(); - - // First see if we should compress this texture before uploading. - switch (fCompressionMode) { - case kNone_CompressionMode: - this->sendTextureData(texture, desc, fPixels.addr(), fPixels.rowBytes()); - break; - - case kCompress_CompressionMode: - this->compressTextureData(texture, desc); - break; - - case kBlitter_CompressionMode: - SkASSERT(fCompressedBuffer.get()); - this->sendTextureData(texture, desc, fCompressedBuffer.get(), 0); - break; - } + // Since we're uploading to it, and it's compressed, 'texture' shouldn't + // have a render target. + SkASSERT(!texture->asRenderTarget()); + + texture->writePixels(0, 0, fPixels.width(), fPixels.height(), texture->config(), + fPixels.addr(), fPixels.rowBytes()); + } /** @@ -307,7 +146,7 @@ GrTexture* GrSWMaskHelper::DrawPathMaskToTexture(GrContext* context, return nullptr; } - helper.draw(path, style, SkRegion::kReplace_Op, antiAlias, 0xFF); + helper.drawPath(path, style, SkRegion::kReplace_Op, antiAlias, 0xFF); GrTexture* texture(helper.createTexture()); if (!texture) { diff --git a/src/gpu/GrSWMaskHelper.h b/src/gpu/GrSWMaskHelper.h index 63d7d64178..b329dd627e 100644 --- a/src/gpu/GrSWMaskHelper.h +++ b/src/gpu/GrSWMaskHelper.h @@ -16,7 +16,6 @@ #include "SkMatrix.h" #include "SkRasterClip.h" #include "SkRegion.h" -#include "SkTextureCompressor.h" #include "SkTypes.h" class GrClip; @@ -42,24 +41,20 @@ class GrDrawTarget; */ class GrSWMaskHelper : SkNoncopyable { public: - GrSWMaskHelper(GrContext* context) - : fContext(context) - , fCompressionMode(kNone_CompressionMode) { - } + GrSWMaskHelper(GrContext* context) : fContext(context) { } // set up the internal state in preparation for draws. Since many masks // may be accumulated in the helper during creation, "resultBounds" // allows the caller to specify the region of interest - to limit the - // amount of work. allowCompression should be set to false if you plan on using - // your own texture to draw into, and not a scratch texture via getTexture(). - bool init(const SkIRect& resultBounds, const SkMatrix* matrix, bool allowCompression = true); + // amount of work. + bool init(const SkIRect& resultBounds, const SkMatrix* matrix); // Draw a single rect into the accumulation bitmap using the specified op - void draw(const SkRect& rect, SkRegion::Op op, bool antiAlias, uint8_t alpha); + void drawRect(const SkRect& rect, SkRegion::Op op, bool antiAlias, uint8_t alpha); // Draw a single path into the accumuation bitmap using the specified op - void draw(const SkPath& path, const GrStyle& style, SkRegion::Op op, - bool antiAlias, uint8_t alpha); + void drawPath(const SkPath& path, const GrStyle& style, SkRegion::Op op, + bool antiAlias, uint8_t alpha); // Move the mask generation results from the internal bitmap to the gpu. void toTexture(GrTexture* texture); @@ -110,33 +105,6 @@ private: SkDraw fDraw; SkRasterClip fRasterClip; - // This enum says whether or not we should compress the mask: - // kNone_CompressionMode: compression is not supported on this device. - // kCompress_CompressionMode: compress the bitmap before it gets sent to the gpu - // kBlitter_CompressionMode: write to the bitmap using a special compressed blitter. - enum CompressionMode { - kNone_CompressionMode, - kCompress_CompressionMode, - kBlitter_CompressionMode, - } fCompressionMode; - - // This is the buffer into which we store our compressed data. This buffer is - // only allocated (non-null) if fCompressionMode is kBlitter_CompressionMode - SkAutoMalloc fCompressedBuffer; - - // This is the desired format within which to compress the - // texture. This value is only valid if fCompressionMode is not kNone_CompressionMode. - SkTextureCompressor::Format fCompressedFormat; - - // Actually sends the texture data to the GPU. This is called from - // toTexture with the data filled in depending on the texture config. - void sendTextureData(GrTexture *texture, const GrSurfaceDesc& desc, - const void *data, size_t rowbytes); - - // Compresses the bitmap stored in fBM and sends the compressed data - // to the GPU to be stored in 'texture' using sendTextureData. - void compressTextureData(GrTexture *texture, const GrSurfaceDesc& desc); - typedef SkNoncopyable INHERITED; }; diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp index 120db1348c..2127c36744 100644 --- a/src/gpu/SkGr.cpp +++ b/src/gpu/SkGr.cpp @@ -29,7 +29,6 @@ #include "SkPixelRef.h" #include "SkResourceCache.h" #include "SkTemplates.h" -#include "SkTextureCompressor.h" #include "SkYUVPlanesCache.h" #include "effects/GrBicubicEffect.h" #include "effects/GrConstColorProcessor.h" -- cgit v1.2.3