Make "alpha only" be a property of GrTextureProducer

src/gpu/SkGpuDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGpuDevice.h"
 
 #include "GrBlurUtils.h"
@@ skipping 812 matching lines @@
 
     return this->shouldTileImageID(image->unique(), image->bounds(), viewMatrix, params, srcRectPtr,
                                    maxTileSize, &outTileSize, &outClippedSrcRect);
 }
 
 void SkGpuDevice::drawBitmap(const SkDraw& origDraw,
                              const SkBitmap& bitmap,
                              const SkMatrix& m,
                              const SkPaint& paint) {
     CHECK_SHOULD_DRAW(origDraw);
-    bool alphaOnly = kAlpha_8_SkColorType == bitmap.colorType();
     SkMatrix viewMatrix;
     viewMatrix.setConcat(*origDraw.fMatrix, m);
     if (bitmap.getTexture()) {
         GrBitmapTextureAdjuster adjuster(&bitmap);
         // We can use kFast here because we know texture-backed bitmaps don't support extractSubset.
-        this->drawTextureProducer(&adjuster, alphaOnly, nullptr, nullptr,
-                                  SkCanvas::kFast_SrcRectConstraint, viewMatrix, fClip, paint);
+        this->drawTextureProducer(&adjuster, nullptr, nullptr, SkCanvas::kFast_SrcRectConstraint,
+                                  viewMatrix, fClip, paint);
         return;
     }
     int maxTileSize = fContext->caps()->maxTileSize();
 
     // The tile code path doesn't currently support AA, so if the paint asked for aa and we could
     // draw untiled, then we bypass checking for tiling purely for optimization reasons.
     bool drawAA = !fRenderTarget->isUnifiedMultisampled() &&
                   paint.isAntiAlias() &&
                   bitmap.width() <= maxTileSize &&
                   bitmap.height() <= maxTileSize;
@@ skipping 24 matching lines @@
 
         int maxTileSizeForFilter = fContext->caps()->maxTileSize() - 2 * tileFilterPad;
         if (this->shouldTileBitmap(bitmap, viewMatrix, params, &srcRect,
                                    maxTileSizeForFilter, &tileSize, &clippedSrcRect)) {
             this->drawTiledBitmap(bitmap, viewMatrix, srcRect, clippedSrcRect, params, paint,
                                   SkCanvas::kStrict_SrcRectConstraint, tileSize, doBicubic);
             return;
         }
     }
     GrBitmapTextureMaker maker(fContext, bitmap);
