Add an LATC compressor to the A8 masks, and hide it behind an ifdef.

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"
 #include "GrDrawTargetCaps.h"
 #include "GrGpu.h"
 
 #include "SkStrokeRec.h"
 
+#if GR_COMPRESS_ALPHA_MASK

[robertphillips, 2014/06/10 22:19:46]

no extra space here

[krajcevski, 2014/06/10 22:28:46]

Done.

+#  include "SkData.h"
+#  include "SkTextureCompressor.h"
+#endif
 // TODO: try to remove this #include
 #include "GrContext.h"
 
 namespace {
+
 /*
  * Convert a boolean operation into a transfer mode code
  */
 SkXfermode::Mode op_to_mode(SkRegion::Op op) {
 
     static const SkXfermode::Mode modeMap[] = {
         SkXfermode::kDstOut_Mode,   // kDifference_Op
         SkXfermode::kModulate_Mode, // kIntersect_Op
         SkXfermode::kSrcOver_Mode,  // kUnion_Op
         SkXfermode::kXor_Mode,      // kXOR_Op
@@ skipping 91 matching lines @@
 bool GrSWMaskHelper::getTexture(GrAutoScratchTexture* texture) {
     GrTextureDesc desc;
     desc.fWidth = fBM.width();
     desc.fHeight = fBM.height();
     desc.fConfig = kAlpha_8_GrPixelConfig;
 
     texture->set(fContext, desc);
     return NULL != texture->texture();
 }
 
+GrTexture* GrSWMaskHelper::toLATCTexture(GrContext* ctx) {
+#if GR_COMPRESS_ALPHA_MASK
+    // Encode the BM into LATC data:

[robertphillips, 2014/06/10 22:19:46]

Can just use fBM - don't need this-> in this case.

[krajcevski, 2014/06/10 22:28:46]

Done.

+    SkAutoLockPixels alp(this->fBM);
+    SkTextureCompressor::Format format = SkTextureCompressor::kLATC_Format;
+    SkAutoDataUnref latcData(SkTextureCompressor::CompressBitmapToFormat(this->fBM, format));
+    if (NULL == latcData) {
+        return NULL;
+    }
+
+    GrTextureDesc desc;
+    desc.fWidth = this->fBM.width();
+    desc.fHeight = this->fBM.height();
+    desc.fConfig = kLATC_GrPixelConfig;
+    return ctx->getGpu()->createTexture(desc, latcData->bytes(), 0);
+#else
+    return NULL;
+#endif
+}
+
 /**
  * Move the result of the software mask generation back to the gpu
  */
 void GrSWMaskHelper::toTexture(GrTexture *texture) {
     SkAutoLockPixels alp(fBM);
 
     // 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();
 
@@ skipping 11 matching lines @@
  * 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,
                                                  const SkPath& path,
                                                  const SkStrokeRec& stroke,
                                                  const SkIRect& resultBounds,
                                                  bool antiAlias,
                                                  SkMatrix* matrix) {
-    GrAutoScratchTexture ast;
-
     GrSWMaskHelper helper(context);
 
     if (!helper.init(resultBounds, matrix)) {
         return NULL;
     }
 
     helper.draw(path, stroke, SkRegion::kReplace_Op, antiAlias, 0xFF);
 

[robertphillips, 2014/06/10 22:19:46]

Given the flag usage in toLATCTexture we probably don't need it here as well.

[krajcevski, 2014/06/10 22:28:46]

Done.

+#if GR_COMPRESS_ALPHA_MASK 
+    // Can we create an LATC texture?
+    GrTexture *latc = helper.toLATCTexture(context);
+    if (NULL != latc) {
+        return latc;
+    }
+#endif
+
+    // Looks like we have to send a full A8 texture. 
+    GrAutoScratchTexture ast;
     if (!helper.getTexture(&ast)) {
         return NULL;
     }
 
     helper.toTexture(ast.texture());
 
     return ast.detach();
 }
 
 void GrSWMaskHelper::DrawToTargetWithPathMask(GrTexture* texture,
@@ skipping 22 matching lines @@
     maskMatrix.preConcat(drawState->getViewMatrix());
 
     drawState->addCoverageEffect(
                          GrSimpleTextureEffect::Create(texture,
                                                        maskMatrix,
                                                        GrTextureParams::kNone_FilterMode,
                                                        kPosition_GrCoordSet))->unref();
 
     target->drawSimpleRect(dstRect);
 }