Make filters use SkImage instead of SkBitmap

src/effects/SkLightingImageFilter.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 "SkLightingImageFilter.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
+#include "SkImagePriv.h"
+#include "SkImage_Base.h"
 #include "SkReadBuffer.h"
+#include "SkReadBuffer.h"
+#include "SkTypes.h"
 #include "SkWriteBuffer.h"
-#include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
-#include "SkTypes.h"
-
 #if SK_SUPPORT_GPU
 #include "GrFragmentProcessor.h"
 #include "GrInvariantOutput.h"
 #include "effects/GrSingleTextureEffect.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 class GrGLDiffuseLightingEffect;
 class GrGLSpecularLightingEffect;
 
@@ skipping 257 matching lines @@
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDiffuseLightingImageFilter)
     SkScalar kd() const { return fKD; }
 
 protected:
     SkDiffuseLightingImageFilter(SkLight* light, SkScalar surfaceScale,
                                  SkScalar kd, SkImageFilter* input, const CropRect* cropRect,
                                  uint32_t uniqueID);
     void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
-    virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
-                               SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
+    virtual bool onFilterImage(Proxy*, SkImage& src, const Context&,
+                               SkAutoTUnref<SkImage>&, SkIPoint* offset) const SK_OVERRIDE;
 #if SK_SUPPORT_GPU
     virtual bool asFragmentProcessor(GrFragmentProcessor**, GrTexture*, const SkMatrix&,
                                      const SkIRect& bounds) const SK_OVERRIDE;
 #endif
 
 private:
     friend class SkLightingImageFilter;
     typedef SkLightingImageFilter INHERITED;
     SkScalar fKD;
 };
 
 class SkSpecularLightingImageFilter : public SkLightingImageFilter {
 public:
     static SkImageFilter* Create(SkLight* light, SkScalar surfaceScale,
                                  SkScalar ks, SkScalar shininess, SkImageFilter*, const CropRect*,
                                  uint32_t uniqueID = 0);
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSpecularLightingImageFilter)
 
     SkScalar ks() const { return fKS; }
     SkScalar shininess() const { return fShininess; }
 
 protected:
     SkSpecularLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar ks,
                                   SkScalar shininess, SkImageFilter* input, const CropRect*,
                                   uint32_t uniqueID);
     void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
