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 107 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);
 
+    SkTBlitterAllocator allocator;
+    SkBlitter* blitter = NULL;
+    if (kBlitter_CompressionMode == fCompressionMode) {
+        SkASSERT(NULL != fCompressedBuffer.get());
+        blitter = SkTextureCompressor::CreateBlitterForFormat(
+            fBM.width(), fBM.height(), fCompressedBuffer.get(), &allocator, fCompressedFormat);
+    }
+
     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);
     }
 }
 
 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) {
+    // 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 * ((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?
+        if (SkTextureCompressor::ExistsBlitterForFormat(fCompressedFormat)) {
+            int cmpSz = SkTextureCompressor::GetCompressedDataSize(
+                fCompressedFormat, cmpWidth, cmpHeight);
+
+            SkASSERT(cmpSz > 0);
+            SkASSERT(NULL == fCompressedBuffer.get());
+            fCompressedBuffer.reset(cmpSz);
+            fCompressionMode = kBlitter_CompressionMode;
+        }
+    } 
+
+    // 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 (!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.get());
+            this->sendTextureData(texture, desc, fCompressedBuffer.get(), 0);
+            break;
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 /**
  * 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);
 }