Make filters use SkImage instead of SkBitmap

src/effects/SkMatrixConvolutionImageFilter.cpp

 /*
  * Copyright 2012 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMatrixConvolutionImageFilter.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
+#include "SkImagePriv.h"
+#include "SkImage_Base.h"
 #include "SkReadBuffer.h"
+#include "SkRect.h"
+#include "SkSurface.h"
+#include "SkUnPreMultiply.h"
 #include "SkWriteBuffer.h"
-#include "SkRect.h"
-#include "SkUnPreMultiply.h"
 
 #if SK_SUPPORT_GPU
 #include "effects/GrMatrixConvolutionEffect.h"
 #endif
 
 // We need to be able to read at most SK_MaxS32 bytes, so divide that
 // by the size of a scalar to know how many scalars we can read.
 static const int32_t gMaxKernelSize = SK_MaxS32 / sizeof(SkScalar);
 
 SkMatrixConvolutionImageFilter::SkMatrixConvolutionImageFilter(
@@ skipping 233 matching lines @@
         const uint32_t* srcRow = src.getAddr32(0, y);
         uint32_t* dstRow = result.getAddr32(0, y);
         for (int x = 0; x < src.width(); ++x) {
             dstRow[x] = SkUnPreMultiply::PMColorToColor(srcRow[x]);
         }
     }
     return result;
 }
 
 bool SkMatrixConvolutionImageFilter::onFilterImage(Proxy* proxy,
-                                                   const SkBitmap& source,
+                                                   SkImage& source,
                                                    const Context& ctx,
-                                                   SkBitmap* result,
+                                                   SkAutoTUnref<SkImage>& result,
                                                    SkIPoint* offset) const {
-    SkBitmap src = source;
+    SkAutoTUnref<SkImage> src(SkRef(&source));
     SkIPoint srcOffset = SkIPoint::Make(0, 0);
-    if (getInput(0) && !getInput(0)->filterImage(proxy, source, ctx, &src, &srcOffset)) {
+    if (getInput(0) && !getInput(0)->filterImage(proxy, source, ctx, src, &srcOffset)) {
         return false;
     }
 
+#if 0 // COLORTYPE
     if (src.colorType() != kN32_SkColorType) {
         return false;
     }
+#endif
 
     SkIRect bounds;
-    if (!this->applyCropRect(ctx, proxy, src, &srcOffset, &bounds, &src)) {
+    if (!this->applyCropRect(ctx, proxy, *src, &srcOffset, &bounds, src)) {
         return false;
     }
 
-    if (!fConvolveAlpha && !src.isOpaque()) {
-        src = unpremultiplyBitmap(src);
-    }
+    SkBitmap srcBitmap;
 
-    SkAutoLockPixels alp(src);
-    if (!src.getPixels()) {
+    if (!as_IB(src)->getROPixels(&srcBitmap)) {
         return false;
     }
 
-    if (!result->tryAllocPixels(src.info().makeWH(bounds.width(), bounds.height()))) {
+    src.reset(NULL);
+
+    if (!fConvolveAlpha && !srcBitmap.isOpaque()) {
+        srcBitmap = unpremultiplyBitmap(srcBitmap);
+    }
+
+    SkAutoLockPixels alp(srcBitmap);
+    if (!srcBitmap.getPixels()) {
         return false;
     }
 
-    offset->fX = bounds.fLeft;
-    offset->fY = bounds.fTop;
+    SkBitmap resultBitmap;
+    if (!resultBitmap.tryAllocPixels(srcBitmap.info().makeWH(bounds.width(), bounds.height()))) {
+        return false;
+    }
+
+    int32_t resultX = bounds.fLeft;
+    int32_t resultY = bounds.fTop;
     bounds.offset(-srcOffset);
     SkIRect interior = SkIRect::MakeXYWH(bounds.left() + fKernelOffset.fX,
                                          bounds.top() + fKernelOffset.fY,
                                          bounds.width() - fKernelSize.fWidth + 1,
                                          bounds.height() - fKernelSize.fHeight + 1);
     SkIRect top = SkIRect::MakeLTRB(bounds.left(), bounds.top(), bounds.right(), interior.top());
     SkIRect bottom = SkIRect::MakeLTRB(bounds.left(), interior.bottom(),
                                        bounds.right(), bounds.bottom());
     SkIRect left = SkIRect::MakeLTRB(bounds.left(), interior.top(),
                                      interior.left(), interior.bottom());
     SkIRect right = SkIRect::MakeLTRB(interior.right(), interior.top(),
                                       bounds.right(), interior.bottom());
-    filterBorderPixels(src, result, top, bounds);
-    filterBorderPixels(src, result, left, bounds);
-    filterInteriorPixels(src, result, interior, bounds);
-    filterBorderPixels(src, result, right, bounds);
-    filterBorderPixels(src, result, bottom, bounds);
+    filterBorderPixels(srcBitmap, &resultBitmap, top, bounds);
+    filterBorderPixels(srcBitmap, &resultBitmap, left, bounds);
+    filterInteriorPixels(srcBitmap, &resultBitmap, interior, bounds);
+    filterBorderPixels(srcBitmap, &resultBitmap, right, bounds);
+    filterBorderPixels(srcBitmap, &resultBitmap, bottom, bounds);
+
+    srcBitmap = SkBitmap();
+
+    SkImage* image = SkNewImageFromBitmap(resultBitmap, true, NULL);
+    if (NULL == image) {
+        return false;
+    }
+    result.reset(image);
+    offset->fX = resultX;
+    offset->fY = resultY;
     return true;
 }
 
 bool SkMatrixConvolutionImageFilter::onFilterBounds(const SkIRect& src, const SkMatrix& ctm,
                                                     SkIRect* dst) const {
     SkIRect bounds = src;
     bounds.fRight += fKernelSize.width() - 1;
     bounds.fBottom += fKernelSize.height() - 1;
     bounds.offset(-fKernelOffset);
     if (getInput(0) && !getInput(0)->filterBounds(bounds, ctm, &bounds)) {
@@ skipping 50 matching lines @@
             str->appendf("%f ", fKernel[y * fKernelSize.width() + x]);
         }
     }
     str->appendf(")");
     str->appendf("gain: %f bias: %f ", fGain, fBias);
     str->appendf("offset: (%d, %d) ", fKernelOffset.fX, fKernelOffset.fY);
     str->appendf("convolveAlpha: %s", fConvolveAlpha ? "true" : "false");
     str->append(")");
 }
 #endif