-    this->drawTextureProducer(&maker, alphaOnly, nullptr, nullptr,
-                              SkCanvas::kStrict_SrcRectConstraint, viewMatrix, fClip, paint);
+    this->drawTextureProducer(&maker, nullptr, nullptr, SkCanvas::kStrict_SrcRectConstraint,
+                              viewMatrix, fClip, paint);
 }
 
 // This method outsets 'iRect' by 'outset' all around and then clamps its extents to
 // 'clamp'. 'offset' is adjusted to remain positioned over the top-left corner
 // of 'iRect' for all possible outsets/clamps.
 static inline void clamped_outset_with_offset(SkIRect* iRect,
                                               int outset,
                                               SkPoint* offset,
                                               const SkIRect& clamp) {
     iRect->outset(outset, outset);
@@ skipping 311 matching lines @@
                                                   SkIntToScalar(h)),
                                  SkRect::MakeXYWH(0,
                                                   0,
                                                   SK_Scalar1 * w / texture->width(),
                                                   SK_Scalar1 * h / texture->height()));
 }
 
 void SkGpuDevice::drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap,
                                  const SkRect* src, const SkRect& origDst,
                                  const SkPaint& paint, SkCanvas::SrcRectConstraint constraint) {
-    bool alphaOnly = kAlpha_8_SkColorType == bitmap.colorType();
     if (bitmap.getTexture()) {
         CHECK_SHOULD_DRAW(draw);
         GrBitmapTextureAdjuster adjuster(&bitmap);
-        this->drawTextureProducer(&adjuster, alphaOnly, src, &origDst, constraint, *draw.fMatrix,
-                                  fClip, paint);
+        this->drawTextureProducer(&adjuster, src, &origDst, constraint, *draw.fMatrix, fClip,
+                                  paint);
         return;
     }
     // The src rect is inferred to be the bmp bounds if not provided. Otherwise, the src rect must
     // be clipped to the bmp bounds. To determine tiling parameters we need the filter mode which
     // in turn requires knowing the src-to-dst mapping. If the src was clipped to the bmp bounds
     // then we use the src-to-dst mapping to compute a new clipped dst rect.
     const SkRect* dst = &origDst;
     const SkRect bmpBounds = SkRect::MakeIWH(bitmap.width(), bitmap.height());
     // Compute matrix from the two rectangles
     if (!src) {
@@ skipping 56 matching lines @@
         viewMatrix.preTranslate(dst->fLeft, dst->fTop);
         viewMatrix.preScale(dst->width()/src->width(), dst->height()/src->height());
         if (this->shouldTileBitmap(bitmap, viewMatrix, params, src,
                                    maxTileSizeForFilter, &tileSize, &clippedSrcRect)) {
             this->drawTiledBitmap(bitmap, viewMatrix, *src, clippedSrcRect, params, paint,
                                   constraint, tileSize, doBicubic);
             return;
         }
     }
     GrBitmapTextureMaker maker(fContext, bitmap);
-    this->drawTextureProducer(&maker, alphaOnly, src, dst, constraint, *draw.fMatrix, fClip, paint);
+    this->drawTextureProducer(&maker, src, dst, constraint, *draw.fMatrix, fClip, paint);
 }
 
 void SkGpuDevice::drawDevice(const SkDraw& draw, SkBaseDevice* device,
                              int x, int y, const SkPaint& paint) {
     // clear of the source device must occur before CHECK_SHOULD_DRAW
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawDevice", fContext);
     SkGpuDevice* dev = static_cast<SkGpuDevice*>(device);
 
     // TODO: If the source device covers the whole of this device, we could
     // omit fNeedsClear -related flushing.
@@ skipping 94 matching lines @@
     }
 
     return this->filterTexture(fContext, texture, src.width(), src.height(),
                                filter, ctx, result, offset);
 }
 
 void SkGpuDevice::drawImage(const SkDraw& draw, const SkImage* image, SkScalar x, SkScalar y,
                             const SkPaint& paint) {
     SkMatrix viewMatrix = *draw.fMatrix;
     viewMatrix.preTranslate(x, y);
-    if (GrTexture* tex = as_IB(image)->peekTexture()) {
+    if (as_IB(image)->peekTexture()) {
         CHECK_SHOULD_DRAW(draw);
-        bool alphaOnly = GrPixelConfigIsAlphaOnly(tex->config());
         GrImageTextureAdjuster adjuster(as_IB(image));
-        this->drawTextureProducer(&adjuster, alphaOnly, nullptr, nullptr,
-                                  SkCanvas::kFast_SrcRectConstraint, viewMatrix, fClip, paint);
+        this->drawTextureProducer(&adjuster, nullptr, nullptr, SkCanvas::kFast_SrcRectConstraint,
+                                  viewMatrix, fClip, paint);
         return;
     } else {
         SkBitmap bm;
         if (this->shouldTileImage(image, nullptr, SkCanvas::kFast_SrcRectConstraint,
                                   paint.getFilterQuality(), *draw.fMatrix)) {
             // only support tiling as bitmap at the moment, so force raster-version
             if (!as_IB(image)->getROPixels(&bm)) {
                 return;
             }
             this->drawBitmap(draw, bm, SkMatrix::MakeTrans(x, y), paint);
         } else if (SkImageCacherator* cacher = as_IB(image)->peekCacherator()) {
             CHECK_SHOULD_DRAW(draw);
             GrImageTextureMaker maker(fContext, cacher, image, SkImage::kAllow_CachingHint);
-            bool alphaOnly = kAlpha_8_SkColorType == cacher->info().colorType();
-            this->drawTextureProducer(&maker, alphaOnly, nullptr, nullptr,
-                                      SkCanvas::kFast_SrcRectConstraint, viewMatrix, fClip, paint);
+            this->drawTextureProducer(&maker, nullptr, nullptr, SkCanvas::kFast_SrcRectConstraint,
+                                      viewMatrix, fClip, paint);
         } else if (as_IB(image)->getROPixels(&bm)) {
             this->drawBitmap(draw, bm, SkMatrix::MakeTrans(x, y), paint);
         }
     }
 }
 
 void SkGpuDevice::drawImageRect(const SkDraw& draw, const SkImage* image, const SkRect* src,
                                 const SkRect& dst, const SkPaint& paint,
                                 SkCanvas::SrcRectConstraint constraint) {
-    if (GrTexture* tex = as_IB(image)->peekTexture()) {
+    if (as_IB(image)->peekTexture()) {
         CHECK_SHOULD_DRAW(draw);
         GrImageTextureAdjuster adjuster(as_IB(image));
-        bool alphaOnly = GrPixelConfigIsAlphaOnly(tex->config());
-        this->drawTextureProducer(&adjuster, alphaOnly, src, &dst, constraint, *draw.fMatrix,
-                                  fClip, paint);
+        this->drawTextureProducer(&adjuster, src, &dst, constraint, *draw.fMatrix, fClip, paint);
         return;
     }
     SkBitmap bm;
     SkMatrix totalMatrix = *draw.fMatrix;
     totalMatrix.preScale(dst.width() / (src ? src->width() : image->width()),
                          dst.height() / (src ? src->height() : image->height()));
     if (this->shouldTileImage(image, src, constraint, paint.getFilterQuality(), totalMatrix)) {
         // only support tiling as bitmap at the moment, so force raster-version
         if (!as_IB(image)->getROPixels(&bm)) {
             return;
         }
         this->drawBitmapRect(draw, bm, src, dst, paint, constraint);
     } else if (SkImageCacherator* cacher = as_IB(image)->peekCacherator()) {
         CHECK_SHOULD_DRAW(draw);
         GrImageTextureMaker maker(fContext, cacher, image, SkImage::kAllow_CachingHint);
-        bool alphaOnly = kAlpha_8_SkColorType == cacher->info().colorType();
-        this->drawTextureProducer(&maker, alphaOnly, src, &dst, constraint, *draw.fMatrix,
-                                  fClip, paint);
+        this->drawTextureProducer(&maker, src, &dst, constraint, *draw.fMatrix, fClip, paint);
     } else if (as_IB(image)->getROPixels(&bm)) {
         this->drawBitmapRect(draw, bm, src, dst, paint, constraint);
     }
 }
 
-void SkGpuDevice::drawProducerNine(const SkDraw& draw, GrTextureProducer* producer, bool alphaOnly,
+void SkGpuDevice::drawProducerNine(const SkDraw& draw, GrTextureProducer* producer,
                                    const SkIRect& center, const SkRect& dst, const SkPaint& paint) {
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawProducerNine", fContext);
 
     CHECK_FOR_ANNOTATION(paint);
     CHECK_SHOULD_DRAW(draw);
 
     bool useFallback = paint.getMaskFilter() || paint.isAntiAlias() ||
                        fRenderTarget->isUnifiedMultisampled();
     bool doBicubic;
     GrTextureParams::FilterMode textureFilterMode =
         GrSkFilterQualityToGrFilterMode(paint.getFilterQuality(), *draw.fMatrix, SkMatrix::I(),
                                         &doBicubic);
     if (useFallback || doBicubic || GrTextureParams::kNone_FilterMode != textureFilterMode) {
         SkNinePatchIter iter(producer->width(), producer->height(), center, dst);
 
         SkRect srcR, dstR;
         while (iter.next(&srcR, &dstR)) {
-            this->drawTextureProducer(producer, alphaOnly, &srcR, &dstR,
-                                      SkCanvas::kStrict_SrcRectConstraint,  *draw.fMatrix, fClip,
-                                      paint);
+            this->drawTextureProducer(producer, &srcR, &dstR, SkCanvas::kStrict_SrcRectConstraint, 
+                                      *draw.fMatrix, fClip, paint);
         }
         return;
     }
 
     static const GrTextureParams::FilterMode kMode = GrTextureParams::kNone_FilterMode;
     SkAutoTUnref<const GrFragmentProcessor> fp(
         producer->createFragmentProcessor(SkMatrix::I(),
                                           SkRect::MakeIWH(producer->width(), producer->height()),
                                           GrTextureProducer::kNo_FilterConstraint, true,
                                           &kMode));
     GrPaint grPaint;
     if (!SkPaintToGrPaintWithTexture(this->context(), paint, *draw.fMatrix, fp,
-                                     alphaOnly, &grPaint)) {
+                                     producer->isAlphaOnly(), &grPaint)) {
         return;
     }
 
     fDrawContext->drawImageNine(fClip, grPaint, *draw.fMatrix, producer->width(),
                                 producer->height(), center, dst);
 }
 
 void SkGpuDevice::drawImageNine(const SkDraw& draw, const SkImage* image,
                                 const SkIRect& center, const SkRect& dst, const SkPaint& paint) {
-    if (GrTexture* tex = as_IB(image)->peekTexture()) {
-        bool alphaOnly = GrPixelConfigIsAlphaOnly(tex->config());
+    if (as_IB(image)->peekTexture()) {
         GrImageTextureAdjuster adjuster(as_IB(image));
-        this->drawProducerNine(draw, &adjuster, alphaOnly, center, dst, paint);
+        this->drawProducerNine(draw, &adjuster, center, dst, paint);
     } else {
         SkBitmap bm;
         if (SkImageCacherator* cacher = as_IB(image)->peekCacherator()) {
             GrImageTextureMaker maker(fContext, cacher, image, SkImage::kAllow_CachingHint);
-            bool alphaOnly = kAlpha_8_SkColorType == cacher->info().colorType();
-            this->drawProducerNine(draw, &maker, alphaOnly, center, dst, paint);
+            this->drawProducerNine(draw, &maker, center, dst, paint);
         } else if (as_IB(image)->getROPixels(&bm)) {
             this->drawBitmapNine(draw, bm, center, dst, paint);
         }
     }
 }
 
 void SkGpuDevice::drawBitmapNine(const SkDraw& draw, const SkBitmap& bitmap, const SkIRect& center,
                                  const SkRect& dst, const SkPaint& paint) {
-    bool alphaOnly = kAlpha_8_SkColorType == bitmap.colorType();
     if (bitmap.getTexture()) {
         GrBitmapTextureAdjuster adjuster(&bitmap);
-        this->drawProducerNine(draw, &adjuster, alphaOnly, center, dst, paint);
+        this->drawProducerNine(draw, &adjuster, center, dst, paint);
     } else {
         GrBitmapTextureMaker maker(fContext, bitmap);
-        this->drawProducerNine(draw, &maker, alphaOnly, center, dst, paint);
+        this->drawProducerNine(draw, &maker, center, dst, paint);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // must be in SkCanvas::VertexMode order
 static const GrPrimitiveType gVertexMode2PrimitiveType[] = {
     kTriangles_GrPrimitiveType,
     kTriangleStrip_GrPrimitiveType,
     kTriangleFan_GrPrimitiveType,
@@ skipping 333 matching lines @@
     return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
 }
 
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkGpuDevice::NewImageFilterCache();
 }
 
 #endif