Separate out natively-texture image/bmp draws from cached-as-texture image/bmp draws

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"
 #include "GrContext.h"
 #include "GrDrawContext.h"
 #include "GrFontScaler.h"
 #include "GrGpu.h"
 #include "GrGpuResourcePriv.h"
+#include "GrImageIDTextureAdjuster.h"
 #include "GrLayerHoister.h"
 #include "GrRecordReplaceDraw.h"
 #include "GrStrokeInfo.h"
 #include "GrTextContext.h"
 #include "GrTracing.h"
 #include "SkCanvasPriv.h"
 #include "SkDrawProcs.h"
 #include "SkErrorInternals.h"
 #include "SkGlyphCache.h"
 #include "SkGrTexturePixelRef.h"
@@ skipping 814 matching lines @@
 void SkGpuDevice::drawBitmap(const SkDraw& origDraw,
                              const SkBitmap& bitmap,
                              const SkMatrix& m,
                              const SkPaint& paint) {
     SkMatrix concat;
     SkTCopyOnFirstWrite<SkDraw> draw(origDraw);
     if (!m.isIdentity()) {
         concat.setConcat(*draw->fMatrix, m);
         draw.writable()->fMatrix = &concat;
     }
+
+    GrTexture* texture = bitmap.getTexture();
+    if (texture) {
+        CHECK_SHOULD_DRAW(*draw);
+        // src and dst rects are the same.
+        SkRect rect = SkRect::MakeWH(SkIntToScalar(bitmap.width()), SkIntToScalar(bitmap.height()));
+        // Since the src rect is the bitmap dimensions, no need to enforce a bleed constraint.
+        static const SkCanvas::SrcRectConstraint kSrcRectConstraint =
+            SkCanvas::kFast_SrcRectConstraint;
+        bool alphaBitmap = kAlpha_8_SkColorType == bitmap.colorType();
+        this->drawTextureRect(&GrBitmapTextureAdjuster(&bitmap), alphaBitmap, rect,
+                              rect, *draw->fMatrix, fClip, paint, kSrcRectConstraint);
+        return;
+    }
     this->drawBitmapCommon(*draw, bitmap, nullptr, nullptr, paint, SkCanvas::kStrict_SrcRectConstraint);
 }
 
 // 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) {
