Pass compressed blitters to our mask drawing algorithm

src/gpu/GrSWMaskHelper.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrSWMaskHelper.h"
 
 #include "GrDrawState.h"
@@ skipping 67 matching lines @@
         *fmt = SkTextureCompressor::kR11_EAC_Format;
         return true;
     }
 
     return false;
 }
 #endif
 
 }
 
+GrSWMaskHelper::~GrSWMaskHelper() {
+    if (NULL != fCompressedBlitter) {
+        delete fCompressedBlitter;
+        fCompressedBlitter = NULL;
+    }
+
+    if (NULL != fCompressedBuffer) {
+        sk_free(fCompressedBuffer);
+        fCompressedBuffer = NULL;
+    }
+}
+
 /**
  * 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) {
     SkPaint paint;
 
     SkXfermode* mode = SkXfermode::Create(op_to_mode(op));
 
     paint.setXfermode(mode);
@@ skipping 20 matching lines @@
             paint.setStyle(SkPaint::kFill_Style);
         } else {
             paint.setStyle(SkPaint::kStroke_Style);
             paint.setStrokeJoin(stroke.getJoin());
             paint.setStrokeCap(stroke.getCap());
             paint.setStrokeWidth(stroke.getWidth());
         }
     }
     paint.setAntiAlias(antiAlias);
 
+    SkBlitter* blitter = NULL;
+    if (kBlitter_CompressionMode == fCompressionMode) {
+        blitter = fCompressedBlitter;
+    }
+
     if (SkRegion::kReplace_Op == op && 0xFF == alpha) {
         SkASSERT(0xFF == paint.getAlpha());
-        fDraw.drawPathCoverage(path, paint);
+        fDraw.drawPathCoverage(path, paint, blitter);
     } else {
         paint.setXfermodeMode(op_to_mode(op));
         paint.setColor(SkColorSetARGB(alpha, alpha, alpha, alpha));
-        fDraw.drawPath(path, paint);
+        fDraw.drawPath(path, paint, blitter);
+    }
+

[robertphillips, 2014/08/06 20:54:49]

Get reset -> Get rid of ?

[krajcevski, 2014/08/06 22:41:59]

Done.

+    // Get reset the blitter, since we're done using it, and it might
+    // need to do some final cleanup for its cached scanlines
+    if (NULL != fCompressedBlitter) {
+        SkASSERT(kBlitter_CompressionMode == fCompressionMode);
+        SkASSERT(blitter == fCompressedBlitter);  // we used the compressed blitter
+        delete fCompressedBlitter;
+        fCompressedBlitter = NULL;
     }
 }
 
 bool GrSWMaskHelper::init(const SkIRect& resultBounds,
                           const SkMatrix* matrix) {
     if (NULL != matrix) {
         fMatrix = *matrix;
     } else {
         fMatrix.setIdentity();
     }
 
     // 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 GR_COMPRESS_ALPHA_MASK
-    fCompressMask = choose_compressed_fmt(fContext->getGpu()->caps(), &fCompressedFormat);
-#else
-    fCompressMask = false;
+    if (choose_compressed_fmt(fContext->getGpu()->caps(), &fCompressedFormat)) {
+        fCompressionMode = kCompress_CompressionMode;
+    }
 #endif
 
     // Make sure that the width is a multiple of 16 so that we can use
     // specialized SIMD instructions that compress 4 blocks at a time.
-    int cmpWidth, cmpHeight;
-    if (fCompressMask) {
+    int cmpWidth = bounds.fRight;
+    int cmpHeight = bounds.fBottom;
+    if (kCompress_CompressionMode == fCompressionMode) {
         int dimX, dimY;
         SkTextureCompressor::GetBlockDimensions(fCompressedFormat, &dimX, &dimY);
-        cmpWidth = dimX * ((bounds.fRight + (dimX - 1)) / dimX);
-        cmpHeight = dimY * ((bounds.fBottom + (dimY - 1)) / dimY);
+        cmpWidth = dimX * ((cmpWidth + (dimX - 1)) / dimX);
+        cmpHeight = dimY * ((cmpHeight + (dimY - 1)) / dimY);
+
+        // Can we create a blitter?
+        int cmpSz = SkTextureCompressor::GetCompressedDataSize(
+            fCompressedFormat, cmpWidth, cmpHeight);
+
+        if (cmpSz > 0) {
+            fCompressedBuffer = sk_malloc_throw(cmpSz);
+            fCompressedBlitter = SkTextureCompressor::CreateBlitterForFormat(
+                cmpWidth, cmpHeight, fCompressedBuffer, fCompressedFormat);
+
+            if (NULL != fCompressedBlitter) {
+                fCompressionMode = kBlitter_CompressionMode;
+            } else {
+                fCompressionMode = kCompress_CompressionMode;
+                sk_free(fCompressedBuffer);
+            }
+        }
+    } 
+

[robertphillips, 2014/08/06 20:54:48]

If blitter creation failed in the above couldn't we wind up with munged cmpWidth
& cmpHeight values here?

[krajcevski, 2014/08/06 22:41:59]

Yes, but the munged ones only happen if we have a compression method. If we
can't make a blitter we can at least compress the mask that we create (which
still needs munged dimensions).

+    // If we don't have a custom blitter, then we need a bitmap
+    // to compress into.
+    const SkImageInfo bmImageInfo = SkImageInfo::MakeA8(cmpWidth, cmpHeight);
+    if (kBlitter_CompressionMode != fCompressionMode) {
+        if (!fBM.allocPixels(bmImageInfo)) {
+            return false;
+        }
+
+        sk_bzero(fBM.getPixels(), fBM.getSafeSize());
     } else {
-        cmpWidth = bounds.fRight;
-        cmpHeight = bounds.fBottom;
+        // Otherwise, we just need to remember how big the buffer is...
+        fBM.setInfo(bmImageInfo);
     }
 
-    if (!fBM.allocPixels(SkImageInfo::MakeA8(cmpWidth, cmpHeight))) {
-        return false;
-    }
+    sk_bzero(&fDraw, sizeof(fDraw));
 
-    sk_bzero(fBM.getPixels(), fBM.getSafeSize());
-
-    sk_bzero(&fDraw, sizeof(fDraw));
     fRasterClip.setRect(bounds);
     fDraw.fRC    = &fRasterClip;
     fDraw.fClip  = &fRasterClip.bwRgn();
     fDraw.fMatrix = &fMatrix;
     fDraw.fBitmap = &fBM;
     return true;
 }
 
 /**
  * Get a texture (from the texture cache) of the correct size & format.
  * Return true on success; false on failure.
  */
 bool GrSWMaskHelper::getTexture(GrAutoScratchTexture* texture) {
     GrTextureDesc desc;
     desc.fWidth = fBM.width();
     desc.fHeight = fBM.height();
     desc.fConfig = kAlpha_8_GrPixelConfig;
 
-    if (fCompressMask) {
+    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);
-
-        // If this config isn't supported then we should fall back to A8
-        if (!(fContext->getGpu()->caps()->isConfigTexturable(desc.fConfig))) {
-            SkDEBUGFAIL("Determining compression should be set from choose_compressed_fmt");
-            desc.fConfig = kAlpha_8_GrPixelConfig;
-        }
+        SkASSERT(fContext->getGpu()->caps()->isConfigTexturable(desc.fConfig));
     }
 
     texture->set(fContext, desc);
     return NULL != texture->texture();
 }
 
 void GrSWMaskHelper::sendTextureData(GrTexture *texture, const GrTextureDesc& desc,
                                      const void *data, int rowbytes) {
     // If we aren't reusing scratch textures we don't need to flush before
     // writing since no one else will be using 'texture'
@@ skipping 24 matching lines @@
  */
 void GrSWMaskHelper::toTexture(GrTexture *texture) {
     SkAutoLockPixels alp(fBM);
 
     GrTextureDesc desc;
     desc.fWidth = fBM.width();
     desc.fHeight = fBM.height();
     desc.fConfig = texture->config();
         
     // First see if we should compress this texture before uploading.
-    if (fCompressMask) {
-        this->compressTextureData(texture, desc);
-    } else {
-        // Looks like we have to send a full A8 texture. 
-        this->sendTextureData(texture, desc, fBM.getPixels(), fBM.rowBytes());
+    switch (fCompressionMode) {
+        case kNone_CompressionMode:
+            this->sendTextureData(texture, desc, fBM.getPixels(), fBM.rowBytes());
+            break;
+
+        case kCompress_CompressionMode:
+            this->compressTextureData(texture, desc);
+            break;
+
+        case kBlitter_CompressionMode:
+            SkASSERT(NULL != fCompressedBuffer);
+            this->sendTextureData(texture, desc, fCompressedBuffer, 0);

[robertphillips, 2014/08/06 20:54:48]

break; ? for consistency.

[krajcevski, 2014/08/06 22:41:59]

Done.

     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 /**
  * Software rasterizes path to A8 mask (possibly using the context's matrix)
  * and uploads the result to a scratch texture. Returns the resulting
  * texture on success; NULL on failure.
  */
 GrTexture* GrSWMaskHelper::DrawPathMaskToTexture(GrContext* context,
@@ skipping 46 matching lines @@
     maskMatrix.preConcat(drawState->getViewMatrix());
 
     drawState->addCoverageEffect(
                          GrSimpleTextureEffect::Create(texture,
                                                        maskMatrix,
                                                        GrTextureParams::kNone_FilterMode,
                                                        kPosition_GrCoordSet))->unref();
 
     target->drawSimpleRect(dstRect);
 }