Make filters use SkImage instead of SkBitmap

src/effects/SkAlphaThresholdFilter.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkAlphaThresholdFilter.h"
 #include "SkBitmap.h"
+#include "SkImagePriv.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkRegion.h"
 
 class SK_API SkAlphaThresholdFilterImpl : public SkImageFilter {
 public:
     SkAlphaThresholdFilterImpl(const SkRegion& region, SkScalar innerThreshold,
                                SkScalar outerThreshold, SkImageFilter* input);
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkAlphaThresholdFilterImpl)
 
 protected:
     void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
-    virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
-                               SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
+    virtual bool onFilterImage(Proxy*, const SkImage* src, const Context&,
+                               SkAutoTUnref<const SkImage>& result,
+                               SkIPoint* offset) const SK_OVERRIDE;
 #if SK_SUPPORT_GPU
     virtual bool asFragmentProcessor(GrFragmentProcessor**, GrTexture*, const SkMatrix&,
                                      const SkIRect& bounds) const SK_OVERRIDE;
 #endif
 
 private:
     SkRegion fRegion;
     SkScalar fInnerThreshold;
     SkScalar fOuterThreshold;
     typedef SkImageFilter INHERITED;
@@ skipping 269 matching lines @@
 }
 #endif
 
 void SkAlphaThresholdFilterImpl::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeScalar(fInnerThreshold);
     buffer.writeScalar(fOuterThreshold);
     buffer.writeRegion(fRegion);
 }
 
-bool SkAlphaThresholdFilterImpl::onFilterImage(Proxy*, const SkBitmap& src,
-                                               const Context& ctx, SkBitmap* dst,
+bool SkAlphaThresholdFilterImpl::onFilterImage(Proxy*, const SkImage* src,
+                                               const Context& ctx, SkAutoTUnref<const SkImage>& dst,
                                                SkIPoint* offset) const {
-    SkASSERT(src.colorType() == kN32_SkColorType);
-
-    if (src.colorType() != kN32_SkColorType) {
-        return false;
-    }
-
     SkMatrix localInverse;
     if (!ctx.ctm().invert(&localInverse)) {
         return false;
     }
 
-    SkAutoLockPixels alp(src);
-    SkASSERT(src.getPixels());
-    if (!src.getPixels() || src.width() <= 0 || src.height() <= 0) {
+    SkBitmap srcBitmap;
+    SkAutoImageAsN32Bitmap aai(src, &srcBitmap);
+    if (!srcBitmap.getPixels() || srcBitmap.width() <= 0 || srcBitmap.height() <= 0) {
         return false;
     }
 
-    if (!dst->tryAllocPixels(src.info())) {
+    SkBitmap dstBitmap;
+    if (!dstBitmap.tryAllocPixels(srcBitmap.info())) {
         return false;
     }
 
     U8CPU innerThreshold = (U8CPU)(fInnerThreshold * 0xFF);
     U8CPU outerThreshold = (U8CPU)(fOuterThreshold * 0xFF);
-    SkColor* sptr = src.getAddr32(0, 0);
-    SkColor* dptr = dst->getAddr32(0, 0);
-    int width = src.width(), height = src.height();
+    SkColor* sptr = srcBitmap.getAddr32(0, 0);
+    SkColor* dptr = dstBitmap.getAddr32(0, 0);
+    int width = srcBitmap.width(), height = srcBitmap.height();
     for (int y = 0; y < height; ++y) {
         for (int x = 0; x < width; ++x) {
             const SkColor& source = sptr[y * width + x];
             SkColor output_color(source);
             SkPoint position;
             localInverse.mapXY((SkScalar)x, (SkScalar)y, &position);
             if (fRegion.contains((int32_t)position.x(), (int32_t)position.y())) {
                 if (SkColorGetA(source) < innerThreshold) {
                     U8CPU alpha = SkColorGetA(source);
                     if (alpha == 0)
                         alpha = 1;
                     float scale = (float)innerThreshold / alpha;
                     output_color = SkColorSetARGB(innerThreshold,
                                                   (U8CPU)(SkColorGetR(source) * scale),
                                                   (U8CPU)(SkColorGetG(source) * scale),
                                                   (U8CPU)(SkColorGetB(source) * scale));
                 }
             } else {
                 if (SkColorGetA(source) > outerThreshold) {
                     float scale = (float)outerThreshold / SkColorGetA(source);
                     output_color = SkColorSetARGB(outerThreshold,
                                                   (U8CPU)(SkColorGetR(source) * scale),
                                                   (U8CPU)(SkColorGetG(source) * scale),
                                                   (U8CPU)(SkColorGetB(source) * scale));
                 }
             }
-            dptr[y * dst->width() + x] = output_color;
+            dptr[y * dstBitmap.width() + x] = output_color;
         }
     }
+    srcBitmap = SkBitmap();
 
+    SkImage* image = SkNewImageFromBitmap(dstBitmap, NULL);
+    if (NULL == image) {
+        return false;
+    }
+    dst.reset(image);
+    offset->fX = 0;
+    offset->fY = 0;
     return true;
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void SkAlphaThresholdFilterImpl::toString(SkString* str) const {
     str->appendf("SkAlphaThresholdImageFilter: (");
     str->appendf("inner: %f outer: %f", fInnerThreshold, fOuterThreshold);
     str->append(")");
 }
 #endif