Make SkGpuDevice know its alpha type

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 104 matching lines @@
 
 struct GrSkDrawProcs : public SkDrawProcs {
 public:
     GrContext* fContext;
     GrTextContext* fTextContext;
     GrFontScaler* fFontScaler;  // cached in the skia glyphcache
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkGpuDevice* SkGpuDevice::Create(GrRenderTarget* rt, const SkSurfaceProps* props, unsigned flags) {
-    return SkGpuDevice::Create(rt, rt->width(), rt->height(), props, flags);
+/** Checks that the alpha type is legal and gets constructor flags. Returns false if device creation
+    should fail. */
+bool SkGpuDevice::CheckAlphaTypeAndGetFlags(
+                        const SkImageInfo* info, SkGpuDevice::InitContents init, unsigned* flags) {
+    *flags = 0;
+    if (info) {
+        switch (info->alphaType()) {
+            case kPremul_SkAlphaType:
+                break;
+            case kOpaque_SkAlphaType:
+                *flags |= SkGpuDevice::kIsOpaque_Flag;
+                break;
+            default: // If it is unpremul or unknown don't try to render
+                return false;
+        }
+    }
+    if (kClear_InitContents == init) {
+        *flags |= kNeedClear_Flag;
+    }
+    return true;
+}
+
+SkGpuDevice* SkGpuDevice::Create(GrRenderTarget* rt, const SkSurfaceProps* props,
+                                 InitContents init) {
+    return SkGpuDevice::Create(rt, rt->width(), rt->height(), props, init);
 }
 
 SkGpuDevice* SkGpuDevice::Create(GrRenderTarget* rt, int width, int height,
-                                 const SkSurfaceProps* props, unsigned flags) {
+                                 const SkSurfaceProps* props, InitContents init) {
     if (!rt || rt->wasDestroyed()) {
         return NULL;
     }
+    unsigned flags;
+    if (!CheckAlphaTypeAndGetFlags(NULL, init, &flags)) {
+        return NULL;
+    }
     return SkNEW_ARGS(SkGpuDevice, (rt, width, height, props, flags));
 }
 
+SkGpuDevice* SkGpuDevice::Create(GrContext* context, SkSurface::Budgeted budgeted,
+                                 const SkImageInfo& info, int sampleCount,
+                                 const SkSurfaceProps* props, InitContents init) {
+    unsigned flags;
+    if (!CheckAlphaTypeAndGetFlags(&info, init, &flags)) {
+        return NULL;
+    }
+
+    SkAutoTUnref<GrRenderTarget> rt(CreateRenderTarget(context, budgeted, info,  sampleCount));
+    if (NULL == rt) {
+        return NULL;
+    }
+
+    return SkNEW_ARGS(SkGpuDevice, (rt, info.width(), info.height(), props, flags));
+}
+
 SkGpuDevice::SkGpuDevice(GrRenderTarget* rt, int width, int height,
                          const SkSurfaceProps* props, unsigned flags)
     : INHERITED(SkSurfacePropsCopyOrDefault(props))
 {
     fDrawProcs = NULL;
 
     fContext = SkRef(rt->getContext());
-    fNeedClear = flags & kNeedClear_Flag;
+    fNeedClear = SkToBool(flags & kNeedClear_Flag);
+    fOpaque = SkToBool(flags & kIsOpaque_Flag);
 
     fRenderTarget = SkRef(rt);
 
-    SkImageInfo info = rt->surfacePriv().info().makeWH(width, height);
+    SkAlphaType at = fOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
+    SkImageInfo info = rt->surfacePriv().info(at).makeWH(width, height);
     SkPixelRef* pr = SkNEW_ARGS(SkGrPixelRef, (info, rt));
     fLegacyBitmap.setInfo(info);
     fLegacyBitmap.setPixelRef(pr)->unref();
 
     fDrawContext.reset(SkRef(fContext->drawContext(&this->surfaceProps())));
 }
 
 GrRenderTarget* SkGpuDevice::CreateRenderTarget(GrContext* context, SkSurface::Budgeted budgeted,
                                                 const SkImageInfo& origInfo, int sampleCount) {
     if (kUnknown_SkColorType == origInfo.colorType() ||
@@ skipping 26 matching lines @@
     desc.fSampleCnt = sampleCount;
     GrTexture* texture = context->textureProvider()->createTexture(
         desc, SkToBool(budgeted), NULL, 0);
     if (NULL == texture) {
         return NULL;
     }
     SkASSERT(NULL != texture->asRenderTarget());
     return texture->asRenderTarget();
 }
 
-SkGpuDevice* SkGpuDevice::Create(GrContext* context, SkSurface::Budgeted budgeted,
-                                 const SkImageInfo& info, int sampleCount,
-                                 const SkSurfaceProps* props, unsigned flags) {
-
-    SkAutoTUnref<GrRenderTarget> rt(CreateRenderTarget(context, budgeted, info,  sampleCount));
-    if (NULL == rt) {
-        return NULL;
-    }
-
-    return SkNEW_ARGS(SkGpuDevice, (rt, info.width(), info.height(), props, flags));
-}
-
 SkGpuDevice::~SkGpuDevice() {
     if (fDrawProcs) {
         delete fDrawProcs;
     }
 
     fRenderTarget->unref();
     fContext->unref();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkGpuDevice::onReadPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
                                int x, int y) {
     DO_DEFERRED_CLEAR();
 
     // TODO: teach fRenderTarget to take ImageInfo directly to specify the src pixels
     GrPixelConfig config = SkImageInfo2GrPixelConfig(dstInfo);
     if (kUnknown_GrPixelConfig == config) {
         return false;
     }
 
     uint32_t flags = 0;
     if (kUnpremul_SkAlphaType == dstInfo.alphaType()) {
         flags = GrContext::kUnpremul_PixelOpsFlag;
     }
-    return fContext->readRenderTargetPixels(fRenderTarget, x, y, dstInfo.width(), dstInfo.height(),
-                                            config, dstPixels, dstRowBytes, flags);
+    return fRenderTarget->readPixels(x, y, dstInfo.width(), dstInfo.height(), config, dstPixels,
+                                     dstRowBytes, flags);
 }
 
 bool SkGpuDevice::onWritePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes,
                                 int x, int y) {
     // TODO: teach fRenderTarget to take ImageInfo directly to specify the src pixels
     GrPixelConfig config = SkImageInfo2GrPixelConfig(info);
     if (kUnknown_GrPixelConfig == config) {
         return false;
     }
     uint32_t flags = 0;
@@ skipping 80 matching lines @@
             return;
         }
         this->context()->copySurface(newRT, fRenderTarget);
     }
 
     SkASSERT(fRenderTarget != newRT);
 
     fRenderTarget->unref();
     fRenderTarget = newRT.detach();
 
-    SkASSERT(fRenderTarget->surfacePriv().info() == fLegacyBitmap.info());
-    SkPixelRef* pr = SkNEW_ARGS(SkGrPixelRef, (fRenderTarget->surfacePriv().info(), fRenderTarget));
+#ifdef SK_DEBUG
+    SkImageInfo info = fRenderTarget->surfacePriv().info(fOpaque ? kOpaque_SkAlphaType :
+                                                                   kPremul_SkAlphaType);
+    SkASSERT(info == fLegacyBitmap.info());
+#endif
+    SkPixelRef* pr = SkNEW_ARGS(SkGrPixelRef, (fLegacyBitmap.info(), fRenderTarget));
     fLegacyBitmap.setPixelRef(pr)->unref();
 
     fDrawContext.reset(SkRef(fRenderTarget->getContext()->drawContext(&this->surfaceProps())));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawPaint", fContext);
@@ skipping 309 matching lines @@
 
     if (maxTileTotalTileSize > 2 * smallTotalTileSize) {
         return kBmpSmallTileSize;
     } else {
         return maxTileSize;
     }
 }
 
 // Given a bitmap, an optional src rect, and a context with a clip and matrix determine what
 // pixels from the bitmap are necessary.
