Add support for converting cc::FilterOperations into an SkImageFilter

cc/output/render_surface_filters.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/output/render_surface_filters.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "cc/output/filter_operation.h"
 #include "cc/output/filter_operations.h"
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkFlattenableBuffers.h"
+#include "third_party/skia/include/core/SkImageFilter.h"
 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
+#include "third_party/skia/include/effects/SkColorFilterImageFilter.h"
 #include "third_party/skia/include/effects/SkColorMatrixFilter.h"
 #include "third_party/skia/include/effects/SkMagnifierImageFilter.h"
+#include "third_party/skia/include/effects/SkTestImageFilters.h"

[ajuma, 2013/07/31 18:40:37]

This is for SkComposeImageFilter, used to connect the SkImageFilter for a
reference filter (produced in Blink) to the SkImageFilter produced here for the
previous operations in the FilterOperations list. Should we move
SkComposeImageFilter to a different file in Skia (since it now has a non-test
use-case)?

[Stephen White, 2013/07/31 19:18:51]

Yes, I think it should be broken out into its own file in Skia first (ie.,
before landing this patch). We've done the same with most of the other filters
which started life in SkTestImageFilters.

[ajuma, 2013/09/09 17:35:36]

Done.

 #include "third_party/skia/include/gpu/SkGpuDevice.h"
 #include "third_party/skia/include/gpu/SkGrPixelRef.h"
 #include "ui/gfx/size_f.h"
 
 namespace cc {
 
 namespace {
 
 void GetBrightnessMatrix(float amount, SkScalar matrix[20]) {
   // Spec implementation
@@ skipping 197 matching lines @@
     }
     case FilterOperation::COLOR_MATRIX: {
       memcpy(matrix, op.matrix(), sizeof(SkScalar[20]));
       return true;
     }
     default:
       return false;
   }
 }
 
+skia::RefPtr<SkImageFilter> CreateMatrixImageFilter(
+    const SkScalar matrix[20],
+    skia::RefPtr<SkImageFilter> input) {
+  skia::RefPtr<SkColorFilter> color_filter =
+      skia::AdoptRef(new SkColorMatrixFilter(matrix));
+  return skia::AdoptRef(
+      SkColorFilterImageFilter::Create(color_filter.get(), input.get()));
+}
+
 class FilterBufferState {
  public:
   FilterBufferState(GrContext* gr_context,
                     gfx::SizeF size,
                     unsigned texture_id)
       : gr_context_(gr_context),
         current_texture_(0) {
     // Wrap the source texture in a Ganesh platform texture.
     GrBackendTextureDesc backend_texture_description;
     backend_texture_description.fWidth = size.width();
@@ skipping 58 matching lines @@
   }
 
   GrContext* gr_context_;
   SkBitmap source_;
   skia::RefPtr<GrTexture> scratch_textures_[2];
   int current_texture_;
   skia::RefPtr<SkGpuDevice> device_;
   skia::RefPtr<SkCanvas> canvas_;
 };
 
