Index: cc/render_surface_filters.cc |
diff --git a/cc/render_surface_filters.cc b/cc/render_surface_filters.cc |
deleted file mode 100644 |
index 8f61c698512f4e606ec1db3b167bb97d804f102e..0000000000000000000000000000000000000000 |
--- a/cc/render_surface_filters.cc |
+++ /dev/null |
@@ -1,461 +0,0 @@ |
-// 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/render_surface_filters.h" |
- |
-#include "base/logging.h" |
-#include "skia/ext/refptr.h" |
-#include "third_party/WebKit/Source/Platform/chromium/public/WebFilterOperation.h" |
-#include "third_party/WebKit/Source/Platform/chromium/public/WebFilterOperations.h" |
-#include "third_party/skia/include/core/SkCanvas.h" |
-#include "third_party/skia/include/effects/SkBlurImageFilter.h" |
-#include "third_party/skia/include/effects/SkColorMatrixFilter.h" |
-#include "third_party/skia/include/effects/SkMagnifierImageFilter.h" |
-#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 |
- // (http://dvcs.w3.org/hg/FXTF/raw-file/tip/filters/index.html#brightnessEquivalent) |
- // <feFunc[R|G|B] type="linear" slope="[amount]"> |
- memset(matrix, 0, 20 * sizeof(SkScalar)); |
- matrix[0] = matrix[6] = matrix[12] = amount; |
- matrix[18] = 1.f; |
-} |
- |
-void GetSaturatingBrightnessMatrix(float amount, SkScalar matrix[20]) { |
- // Legacy implementation used by internal clients. |
- // <feFunc[R|G|B] type="linear" intercept="[amount]"/> |
- memset(matrix, 0, 20 * sizeof(SkScalar)); |
- matrix[0] = matrix[6] = matrix[12] = matrix[18] = 1.f; |
- matrix[4] = matrix[9] = matrix[14] = amount * 255.f; |
-} |
- |
-void GetContrastMatrix(float amount, SkScalar matrix[20]) { |
- memset(matrix, 0, 20 * sizeof(SkScalar)); |
- matrix[0] = matrix[6] = matrix[12] = amount; |
- matrix[4] = matrix[9] = matrix[14] = (-0.5f * amount + 0.5f) * 255.f; |
- matrix[18] = 1.f; |
-} |
- |
-void GetSaturateMatrix(float amount, SkScalar matrix[20]) { |
- // Note, these values are computed to ensure matrixNeedsClamping is false |
- // for amount in [0..1] |
- matrix[0] = 0.213f + 0.787f * amount; |
- matrix[1] = 0.715f - 0.715f * amount; |
- matrix[2] = 1.f - (matrix[0] + matrix[1]); |
- matrix[3] = matrix[4] = 0.f; |
- matrix[5] = 0.213f - 0.213f * amount; |
- matrix[6] = 0.715f + 0.285f * amount; |
- matrix[7] = 1.f - (matrix[5] + matrix[6]); |
- matrix[8] = matrix[9] = 0.f; |
- matrix[10] = 0.213f - 0.213f * amount; |
- matrix[11] = 0.715f - 0.715f * amount; |
- matrix[12] = 1.f - (matrix[10] + matrix[11]); |
- matrix[13] = matrix[14] = 0.f; |
- matrix[15] = matrix[16] = matrix[17] = matrix[19] = 0.f; |
- matrix[18] = 1.f; |
-} |
- |
-void GetHueRotateMatrix(float hue, SkScalar matrix[20]) { |
- const float kPi = 3.1415926535897932384626433832795f; |
- |
- float cos_hue = cosf(hue * kPi / 180.f); |
- float sin_hue = sinf(hue * kPi / 180.f); |
- matrix[0] = 0.213f + cos_hue * 0.787f - sin_hue * 0.213f; |
- matrix[1] = 0.715f - cos_hue * 0.715f - sin_hue * 0.715f; |
- matrix[2] = 0.072f - cos_hue * 0.072f + sin_hue * 0.928f; |
- matrix[3] = matrix[4] = 0.f; |
- matrix[5] = 0.213f - cos_hue * 0.213f + sin_hue * 0.143f; |
- matrix[6] = 0.715f + cos_hue * 0.285f + sin_hue * 0.140f; |
- matrix[7] = 0.072f - cos_hue * 0.072f - sin_hue * 0.283f; |
- matrix[8] = matrix[9] = 0.f; |
- matrix[10] = 0.213f - cos_hue * 0.213f - sin_hue * 0.787f; |
- matrix[11] = 0.715f - cos_hue * 0.715f + sin_hue * 0.715f; |
- matrix[12] = 0.072f + cos_hue * 0.928f + sin_hue * 0.072f; |
- matrix[13] = matrix[14] = 0.f; |
- matrix[15] = matrix[16] = matrix[17] = 0.f; |
- matrix[18] = 1.f; |
- matrix[19] = 0.f; |
-} |
- |
-void GetInvertMatrix(float amount, SkScalar matrix[20]) { |
- memset(matrix, 0, 20 * sizeof(SkScalar)); |
- matrix[0] = matrix[6] = matrix[12] = 1.f - 2.f * amount; |
- matrix[4] = matrix[9] = matrix[14] = amount * 255.f; |
- matrix[18] = 1.f; |
-} |
- |
-void GetOpacityMatrix(float amount, SkScalar matrix[20]) { |
- memset(matrix, 0, 20 * sizeof(SkScalar)); |
- matrix[0] = matrix[6] = matrix[12] = 1.f; |
- matrix[18] = amount; |
-} |
- |
-void GetGrayscaleMatrix(float amount, SkScalar matrix[20]) { |
- // Note, these values are computed to ensure matrixNeedsClamping is false |
- // for amount in [0..1] |
- matrix[0] = 0.2126f + 0.7874f * amount; |
- matrix[1] = 0.7152f - 0.7152f * amount; |
- matrix[2] = 1.f - (matrix[0] + matrix[1]); |
- matrix[3] = matrix[4] = 0.f; |
- |
- matrix[5] = 0.2126f - 0.2126f * amount; |
- matrix[6] = 0.7152f + 0.2848f * amount; |
- matrix[7] = 1.f - (matrix[5] + matrix[6]); |
- matrix[8] = matrix[9] = 0.f; |
- |
- matrix[10] = 0.2126f - 0.2126f * amount; |
- matrix[11] = 0.7152f - 0.7152f * amount; |
- matrix[12] = 1.f - (matrix[10] + matrix[11]); |
- matrix[13] = matrix[14] = 0.f; |
- |
- matrix[15] = matrix[16] = matrix[17] = matrix[19] = 0.f; |
- matrix[18] = 1.f; |
-} |
- |
-void GetSepiaMatrix(float amount, SkScalar matrix[20]) { |
- matrix[0] = 0.393f + 0.607f * amount; |
- matrix[1] = 0.769f - 0.769f * amount; |
- matrix[2] = 0.189f - 0.189f * amount; |
- matrix[3] = matrix[4] = 0.f; |
- |
- matrix[5] = 0.349f - 0.349f * amount; |
- matrix[6] = 0.686f + 0.314f * amount; |
- matrix[7] = 0.168f - 0.168f * amount; |
- matrix[8] = matrix[9] = 0.f; |
- |
- matrix[10] = 0.272f - 0.272f * amount; |
- matrix[11] = 0.534f - 0.534f * amount; |
- matrix[12] = 0.131f + 0.869f * amount; |
- matrix[13] = matrix[14] = 0.f; |
- |
- matrix[15] = matrix[16] = matrix[17] = matrix[19] = 0.f; |
- matrix[18] = 1.f; |
-} |
- |
-// The 5x4 matrix is really a "compressed" version of a 5x5 matrix that'd have |
-// (0 0 0 0 1) as a last row, and that would be applied to a 5-vector extended |
-// from the 4-vector color with a 1. |
-void MultColorMatrix(SkScalar a[20], SkScalar b[20], SkScalar out[20]) { |
- for (int j = 0; j < 4; ++j) { |
- for (int i = 0; i < 5; ++i) { |
- out[i+j*5] = i == 4 ? a[4+j*5] : 0.f; |
- for (int k = 0; k < 4; ++k) |
- out[i+j*5] += a[k+j*5] * b[i+k*5]; |
- } |
- } |
-} |
- |
-// To detect if we need to apply clamping after applying a matrix, we check if |
-// any output component might go outside of [0, 255] for any combination of |
-// input components in [0..255]. |
-// Each output component is an affine transformation of the input component, so |
-// the minimum and maximum values are for any combination of minimum or maximum |
-// values of input components (i.e. 0 or 255). |
-// E.g. if R' = x*R + y*G + z*B + w*A + t |
-// Then the maximum value will be for R=255 if x>0 or R=0 if x<0, and the |
-// minimum value will be for R=0 if x>0 or R=255 if x<0. |
-// Same goes for all components. |
-bool ComponentNeedsClamping(SkScalar row[5]) { |
- SkScalar max_value = row[4] / 255.f; |
- SkScalar min_value = row[4] / 255.f; |
- for (int i = 0; i < 4; ++i) { |
- if (row[i] > 0) |
- max_value += row[i]; |
- else |
- min_value += row[i]; |
- } |
- return (max_value > 1.f) || (min_value < 0.f); |
-} |
- |
-bool MatrixNeedsClamping(SkScalar matrix[20]) { |
- return ComponentNeedsClamping(matrix) |
- || ComponentNeedsClamping(matrix+5) |
- || ComponentNeedsClamping(matrix+10) |
- || ComponentNeedsClamping(matrix+15); |
-} |
- |
-bool GetColorMatrix(const WebKit::WebFilterOperation& op, SkScalar matrix[20]) { |
- switch (op.type()) { |
- case WebKit::WebFilterOperation::FilterTypeBrightness: { |
- GetBrightnessMatrix(op.amount(), matrix); |
- return true; |
- } |
- case WebKit::WebFilterOperation::FilterTypeSaturatingBrightness: { |
- GetSaturatingBrightnessMatrix(op.amount(), matrix); |
- return true; |
- } |
- case WebKit::WebFilterOperation::FilterTypeContrast: { |
- GetContrastMatrix(op.amount(), matrix); |
- return true; |
- } |
- case WebKit::WebFilterOperation::FilterTypeGrayscale: { |
- GetGrayscaleMatrix(1.f - op.amount(), matrix); |
- return true; |
- } |
- case WebKit::WebFilterOperation::FilterTypeSepia: { |
- GetSepiaMatrix(1.f - op.amount(), matrix); |
- return true; |
- } |
- case WebKit::WebFilterOperation::FilterTypeSaturate: { |
- GetSaturateMatrix(op.amount(), matrix); |
- return true; |
- } |
- case WebKit::WebFilterOperation::FilterTypeHueRotate: { |
- GetHueRotateMatrix(op.amount(), matrix); |
- return true; |
- } |
- case WebKit::WebFilterOperation::FilterTypeInvert: { |
- GetInvertMatrix(op.amount(), matrix); |
- return true; |
- } |
- case WebKit::WebFilterOperation::FilterTypeOpacity: { |
- GetOpacityMatrix(op.amount(), matrix); |
- return true; |
- } |
- case WebKit::WebFilterOperation::FilterTypeColorMatrix: { |
- memcpy(matrix, op.matrix(), sizeof(SkScalar[20])); |
- return true; |
- } |
- default: |
- return false; |
- } |
-} |
- |
-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(); |
- backend_texture_description.fHeight = size.height(); |
- backend_texture_description.fConfig = kSkia8888_GrPixelConfig; |
- backend_texture_description.fTextureHandle = texture_id; |
- skia::RefPtr<GrTexture> texture = skia::AdoptRef( |
- gr_context->wrapBackendTexture(backend_texture_description)); |
- // Place the platform texture inside an SkBitmap. |
- source_.setConfig(SkBitmap::kARGB_8888_Config, size.width(), size.height()); |
- skia::RefPtr<SkGrPixelRef> pixel_ref = |
- skia::AdoptRef(new SkGrPixelRef(texture.get())); |
- source_.setPixelRef(pixel_ref.get()); |
- } |
- |
- ~FilterBufferState() {} |
- |
- bool Init(int filter_count) { |
- int scratch_count = std::min(2, filter_count); |
- GrTextureDesc desc; |
- desc.fFlags = kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit; |
- desc.fSampleCnt = 0; |
- desc.fWidth = source_.width(); |
- desc.fHeight = source_.height(); |
- desc.fConfig = kSkia8888_GrPixelConfig; |
- for (int i = 0; i < scratch_count; ++i) { |
- GrAutoScratchTexture scratch_texture( |
- gr_context_, desc, GrContext::kExact_ScratchTexMatch); |
- scratch_textures_[i] = skia::AdoptRef(scratch_texture.detach()); |
- if (!scratch_textures_[i]) |
- return false; |
- } |
- return true; |
- } |
- |
- SkCanvas* Canvas() { |
- if (!canvas_.get()) |
- CreateCanvas(); |
- return canvas_.get(); |
- } |
- |
- const SkBitmap& Source() { return source_; } |
- |
- void Swap() { |
- canvas_->flush(); |
- canvas_.clear(); |
- device_.clear(); |
- |
- skia::RefPtr<SkGrPixelRef> pixel_ref = skia::AdoptRef( |
- new SkGrPixelRef(scratch_textures_[current_texture_].get())); |
- source_.setPixelRef(pixel_ref.get()); |
- current_texture_ = 1 - current_texture_; |
- } |
- |
- private: |
- void CreateCanvas() { |
- DCHECK(scratch_textures_[current_texture_].get()); |
- device_ = skia::AdoptRef(new SkGpuDevice( |
- gr_context_, scratch_textures_[current_texture_].get())); |
- canvas_ = skia::AdoptRef(new SkCanvas(device_.get())); |
- canvas_->clear(0x0); |
- } |
- |
- GrContext* gr_context_; |
- SkBitmap source_; |
- skia::RefPtr<GrTexture> scratch_textures_[2]; |
- int current_texture_; |
- skia::RefPtr<SkGpuDevice> device_; |
- skia::RefPtr<SkCanvas> canvas_; |
-}; |
- |
-} // namespace |
- |
-WebKit::WebFilterOperations RenderSurfaceFilters::Optimize( |
- const WebKit::WebFilterOperations& filters) { |
- WebKit::WebFilterOperations new_list; |
- |
- SkScalar accumulated_color_matrix[20]; |
- bool have_accumulated_color_matrix = false; |
- for (unsigned i = 0; i < filters.size(); ++i) { |
- const WebKit::WebFilterOperation& op = filters.at(i); |
- |
- // If the filter is a color matrix, we may be able to combine it with |
- // following Filter(s) that also are color matrices. |
- SkScalar matrix[20]; |
- if (GetColorMatrix(op, matrix)) { |
- if (have_accumulated_color_matrix) { |
- SkScalar newMatrix[20]; |
- MultColorMatrix(matrix, accumulated_color_matrix, newMatrix); |
- memcpy(accumulated_color_matrix, |
- newMatrix, |
- sizeof(accumulated_color_matrix)); |
- } else { |
- memcpy(accumulated_color_matrix, |
- matrix, |
- sizeof(accumulated_color_matrix)); |
- have_accumulated_color_matrix = true; |
- } |
- |
- // We can only combine matrices if clamping of color components |
- // would have no effect. |
- if (!MatrixNeedsClamping(accumulated_color_matrix)) |
- continue; |
- } |
- |
- if (have_accumulated_color_matrix) { |
- new_list.append(WebKit::WebFilterOperation::createColorMatrixFilter( |
- accumulated_color_matrix)); |
- } |
- have_accumulated_color_matrix = false; |
- |
- switch (op.type()) { |
- case WebKit::WebFilterOperation::FilterTypeBlur: |
- case WebKit::WebFilterOperation::FilterTypeDropShadow: |
- case WebKit::WebFilterOperation::FilterTypeZoom: |
- new_list.append(op); |
- break; |
- case WebKit::WebFilterOperation::FilterTypeBrightness: |
- case WebKit::WebFilterOperation::FilterTypeSaturatingBrightness: |
- case WebKit::WebFilterOperation::FilterTypeContrast: |
- case WebKit::WebFilterOperation::FilterTypeGrayscale: |
- case WebKit::WebFilterOperation::FilterTypeSepia: |
- case WebKit::WebFilterOperation::FilterTypeSaturate: |
- case WebKit::WebFilterOperation::FilterTypeHueRotate: |
- case WebKit::WebFilterOperation::FilterTypeInvert: |
- case WebKit::WebFilterOperation::FilterTypeOpacity: |
- case WebKit::WebFilterOperation::FilterTypeColorMatrix: |
- break; |
- } |
- } |
- if (have_accumulated_color_matrix) { |
- new_list.append(WebKit::WebFilterOperation::createColorMatrixFilter( |
- accumulated_color_matrix)); |
- } |
- return new_list; |
-} |
- |
-SkBitmap RenderSurfaceFilters::Apply(const WebKit::WebFilterOperations& filters, |
- unsigned texture_id, |
- gfx::SizeF size, |
- GrContext* gr_context) { |
- DCHECK(gr_context); |
- |
- WebKit::WebFilterOperations optimized_filters = Optimize(filters); |
- FilterBufferState state(gr_context, size, texture_id); |
- if (!state.Init(optimized_filters.size())) |
- return SkBitmap(); |
- |
- for (unsigned i = 0; i < optimized_filters.size(); ++i) { |
- const WebKit::WebFilterOperation& op = optimized_filters.at(i); |
- SkCanvas* canvas = state.Canvas(); |
- switch (op.type()) { |
- case WebKit::WebFilterOperation::FilterTypeColorMatrix: { |
- SkPaint paint; |
- skia::RefPtr<SkColorMatrixFilter> filter = |
- skia::AdoptRef(new SkColorMatrixFilter(op.matrix())); |
- paint.setColorFilter(filter.get()); |
- canvas->drawBitmap(state.Source(), 0, 0, &paint); |
- break; |
- } |
- case WebKit::WebFilterOperation::FilterTypeBlur: { |
- float std_deviation = op.amount(); |
- skia::RefPtr<SkImageFilter> filter = |
- skia::AdoptRef(new SkBlurImageFilter(std_deviation, std_deviation)); |
- SkPaint paint; |
- paint.setImageFilter(filter.get()); |
- canvas->drawSprite(state.Source(), 0, 0, &paint); |
- break; |
- } |
- case WebKit::WebFilterOperation::FilterTypeDropShadow: { |
- skia::RefPtr<SkImageFilter> blur_filter = |
- skia::AdoptRef(new SkBlurImageFilter(op.amount(), op.amount())); |
- skia::RefPtr<SkColorFilter> color_filter = |
- skia::AdoptRef(SkColorFilter::CreateModeFilter( |
- op.dropShadowColor(), SkXfermode::kSrcIn_Mode)); |
- SkPaint paint; |
- paint.setImageFilter(blur_filter.get()); |
- paint.setColorFilter(color_filter.get()); |
- paint.setXfermodeMode(SkXfermode::kSrcOver_Mode); |
- canvas->saveLayer(NULL, &paint); |
- canvas->drawBitmap(state.Source(), |
- op.dropShadowOffset().x, |
- -op.dropShadowOffset().y); |
- canvas->restore(); |
- canvas->drawBitmap(state.Source(), 0, 0); |
- break; |
- } |
- case WebKit::WebFilterOperation::FilterTypeZoom: { |
- SkPaint paint; |
- int width = state.Source().width(); |
- int height = state.Source().height(); |
- skia::RefPtr<SkImageFilter> zoom_filter = skia::AdoptRef( |
- new SkMagnifierImageFilter( |
- SkRect::MakeXYWH( |
- (width - (width / op.amount())) / 2.f, |
- (height - (height / op.amount())) / 2.f, |
- width / op.amount(), |
- height / op.amount()), |
- op.zoomInset())); |
- paint.setImageFilter(zoom_filter.get()); |
- canvas->saveLayer(NULL, &paint); |
- canvas->drawBitmap(state.Source(), 0, 0); |
- canvas->restore(); |
- break; |
- } |
- case WebKit::WebFilterOperation::FilterTypeBrightness: |
- case WebKit::WebFilterOperation::FilterTypeSaturatingBrightness: |
- case WebKit::WebFilterOperation::FilterTypeContrast: |
- case WebKit::WebFilterOperation::FilterTypeGrayscale: |
- case WebKit::WebFilterOperation::FilterTypeSepia: |
- case WebKit::WebFilterOperation::FilterTypeSaturate: |
- case WebKit::WebFilterOperation::FilterTypeHueRotate: |
- case WebKit::WebFilterOperation::FilterTypeInvert: |
- case WebKit::WebFilterOperation::FilterTypeOpacity: |
- NOTREACHED(); |
- break; |
- } |
- state.Swap(); |
- } |
- return state.Source(); |
-} |
- |
-} // namespace cc |