-static void determine_clipped_src_rect(const GrContext* context,
-                                       const GrRenderTarget* rt,
+static void determine_clipped_src_rect(const GrRenderTarget* rt,
                                        const GrClip& clip,
                                        const SkMatrix& viewMatrix,
                                        const SkBitmap& bitmap,
                                        const SkRect* srcRectPtr,
                                        SkIRect* clippedSrcIRect) {
     clip.getConservativeBounds(rt, clippedSrcIRect, NULL);
     SkMatrix inv;
     if (!viewMatrix.invert(&inv)) {
         clippedSrcIRect->setEmpty();
         return;
@@ skipping 22 matching lines @@
                                    int maxTileSize,
                                    int* tileSize,
                                    SkIRect* clippedSrcRect) const {
     // if bitmap is explictly texture backed then just use the texture
     if (bitmap.getTexture()) {
         return false;
     }
 
     // if it's larger than the max tile size, then we have no choice but tiling.
     if (bitmap.width() > maxTileSize || bitmap.height() > maxTileSize) {
-        determine_clipped_src_rect(fContext, fRenderTarget, fClip, viewMatrix, bitmap,
+        determine_clipped_src_rect(fRenderTarget, fClip, viewMatrix, bitmap,
                                    srcRectPtr, clippedSrcRect);
         *tileSize = determine_tile_size(bitmap, *clippedSrcRect, maxTileSize);
         return true;
     }
 
     if (bitmap.width() * bitmap.height() < 4 * kBmpSmallTileSize * kBmpSmallTileSize) {
         return false;
     }
 
     // if the entire texture is already in our cache then no reason to tile it
     if (GrIsBitmapInCache(fContext, bitmap, &params)) {
         return false;
     }
 
     // At this point we know we could do the draw by uploading the entire bitmap
     // as a texture. However, if the texture would be large compared to the
     // cache size and we don't require most of it for this draw then tile to
     // reduce the amount of upload and cache spill.
 
     // assumption here is that sw bitmap size is a good proxy for its size as
     // a texture
     size_t bmpSize = bitmap.getSize();
     size_t cacheSize;
     fContext->getResourceCacheLimits(NULL, &cacheSize);
     if (bmpSize < cacheSize / 2) {
         return false;
     }
 
     // Figure out how much of the src we will need based on the src rect and clipping.
-    determine_clipped_src_rect(fContext, fRenderTarget, fClip, viewMatrix, bitmap, srcRectPtr,
+    determine_clipped_src_rect(fRenderTarget, fClip, viewMatrix, bitmap, srcRectPtr,
                                clippedSrcRect);
     *tileSize = kBmpSmallTileSize; // already know whole bitmap fits in one max sized tile.
     size_t usedTileBytes = get_tile_count(*clippedSrcRect, kBmpSmallTileSize) *
                            kBmpSmallTileSize * kBmpSmallTileSize;
 
     return usedTileBytes < 2 * bmpSize;
 }
 
 void SkGpuDevice::drawBitmap(const SkDraw& origDraw,
                              const SkBitmap& bitmap,
@@ skipping 915 matching lines @@
 SkBaseDevice* SkGpuDevice::onCreateDevice(const CreateInfo& cinfo, const SkPaint*) {
     GrSurfaceDesc desc;
     desc.fConfig = fRenderTarget->config();
     desc.fFlags = kRenderTarget_GrSurfaceFlag;
     desc.fWidth = cinfo.fInfo.width();
     desc.fHeight = cinfo.fInfo.height();
     desc.fSampleCnt = fRenderTarget->desc().fSampleCnt;
 
     SkAutoTUnref<GrTexture> texture;
     // Skia's convention is to only clear a device if it is non-opaque.
-    unsigned flags = cinfo.fInfo.isOpaque() ? 0 : kNeedClear_Flag;
+    InitContents init = cinfo.fInfo.isOpaque() ? kUninit_InitContents : kClear_InitContents;
 
     // layers are never draw in repeat modes, so we can request an approx
     // match and ignore any padding.
     const GrTextureProvider::ScratchTexMatch match = (kNever_TileUsage == cinfo.fTileUsage) ?
                                                   GrTextureProvider::kApprox_ScratchTexMatch :
                                                   GrTextureProvider::kExact_ScratchTexMatch;
     texture.reset(fContext->textureProvider()->refScratchTexture(desc, match));
 
     if (texture) {
         SkSurfaceProps props(this->surfaceProps().flags(), cinfo.fPixelGeometry);
         return SkGpuDevice::Create(
-            texture->asRenderTarget(), cinfo.fInfo.width(), cinfo.fInfo.height(), &props, flags);
+            texture->asRenderTarget(), cinfo.fInfo.width(), cinfo.fInfo.height(), &props, init);
     } else {
         SkErrorInternals::SetError( kInternalError_SkError,
                                     "---- failed to create gpu device texture [%d %d]\n",
                                     cinfo.fInfo.width(), cinfo.fInfo.height());
         return NULL;
     }
 }
 
 SkSurface* SkGpuDevice::newSurface(const SkImageInfo& info, const SkSurfaceProps& props) {
     // TODO: Change the signature of newSurface to take a budgeted parameter.
@@ skipping 69 matching lines @@
 #endif
 }
 
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
 }
 
 #endif