+class DropShadowImageFilter : public SkImageFilter {

[ajuma, 2013/07/31 18:40:37]

This is copied from Blink. SkiaImageFilterBuilder is the only consumer of this
class in Blink, so the Blink version can be removed once the DAG build is
happening in cc.

[ajuma, 2013/09/09 17:35:36]

This is no longer needed, since DropShadowImageFilter was upstreamed to Skia.

+ public:
+  DropShadowImageFilter(SkScalar dx,
+                        SkScalar dy,
+                        SkScalar sigma,
+                        SkColor color,
+                        SkImageFilter* input)
+      : SkImageFilter(input),
+        dx_(dx),
+        dy_(dy),
+        sigma_(sigma),
+        color_(color) { }
+  SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(DropShadowImageFilter)
+
+ protected:
+  explicit DropShadowImageFilter(SkFlattenableReadBuffer& buffer)
+      : SkImageFilter(buffer) {
+    dx_ = buffer.readScalar();
+    dy_ = buffer.readScalar();
+    sigma_ = buffer.readScalar();
+    color_ = buffer.readColor();
+  }
+
+  virtual void flatten(SkFlattenableWriteBuffer& buffer) const OVERRIDE {
+    buffer.writeScalar(dx_);
+    buffer.writeScalar(dy_);
+    buffer.writeScalar(sigma_);
+    buffer.writeColor(color_);
+  }
+
+  virtual bool onFilterImage(Proxy* proxy,
+                             const SkBitmap& source,
+                             const SkMatrix& matrix,
+                             SkBitmap* result,
+                             SkIPoint* loc) OVERRIDE {
+    SkBitmap src = source;
+    if (getInput(0) &&
+        !getInput(0)->filterImage(proxy, source, matrix, &src, loc))
+      return false;
+
+    skia::RefPtr<SkDevice> device = skia::AdoptRef(
+        proxy->createDevice(src.width(), src.height()));
+    SkCanvas canvas(device.get());
+
+    skia::RefPtr<SkImageFilter> blurFilter = skia::AdoptRef(
+        new SkBlurImageFilter(sigma_, sigma_));
+    skia::RefPtr<SkColorFilter> colorFilter = skia::AdoptRef(
+        SkColorFilter::CreateModeFilter(color_, SkXfermode::kSrcIn_Mode));
+    SkPaint paint;
+    paint.setImageFilter(blurFilter.get());
+    paint.setColorFilter(colorFilter.get());
+    paint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
+    canvas.saveLayer(0, &paint);

[Stephen White, 2013/07/31 19:18:51]

FYI, we can probably get rid of the saveLayer()/restore(), and just pass the
paint directly to drawBitmap. (This code dates from early days, when image
filters only worked in saveLayer/restore).

+    canvas.drawBitmap(src, dx_, dy_);

[ajuma, 2013/07/31 18:40:37]

The version of DropShadowImageFilter currently in Blink uses -dy_ rather than
dy_ here, but that was producing incorrect results when I tested it.

[Stephen White, 2013/07/31 19:18:51]

Yeah, I think that was when we had TopDown textures in Blink but didn't know it.
Not doing the flip is probably correct (but I couldn't tell you why it's not
failing in Blink currently).

+    canvas.restore();
+    canvas.drawBitmap(src, 0, 0);
+    *result = device.get()->accessBitmap(false);
+    return true;
+  }
+
+ private:
+  SkScalar dx_, dy_, sigma_;
+  SkColor color_;
+};
+
 }  // namespace
 
 FilterOperations RenderSurfaceFilters::Optimize(
     const FilterOperations& filters) {
   FilterOperations new_list;
 
   SkScalar accumulated_color_matrix[20];
   bool have_accumulated_color_matrix = false;
   for (unsigned i = 0; i < filters.size(); ++i) {
     const FilterOperation& op = filters.at(i);
@@ skipping 26 matching lines @@
           accumulated_color_matrix));
     }
     have_accumulated_color_matrix = false;
 
     switch (op.type()) {
       case FilterOperation::BLUR:
       case FilterOperation::DROP_SHADOW:
       case FilterOperation::ZOOM:
         new_list.Append(op);
         break;
+      case FilterOperation::REFERENCE:
+        // Not supported on this code path.
+        NOTREACHED();
       case FilterOperation::BRIGHTNESS:
       case FilterOperation::SATURATING_BRIGHTNESS:
       case FilterOperation::CONTRAST:
       case FilterOperation::GRAYSCALE:
       case FilterOperation::SEPIA:
       case FilterOperation::SATURATE:
       case FilterOperation::HUE_ROTATE:
       case FilterOperation::INVERT:
       case FilterOperation::OPACITY:
       case FilterOperation::COLOR_MATRIX:
@@ skipping 67 matching lines @@
                     (height - (height / op.amount())) / 2.f,
                     width / op.amount(),
                     height / op.amount()),
                 op.zoom_inset()));
         paint.setImageFilter(zoom_filter.get());
         canvas->saveLayer(NULL, &paint);
         canvas->drawBitmap(state.Source(), 0, 0);
         canvas->restore();
         break;
       }
+      case FilterOperation::REFERENCE:
       case FilterOperation::BRIGHTNESS:
       case FilterOperation::SATURATING_BRIGHTNESS:
       case FilterOperation::CONTRAST:
       case FilterOperation::GRAYSCALE:
       case FilterOperation::SEPIA:
       case FilterOperation::SATURATE:
       case FilterOperation::HUE_ROTATE:
       case FilterOperation::INVERT:
       case FilterOperation::OPACITY:
         NOTREACHED();
         break;
     }
     state.Swap();
   }
   return state.Source();
 }
 