@@ skipping 317 matching lines @@
     }
 }
 
 // Break 'bitmap' into several tiles to draw it since it has already
 // been determined to be too large to fit in VRAM
 void SkGpuDevice::drawTiledBitmap(const SkBitmap& bitmap,
                                   const SkMatrix& viewMatrix,
                                   const SkRect& srcRect,
                                   const SkIRect& clippedSrcIRect,
                                   const GrTextureParams& params,
-                                  const SkPaint& paint,
+                                  const SkPaint& origPaint,
                                   SkCanvas::SrcRectConstraint constraint,
                                   int tileSize,
                                   bool bicubic) {
     // The following pixel lock is technically redundant, but it is desirable
     // to lock outside of the tile loop to prevent redecoding the whole image
     // at each tile in cases where 'bitmap' holds an SkDiscardablePixelRef that
     // is larger than the limit of the discardable memory pool.
     SkAutoLockPixels alp(bitmap);
+
+    const SkPaint* paint = &origPaint;
+    SkPaint tempPaint;
+    if (origPaint.isAntiAlias() && !fRenderTarget->isUnifiedMultisampled()) {
+        // Drop antialiasing to avoid seams at tile boundaries.
+        tempPaint = origPaint;
+        tempPaint.setAntiAlias(false);
+        paint = &tempPaint;
+    }
     SkRect clippedSrcRect = SkRect::Make(clippedSrcIRect);
 
     int nx = bitmap.width() / tileSize;
     int ny = bitmap.height() / tileSize;
     for (int x = 0; x <= nx; x++) {
         for (int y = 0; y <= ny; y++) {
             SkRect tileR;
             tileR.set(SkIntToScalar(x * tileSize),
                       SkIntToScalar(y * tileSize),
                       SkIntToScalar((x + 1) * tileSize),
@@ skipping 41 matching lines @@
                 tileR.offset(-offset.fX, -offset.fY);
                 GrTextureParams paramsTemp = params;
                 bool needsTextureDomain = needs_texture_domain(
                                                          bitmap, srcRect, paramsTemp,
                                                          viewM, bicubic,
                                                          fRenderTarget->isUnifiedMultisampled());
                 this->internalDrawBitmap(tmpB,
                                          viewM,
                                          tileR,
                                          paramsTemp,
-                                         paint,
+                                         *paint,
                                          constraint,
                                          bicubic,
                                          needsTextureDomain);
             }
         }
     }
 }
 
 
 /*
@@ skipping 207 matching lines @@
                                                   SkIntToScalar(h)),
                                  SkRect::MakeXYWH(0,
                                                   0,
                                                   SK_Scalar1 * w / texture->width(),
                                                   SK_Scalar1 * h / texture->height()));
 }
 
 void SkGpuDevice::drawBitmapRect(const SkDraw& origDraw, const SkBitmap& bitmap,
                                  const SkRect* src, const SkRect& dst,
                                  const SkPaint& paint, SkCanvas::SrcRectConstraint constraint) {
+    SkBitmap bm;
+    if (GrTexture* tex = bitmap.getTexture()) {
+        CHECK_SHOULD_DRAW(origDraw);
+        // Will hold the src dst rect after clipping against the image bounds.
+        SkRect clippedSrcRect;
+        SkRect clippedDstRect;
+        SkIRect contentArea = SkIRect::MakeWH(bitmap.width(), bitmap.height());
+        bool alphaBitmap = GrPixelConfigIsAlphaOnly(tex->config());
+        if (src) {
+            SkRect bmpSrcBounds = SkRect::MakeIWH(bitmap.width(), bitmap.height());
+            if (!bmpSrcBounds.contains(*src)) {
+                clippedSrcRect = *src;
+                if (!clippedSrcRect.intersect(bmpSrcBounds)) {
+                    return;
+                }
+                SkMatrix srcToDstMatrix;
+                srcToDstMatrix.setRectToRect(*src, dst, SkMatrix::kFill_ScaleToFit);
+                srcToDstMatrix.mapRect(&clippedDstRect, clippedSrcRect);
+                // Since went through the trouble to compute the local matrix, call this version and
+                // return.
+                this->drawTextureRectPrecomputedLocalMatrix(
+                    &GrBitmapTextureAdjuster(&bitmap), alphaBitmap, clippedSrcRect, clippedDstRect,
+                    *origDraw.fMatrix, srcToDstMatrix, fClip, paint, constraint);
+                return;
+            } else {
+                clippedSrcRect = *src;
+                clippedDstRect = dst;
+            }
+        } else {
+            clippedSrcRect = SkRect::MakeWH(SkIntToScalar(bitmap.width()),
+                                            SkIntToScalar(bitmap.height()));
+        }
+        this->drawTextureRect(&GrBitmapTextureAdjuster(&bitmap), alphaBitmap, clippedSrcRect,
+                              clippedDstRect, *origDraw.fMatrix, fClip, paint, constraint);
+        return;
+    }
+
     SkMatrix    matrix;
     SkRect      bitmapBounds, tmpSrc;
 
     bitmapBounds.set(0, 0,
                      SkIntToScalar(bitmap.width()),
                      SkIntToScalar(bitmap.height()));
 
     // Compute matrix from the two rectangles
     if (src) {
         tmpSrc = *src;
@@ skipping 141 matching lines @@
         return true;
     } else {
         return as_IB(image)->getROPixels(bm);
     }
 }
 
 void SkGpuDevice::drawImage(const SkDraw& draw, const SkImage* image, SkScalar x, SkScalar y,
                             const SkPaint& paint) {
     SkBitmap bm;
     if (GrTexture* tex = as_IB(image)->peekTexture()) {
-        GrWrapTextureInBitmap(tex, image->width(), image->height(), image->isOpaque(), &bm);
+        CHECK_SHOULD_DRAW(draw);
+        SkRect srcRect = SkRect::MakeIWH(image->width(), image->height());
+        SkRect dstRect = srcRect;
+        dstRect.offset(x, y);
+        bool alphaBitmap = GrPixelConfigIsAlphaOnly(tex->config());
+        // Since the src rect is the image dimensions, no need to enforce a bleed constraint.
+        static const SkCanvas::SrcRectConstraint kSrcRectConstraint =
+            SkCanvas::kFast_SrcRectConstraint;
+        this->drawTextureRect(&GrImageTextureAdjuster(as_IB(image)), alphaBitmap, srcRect, dstRect,
+                              *draw.fMatrix, fClip, paint, kSrcRectConstraint);
+        return;
     } else {
         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;
             }
         } else {
             if (!wrap_as_bm(this->context(), image, &bm)) {
                 return;
             }
         }
     }
     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) {
     SkBitmap bm;
     if (GrTexture* tex = as_IB(image)->peekTexture()) {
-        GrWrapTextureInBitmap(tex, image->width(), image->height(), image->isOpaque(), &bm);
-    } else {
-        SkMatrix viewMatrix = *draw.fMatrix;
-        viewMatrix.preScale(dst.width() / (src ? src->width() : image->width()),
-                            dst.height() / (src ? src->height() : image->height()));
-
-        if (this->shouldTileImage(image, src, constraint, paint.getFilterQuality(), viewMatrix)) {
-            // only support tiling as bitmap at the moment, so force raster-version
-            if (!as_IB(image)->getROPixels(&bm)) {
+        CHECK_SHOULD_DRAW(draw);
+        // Will hold the src dst rect after clipping against the image bounds.
+        SkRect clippedSrcRect;
+        SkRect clippedDstRect;
+        bool alphaBitmap = GrPixelConfigIsAlphaOnly(tex->config());
+        if (src) {
+            SkRect imgSrcBounds = SkRect::MakeIWH(image->width(), image->height());
+            if (!imgSrcBounds.contains(*src)) {
+                clippedSrcRect = *src;
+                if (!clippedSrcRect.intersect(imgSrcBounds)) {
+                    return;
+                }
+                SkMatrix srcToDstMatrix;
+                srcToDstMatrix.setRectToRect(*src, dst, SkMatrix::kFill_ScaleToFit);
+                srcToDstMatrix.mapRect(&clippedDstRect, clippedSrcRect);
+                // Since went through the trouble to compute the local matrix, call this version and
+                // return.
+                this->drawTextureRectPrecomputedLocalMatrix(
+                    &GrImageTextureAdjuster(as_IB(image)), alphaBitmap, clippedSrcRect,
+                    clippedDstRect, *draw.fMatrix, srcToDstMatrix, fClip, paint, constraint);

[joshualitt, 2015/11/05 19:53:12]

can this be made a helper? or do we want it to be separate because of the whole
image / bitmap thing?  Could maybe have a lambda to call to create the
imageTextureAdjuster if it succeeds.

[bsalomon, 2015/11/05 20:10:37]

I'm not sure I understand what you're asking/suggesting.

[bsalomon, 2015/11/06 15:24:26]

Done.

                 return;
+            } else {
+                clippedSrcRect = *src;
+                clippedDstRect = dst;
             }
         } else {
-            if (!wrap_as_bm(this->context(), image, &bm)) {
-                return;
-            }
+            clippedSrcRect = SkRect::MakeWH(SkIntToScalar(image->width()),
+                                            SkIntToScalar(image->height()));
+            clippedDstRect = dst;
+        }
+        this->drawTextureRect(&GrImageTextureAdjuster(as_IB(image)), alphaBitmap, clippedSrcRect, 
+                              clippedDstRect, *draw.fMatrix, fClip, paint, constraint);
+        return;
+    }
+    SkMatrix viewMatrix = *draw.fMatrix;
+    viewMatrix.preScale(dst.width() / (src ? src->width() : image->width()),
+                        dst.height() / (src ? src->height() : image->height()));
+    if (this->shouldTileImage(image, src, constraint, paint.getFilterQuality(), viewMatrix)) {
+        // only support tiling as bitmap at the moment, so force raster-version
+        if (!as_IB(image)->getROPixels(&bm)) {
+            return;
+        }
+    } else {
+        if (!wrap_as_bm(this->context(), image, &bm)) {
+            return;
         }
     }
     this->drawBitmapRect(draw, bm, src, dst, paint, constraint);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // must be in SkCanvas::VertexMode order
 static const GrPrimitiveType gVertexMode2PrimitiveType[] = {
     kTriangles_GrPrimitiveType,
@@ skipping 332 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