-    virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
-                               SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
+    virtual bool onFilterImage(Proxy*, SkImage& src, const Context&,
+                               SkAutoTUnref<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:
     SkScalar fKS;
     SkScalar fShininess;
     friend class SkLightingImageFilter;
     typedef SkLightingImageFilter INHERITED;
@@ skipping 641 matching lines @@
     SkScalar kd = buffer.readScalar();
     return Create(light, surfaceScale, kd, common.getInput(0), &common.cropRect(), common.uniqueID());
 }
 
 void SkDiffuseLightingImageFilter::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeScalar(fKD);
 }
 
 bool SkDiffuseLightingImageFilter::onFilterImage(Proxy* proxy,
-                                                 const SkBitmap& source,
+                                                 SkImage& source,
                                                  const Context& ctx,
-                                                 SkBitmap* dst,
+                                                 SkAutoTUnref<SkImage>& dst,
                                                  SkIPoint* offset) const {
     SkImageFilter* input = getInput(0);
-    SkBitmap src = source;
+    SkAutoTUnref<SkImage> src(SkRef(&source));
     SkIPoint srcOffset = SkIPoint::Make(0, 0);
-    if (input && !input->filterImage(proxy, source, ctx, &src, &srcOffset)) {
+    if (input && !input->filterImage(proxy, source, ctx, src, &srcOffset)) {
         return false;
     }
-
+#if 0
     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 (bounds.width() < 2 || bounds.height() < 2) {
         return false;
     }
+    SkBitmap srcBitmap;
+    if (!as_IB(src)->getROPixels(&srcBitmap)) {
+        return false;
+    }
+    src.reset(NULL);
 
-    SkAutoLockPixels alp(src);
-    if (!src.getPixels()) {
+    SkAutoLockPixels alp(srcBitmap);
+    if (!srcBitmap.getPixels()) {
         return false;
     }
 
-    if (!dst->tryAllocPixels(src.info().makeWH(bounds.width(), bounds.height()))) {
+    SkBitmap dstBitmap;
+    if (!dstBitmap.tryAllocPixels(srcBitmap.info().makeWH(bounds.width(), bounds.height()))) {
         return false;
     }
 
     SkAutoTUnref<SkLight> transformedLight(light()->transform(ctx.ctm()));
 
     DiffuseLightingType lightingType(fKD);
-    offset->fX = bounds.left();
-    offset->fY = bounds.top();
+    int32_t resultX = bounds.left();
+    int32_t resultY = bounds.top();
+
     bounds.offset(-srcOffset);
     switch (transformedLight->type()) {
         case SkLight::kDistant_LightType:
-            lightBitmap<DiffuseLightingType, SkDistantLight>(lightingType, transformedLight, src, dst, surfaceScale(), bounds);
+            lightBitmap<DiffuseLightingType, SkDistantLight>(lightingType, transformedLight,
+                                                             srcBitmap, &dstBitmap, surfaceScale(),
+                                                             bounds);
             break;
         case SkLight::kPoint_LightType:
-            lightBitmap<DiffuseLightingType, SkPointLight>(lightingType, transformedLight, src, dst, surfaceScale(), bounds);
+            lightBitmap<DiffuseLightingType, SkPointLight>(lightingType, transformedLight,
+                                                           srcBitmap, &dstBitmap, surfaceScale(),
+                                                           bounds);
             break;
         case SkLight::kSpot_LightType:
-            lightBitmap<DiffuseLightingType, SkSpotLight>(lightingType, transformedLight, src, dst, surfaceScale(), bounds);
+            lightBitmap<DiffuseLightingType, SkSpotLight>(lightingType, transformedLight, srcBitmap,
+                                                          &dstBitmap, surfaceScale(), bounds);
             break;
     }
 
+    srcBitmap = SkBitmap();
+
+    SkImage* image = SkNewImageFromBitmap(dstBitmap, true, NULL);
+    if (NULL == image) {
+        return false;
+    }
+    dst.reset(image);
+    offset->fX = resultX;
+    offset->fY = resultY;
     return true;
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void SkDiffuseLightingImageFilter::toString(SkString* str) const {
     str->appendf("SkDiffuseLightingImageFilter: (");
     str->appendf("kD: %f\n", fKD);
     str->append(")");
 }
 #endif
@@ skipping 46 matching lines @@
     return Create(light, surfaceScale, ks, shine, common.getInput(0), &common.cropRect(), common.uniqueID());
 }
 
 void SkSpecularLightingImageFilter::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeScalar(fKS);
     buffer.writeScalar(fShininess);
 }
 
 bool SkSpecularLightingImageFilter::onFilterImage(Proxy* proxy,
-                                                  const SkBitmap& source,
+                                                  SkImage& source,
                                                   const Context& ctx,
-                                                  SkBitmap* dst,
+                                                  SkAutoTUnref<SkImage>& dst,
                                                   SkIPoint* offset) const {
     SkImageFilter* input = getInput(0);
-    SkBitmap src = source;
+    SkAutoTUnref<SkImage> src(SkRef(&source));
     SkIPoint srcOffset = SkIPoint::Make(0, 0);
-    if (input && !input->filterImage(proxy, source, ctx, &src, &srcOffset)) {
+    if (input && !input->filterImage(proxy, source, ctx, src, &srcOffset)) {
+        return false;
+    }
+#if 0
+    if (src.colorType() != kN32_SkColorType) {
+        return false;
+    }
+#endif
+    SkIRect bounds;
+    if (!this->applyCropRect(ctx, proxy, *src, &srcOffset, &bounds, src)) {
         return false;
     }
 
-    if (src.colorType() != kN32_SkColorType) {
-        return false;
-    }
-
-    SkIRect bounds;
-    if (!this->applyCropRect(ctx, proxy, src, &srcOffset, &bounds, &src)) {
-        return false;
-    }
-
     if (bounds.width() < 2 || bounds.height() < 2) {
         return false;
     }
 
-    SkAutoLockPixels alp(src);
-    if (!src.getPixels()) {
+    SkBitmap srcBitmap;
+    if (!as_IB(src)->getROPixels(&srcBitmap)) {
+        return false;
+    }
+    src.reset(NULL);
+
+    SkAutoLockPixels alp(srcBitmap);
+    if (!srcBitmap.getPixels()) {
         return false;
     }
 
-    if (!dst->tryAllocPixels(src.info().makeWH(bounds.width(), bounds.height()))) {
+    SkBitmap dstBitmap;
+    if (!dstBitmap.tryAllocPixels(srcBitmap.info().makeWH(bounds.width(), bounds.height()))) {
         return false;
     }
 
     SpecularLightingType lightingType(fKS, fShininess);
-    offset->fX = bounds.left();
-    offset->fY = bounds.top();
+    int32_t resultX = bounds.left();
+    int32_t resultY = bounds.top();
+
     bounds.offset(-srcOffset);
     SkAutoTUnref<SkLight> transformedLight(light()->transform(ctx.ctm()));
     switch (transformedLight->type()) {
         case SkLight::kDistant_LightType:
-            lightBitmap<SpecularLightingType, SkDistantLight>(lightingType, transformedLight, src, dst, surfaceScale(), bounds);
+            lightBitmap<SpecularLightingType, SkDistantLight>(lightingType, transformedLight,
+                                                              srcBitmap, &dstBitmap, surfaceScale(),
+                                                              bounds);
             break;
         case SkLight::kPoint_LightType:
-            lightBitmap<SpecularLightingType, SkPointLight>(lightingType, transformedLight, src, dst, surfaceScale(), bounds);
+            lightBitmap<SpecularLightingType, SkPointLight>(lightingType, transformedLight,
+                                                            srcBitmap, &dstBitmap, surfaceScale(),
+                                                            bounds);
             break;
         case SkLight::kSpot_LightType:
-            lightBitmap<SpecularLightingType, SkSpotLight>(lightingType, transformedLight, src, dst, surfaceScale(), bounds);
+            lightBitmap<SpecularLightingType, SkSpotLight>(lightingType, transformedLight,
+                                                           srcBitmap, &dstBitmap, surfaceScale(),
+                                                           bounds);
             break;
     }
+    SkImage* image = SkNewImageFromBitmap(dstBitmap, true, NULL);
+    if (NULL == image) {
+        return false;
+    }
+    dst.reset(image);
+    offset->fX = resultX;
+    offset->fY = resultY;
     return true;
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void SkSpecularLightingImageFilter::toString(SkString* str) const {
     str->appendf("SkSpecularLightingImageFilter: (");
     str->appendf("kS: %f shininess: %f", fKS, fShininess);
     str->append(")");
 }
 #endif
@@ skipping 554 matching lines @@
 
     fsBuilder->codeAppendf("%s(%s)", fLightColorFunc.c_str(), surfaceToLight);
 }
 
 #endif
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDiffuseLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSpecularLightingImageFilter)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END