+skia::RefPtr<SkImageFilter> RenderSurfaceFilters::BuildImageFilter(
+    const FilterOperations& filters) {
+  skia::RefPtr<SkImageFilter> image_filter;
+  SkScalar matrix[20];
+  for (size_t i = 0; i < filters.size(); ++i) {
+    const FilterOperation& op = filters.at(i);
+    switch (op.type()) {
+      case FilterOperation::GRAYSCALE:
+        GetGrayscaleMatrix(1 - op.amount(), matrix);
+        image_filter = CreateMatrixImageFilter(matrix, image_filter);
+        break;
+      case FilterOperation::SEPIA:
+        GetSepiaMatrix(1 - op.amount(), matrix);
+        image_filter = CreateMatrixImageFilter(matrix, image_filter);
+        break;
+      case FilterOperation::SATURATE:
+        GetSaturateMatrix(op.amount(), matrix);
+        image_filter = CreateMatrixImageFilter(matrix, image_filter);
+        break;
+      case FilterOperation::HUE_ROTATE:
+        GetHueRotateMatrix(op.amount(), matrix);
+        image_filter = CreateMatrixImageFilter(matrix, image_filter);
+        break;
+      case FilterOperation::INVERT:
+        GetInvertMatrix(op.amount(), matrix);
+        image_filter = CreateMatrixImageFilter(matrix, image_filter);
+        break;
+      case FilterOperation::OPACITY:
+        GetOpacityMatrix(op.amount(), matrix);
+        image_filter = CreateMatrixImageFilter(matrix, image_filter);
+        break;
+      case FilterOperation::BRIGHTNESS:
+        GetBrightnessMatrix(op.amount(), matrix);
+        image_filter = CreateMatrixImageFilter(matrix, image_filter);
+        break;
+      case FilterOperation::CONTRAST:
+        GetContrastMatrix(op.amount(), matrix);
+        image_filter = CreateMatrixImageFilter(matrix, image_filter);
+        break;
+      case FilterOperation::BLUR:
+        image_filter = skia::AdoptRef(new SkBlurImageFilter(
+            op.amount(), op.amount(), image_filter.get()));
+        break;
+      case FilterOperation::DROP_SHADOW:
+        image_filter = skia::AdoptRef(new DropShadowImageFilter(
+            SkIntToScalar(op.drop_shadow_offset().x()),
+            SkIntToScalar(op.drop_shadow_offset().y()),
+            SkIntToScalar(op.amount()),
+            op.drop_shadow_color(),
+            image_filter.get()));
+        break;
+      case FilterOperation::COLOR_MATRIX:
+        image_filter = CreateMatrixImageFilter(op.matrix(), image_filter);
+        break;
+      case FilterOperation::ZOOM:
+        // TODO(ajuma): Add support for this. Note that zoom filter operations
+        // are only used for background filters right now.

[ajuma, 2013/07/31 18:40:37]

Is this worth doing? That is, are there any plans to use a DAG-build for
background filters?

[Stephen White, 2013/07/31 19:18:51]

Check with zork@ about this filter; I think it's only used in ChromeOS, but I'm
not sure.

Eventually it would be nice for background filters to support the same path as
foreground filters (which will be just FilterOperations, I'm guessing, not
SkImageFilter directly).

[ajuma, 2013/09/09 17:35:36]

I've added the code that was missing here for ZOOM filters.

+        NOTREACHED();
+      case FilterOperation::SATURATING_BRIGHTNESS:
+        GetSaturatingBrightnessMatrix(op.amount(), matrix);
+        image_filter = CreateMatrixImageFilter(matrix, image_filter);
+        break;
+      case FilterOperation::REFERENCE: {
+        skia::RefPtr<SkColorFilter> cf;
+
+        {
+          SkColorFilter* colorfilter_rawptr = NULL;
+          op.image_filter()->asColorFilter(&colorfilter_rawptr);
+          cf = skia::AdoptRef(colorfilter_rawptr);
+        }
+
+        if (cf && cf->asColorMatrix(matrix) &&
+            !op.image_filter()->getInput(0)) {
+          image_filter = CreateMatrixImageFilter(matrix, image_filter);
+        } else if (image_filter.get()) {
+          image_filter = skia::AdoptRef(new SkComposeImageFilter(
+              op.image_filter().get(), image_filter.get()));

[ajuma, 2013/07/31 18:40:37]

The plan is to use a no-op filter as the SourceGraphic when building the
SkImageFilter for the reference filter in Blink. By using a color matrix filter
as the no-op filter, we'll preserve the optimization we currently have for the
case where the filter itself is just a color matrix.

[Stephen White, 2013/07/31 19:18:51]

That seems reasonable. I like the use of the SkComposeImageFilter here, although
it does mean we miss the possibility for color matrix folding between shorthand
and reference filters that start with a color matrix, but contain other things
(e.g., sepia() -> matrix -> morphology). Probably not a big deal, though, and
maybe we can figure that out later.

The other thing we might be missing is a colorspace conversion from the
colorspace the shorthand filter is (device) in to the one the reference filter
is in (could be linear). This actually may also be broken in the Blink
implementation, so if it doesn't break tests, don't worry about it for now.

+        } else {
+          image_filter = op.image_filter();
+        }
+        break;
+      }
+    }
+  }
+  return image_filter;
+}
+
 }  // namespace cc