cc: optimize Skia image filter application via SkImage::makeWithFilter().

cc/output/gl_renderer.cc

 // Copyright 2010 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/gl_renderer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 35 matching lines @@
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
 #include "skia/ext/texture_handle.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
-#include "third_party/skia/include/gpu/GrTexture.h"
-#include "third_party/skia/include/gpu/GrTextureProvider.h"
 #include "third_party/skia/include/gpu/gl/GrGLInterface.h"
 #include "third_party/skia/include/gpu/gl/GrGLTypes.h"
 #include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 
 using gpu::gles2::GLES2Interface;
 
 namespace cc {
 namespace {
@@ skipping 66 matching lines @@
     case SkXfermode::kColor_Mode:
       return BLEND_MODE_COLOR;
     case SkXfermode::kLuminosity_Mode:
       return BLEND_MODE_LUMINOSITY;
     default:
       NOTREACHED();
       return BLEND_MODE_NONE;
   }
 }
 
-void RoundUpToPow2(gfx::RectF* rect) {
-  float w, h;
-  for (w = 1.f; w < rect->width(); w *= 2.f) {
-  }
-  for (h = 1.f; h < rect->height(); h *= 2.f) {
-  }
-  rect->set_width(w);
-  rect->set_height(h);
-}
-
 // Smallest unit that impact anti-aliasing output. We use this to
 // determine when anti-aliasing is unnecessary.
 const float kAntiAliasingEpsilon = 1.0f / 1024.0f;
 
 // Block or crash if the number of pending sync queries reach this high as
 // something is seriously wrong on the service side if this happens.
 const size_t kMaxPendingSyncQueries = 16;
 
 }  // anonymous namespace
 
@@ skipping 429 matching lines @@
                  (SkColorGetG(color) * (1.0f / 255.0f)) * alpha,
                  (SkColorGetB(color) * (1.0f / 255.0f)) * alpha, alpha);
 
   gl_->LineWidth(quad->width);
 
   // The indices for the line are stored in the same array as the triangle
   // indices.
   gl_->DrawElements(GL_LINE_LOOP, 4, GL_UNSIGNED_SHORT, 0);
 }
 
+static sk_sp<SkImage> WrapTexture(
+    const ResourceProvider::ScopedReadLockGL& lock,
+    GrContext* context) {
+  // Wrap a given texture in a Ganesh platform texture.
+  GrBackendTextureDesc backend_texture_description;
+  GrGLTextureInfo texture_info;
+  texture_info.fTarget = lock.target();
+  texture_info.fID = lock.texture_id();
+  backend_texture_description.fWidth = lock.texture_size().width();
+  backend_texture_description.fHeight = lock.texture_size().height();
+  backend_texture_description.fConfig = kSkia8888_GrPixelConfig;
+  backend_texture_description.fTextureHandle =
+      skia::GrGLTextureInfoToGrBackendObject(texture_info);
+  backend_texture_description.fOrigin = kBottomLeft_GrSurfaceOrigin;
+
+  return SkImage::MakeFromTexture(context, backend_texture_description);
+}
+
 static sk_sp<SkImage> ApplyImageFilter(
     std::unique_ptr<GLRenderer::ScopedUseGrContext> use_gr_context,
     ResourceProvider* resource_provider,
     const gfx::RectF& src_rect,
     const gfx::RectF& dst_rect,
     const gfx::Vector2dF& scale,
     sk_sp<SkImageFilter> filter,
-    ScopedResource* source_texture_resource) {
-  if (!filter)
-    return nullptr;
-
-  if (!use_gr_context)
+    ScopedResource* source_texture_resource,
+    SkIPoint* offset,
+    SkIRect* subset,
+    bool* flip_texture) {
+  if (!filter || !use_gr_context)
     return nullptr;
 
   ResourceProvider::ScopedReadLockGL lock(resource_provider,
                                           source_texture_resource->id());
 
-  // Wrap the source texture in a Ganesh platform texture.
-  GrBackendTextureDesc backend_texture_description;
-  GrGLTextureInfo texture_info;
-  texture_info.fTarget = lock.target();
-  texture_info.fID = lock.texture_id();
-  backend_texture_description.fWidth = source_texture_resource->size().width();
-  backend_texture_description.fHeight =
-      source_texture_resource->size().height();
-  backend_texture_description.fConfig = kSkia8888_GrPixelConfig;
-  backend_texture_description.fTextureHandle =
-      skia::GrGLTextureInfoToGrBackendObject(texture_info);
-  backend_texture_description.fOrigin = kBottomLeft_GrSurfaceOrigin;
-
-  sk_sp<SkImage> src_image = SkImage::MakeFromTexture(
-      use_gr_context->context(), backend_texture_description);
+  sk_sp<SkImage> src_image = WrapTexture(lock, use_gr_context->context());
   if (!src_image) {
     TRACE_EVENT_INSTANT0("cc",
                          "ApplyImageFilter wrap background texture failed",
                          TRACE_EVENT_SCOPE_THREAD);
     return nullptr;
   }
 
-  // Create surface to draw into.
-  SkImageInfo dst_info =
-      SkImageInfo::MakeN32Premul(dst_rect.width(), dst_rect.height());
-  sk_sp<SkSurface> surface = SkSurface::MakeRenderTarget(
-      use_gr_context->context(), SkBudgeted::kYes, dst_info);
-  if (!surface) {
-    TRACE_EVENT_INSTANT0("cc", "ApplyImageFilter surface allocation failed",
-                         TRACE_EVENT_SCOPE_THREAD);
-    return nullptr;
-  }
-
   SkMatrix local_matrix;
-  local_matrix.setScale(scale.x(), scale.y());
+  local_matrix.setTranslate(-src_rect.x(), -src_rect.y());
+  local_matrix.postScale(scale.x(), scale.y());
 
-  SkPaint paint;
-  paint.setImageFilter(filter->makeWithLocalMatrix(local_matrix));
-  surface->getCanvas()->translate(-dst_rect.x(), -dst_rect.y());
-  surface->getCanvas()->drawImage(src_image, src_rect.x(), src_rect.y(),
-                                  &paint);
-  // Flush the drawing before source texture read lock goes out of scope.
-  // Skia API does not guarantee that when the SkImage goes out of scope,
-  // its externally referenced resources would force the rendering to be
-  // flushed.
-  surface->getCanvas()->flush();
-  sk_sp<SkImage> image = surface->makeImageSnapshot();
+  SkIRect clip_bounds = gfx::RectFToSkRect(dst_rect).roundOut();
+  clip_bounds.offset(-src_rect.x(), -src_rect.y());
+  filter = filter->makeWithLocalMatrix(local_matrix);
+  SkIRect in_subset = SkIRect::MakeWH(src_image->width(), src_image->height());
+  sk_sp<SkImage> image = src_image->makeWithFilter(filter.get(), in_subset,
+                                                   clip_bounds, subset, offset);
+
   if (!image || !image->isTextureBacked()) {
     return nullptr;
   }
 
+  // Force a flush of the Skia pipeline before we switch back to the compositor
+  // context.
+  image->getTextureHandle(true);
   CHECK(image->isTextureBacked());
+  *flip_texture = image->getTexture()->origin() == kBottomLeft_GrSurfaceOrigin;

[enne (OOO), 2016/05/20 00:53:45]

Is this ever different? Also, it seems like if you're returning image, you don't
need this out param as well?

[Stephen White, 2016/05/20 03:31:39]

Yep: with SVG filters, you can have an feImage which replaces the input. It gets
converted to a top-down SkImage in Skia. There's actually a layout test that
fails without this (css3/filters/effect-reference-image-hw.html).
Good idea. I'll just move it into the caller.

   return image;
 }
 
 bool GLRenderer::CanApplyBlendModeUsingBlendFunc(SkXfermode::Mode blend_mode) {
   return use_blend_equation_advanced_ ||
          blend_mode == SkXfermode::kScreen_Mode ||
          blend_mode == SkXfermode::kSrcOver_Mode;
 }
 
 void GLRenderer::ApplyBlendModeUsingBlendFunc(SkXfermode::Mode blend_mode) {
@@ skipping 171 matching lines @@
   }
   return device_background_texture;
 }
 
 sk_sp<SkImage> GLRenderer::ApplyBackgroundFilters(
     DrawingFrame* frame,
     const RenderPassDrawQuad* quad,
     ScopedResource* background_texture,
     const gfx::RectF& rect) {
   DCHECK(ShouldApplyBackgroundFilters(quad));
+  auto use_gr_context = ScopedUseGrContext::Create(this, frame);
   sk_sp<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
       quad->background_filters, gfx::SizeF(background_texture->size()));
 
-  sk_sp<SkImage> background_with_filters = ApplyImageFilter(
-      ScopedUseGrContext::Create(this, frame), resource_provider_, rect, rect,
-      quad->filters_scale, std::move(filter), background_texture);
-  return background_with_filters;
+  // TODO(senorblanco): background filters should be moved to the
+  // makeWithFilter fast-path, and go back to calling ApplyImageFilter().
+  // See http://crbug.com/613233.
+  if (!filter || !use_gr_context)
+    return nullptr;
+
+  ResourceProvider::ScopedReadLockGL lock(resource_provider_,
+                                          background_texture->id());
+
+  sk_sp<SkImage> src_image = WrapTexture(lock, use_gr_context->context());
+  if (!src_image) {
+    TRACE_EVENT_INSTANT0(
+        "cc", "ApplyBackgroundFilters wrap background texture failed",
+        TRACE_EVENT_SCOPE_THREAD);
+    return nullptr;
+  }
+
+  // Create surface to draw into.
+  SkImageInfo dst_info =
+      SkImageInfo::MakeN32Premul(rect.width(), rect.height());
+  sk_sp<SkSurface> surface = SkSurface::MakeRenderTarget(
+      use_gr_context->context(), SkBudgeted::kYes, dst_info);
+  if (!surface) {
+    TRACE_EVENT_INSTANT0("cc",
+                         "ApplyBackgroundFilters surface allocation failed",
+                         TRACE_EVENT_SCOPE_THREAD);
+    return nullptr;
+  }
+
+  SkMatrix local_matrix;
+  local_matrix.setScale(quad->filters_scale.x(), quad->filters_scale.y());
+
+  SkPaint paint;
+  paint.setImageFilter(filter->makeWithLocalMatrix(local_matrix));
+  surface->getCanvas()->translate(-rect.x(), -rect.y());
+  surface->getCanvas()->drawImage(src_image, rect.x(), rect.y(), &paint);
+  // Flush the drawing before source texture read lock goes out of scope.
+  // Skia API does not guarantee that when the SkImage goes out of scope,
+  // its externally referenced resources would force the rendering to be
+  // flushed.
+  surface->getCanvas()->flush();
+  sk_sp<SkImage> image = surface->makeImageSnapshot();
+  if (!image || !image->isTextureBacked()) {
+    return nullptr;
+  }
+
+  return image;
 }
 
 // Map device space quad to local space. Device_transform has no 3d
 // component since it was flattened, so we don't need to project.  We should
 // have already checked that the transform was uninvertible before this call.
 gfx::QuadF MapQuadToLocalSpace(const gfx::Transform& device_transform,
                                const gfx::QuadF& device_quad) {
   gfx::Transform inverse_device_transform(gfx::Transform::kSkipInitialization);
   DCHECK(device_transform.IsInvertible());
   bool did_invert = device_transform.GetInverse(&inverse_device_transform);
@@ skipping 111 matching lines @@
   SetBlendEnabled(
       !use_shaders_for_blending &&
       (quad->ShouldDrawWithBlending() || !IsDefaultBlendMode(blend_mode)));
 
   // TODO(senorblanco): Cache this value so that we don't have to do it for both
   // the surface and its replica.  Apply filters to the contents texture.
   sk_sp<SkImage> filter_image;
   GLuint filter_image_id = 0;
   SkScalar color_matrix[20];
   bool use_color_matrix = false;
-  gfx::RectF rect = gfx::RectF(quad->rect);
+  gfx::Size texture_size = contents_texture->size();
+  bool flip_texture = true;
+  gfx::Point src_offset;
   if (!quad->filters.IsEmpty()) {
     sk_sp<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
         quad->filters, gfx::SizeF(contents_texture->size()));
     if (filter) {
       SkColorFilter* colorfilter_rawptr = NULL;
       filter->asColorFilter(&colorfilter_rawptr);
       sk_sp<SkColorFilter> cf(colorfilter_rawptr);
 
       if (cf && cf->asColorMatrix(color_matrix)) {
         // We have a color matrix at the root of the filter DAG; apply it
@@ skipping 10 matching lines @@
         gfx::Transform transform =
             quad->shared_quad_state->quad_to_target_transform;
         gfx::QuadF clip_quad = gfx::QuadF(gfx::RectF(clip_rect));
         gfx::QuadF local_clip = MapQuadToLocalSpace(transform, clip_quad);
         dst_rect.Intersect(local_clip.BoundingBox());
         // If we've been fully clipped out (by crop rect or clipping), there's
         // nothing to draw.
         if (dst_rect.IsEmpty()) {
           return;
         }
-        // Expand dst_rect size to the nearest power of 2, in order to get
-        // more cache hits in Skia's texture cache.
-        RoundUpToPow2(&dst_rect);
+        SkIPoint offset;
+        SkIRect subset;
+        gfx::RectF src_rect(quad->rect);
         filter_image = ApplyImageFilter(
-            ScopedUseGrContext::Create(this, frame), resource_provider_, rect,
-            dst_rect, quad->filters_scale, std::move(filter), contents_texture);
+            ScopedUseGrContext::Create(this, frame), resource_provider_,
+            src_rect, dst_rect, quad->filters_scale, std::move(filter),
+            contents_texture, &offset, &subset, &flip_texture);
         if (!filter_image) {
           return;
         }
         filter_image_id = skia::GrBackendObjectToGrGLTextureInfo(
                               filter_image->getTextureHandle(true))
                               ->fID;
+        texture_size.set_width(filter_image->width());
+        texture_size.set_height(filter_image->height());
         DCHECK(filter_image_id);
+        dst_rect =
+            gfx::RectF(src_rect.x() + offset.fX, src_rect.y() + offset.fY,
+                       subset.width(), subset.height());
+        src_offset.SetPoint(subset.x(), subset.y());
       }
     }
   }
 
   std::unique_ptr<ResourceProvider::ScopedSamplerGL> mask_resource_lock;
   unsigned mask_texture_id = 0;
   SamplerType mask_sampler = SAMPLER_TYPE_NA;
   if (quad->mask_resource_id()) {
     mask_resource_lock.reset(new ResourceProvider::ScopedSamplerGL(
         resource_provider_, quad->mask_resource_id(), GL_TEXTURE1, GL_LINEAR));
@@ skipping 91 matching lines @@
     program->fragment_shader().FillLocations(&locations);
     gl_->Uniform1i(locations.sampler, 0);
   } else {
     const RenderPassProgram* program =
         GetRenderPassProgram(tex_coord_precision, shader_blend_mode);
     SetUseProgram(program->program());
     program->vertex_shader().FillLocations(&locations);
     program->fragment_shader().FillLocations(&locations);
     gl_->Uniform1i(locations.sampler, 0);
   }
-  float tex_scale_x, tex_scale_y;
-  if (filter_image) {
-    // Skia filters always return SkImages with snug textures.
-    tex_scale_x = tex_scale_y = 1.0f;
-  } else {
-    tex_scale_x = quad->rect.width() /
-                  static_cast<float>(contents_texture->size().width());
-    tex_scale_y = quad->rect.height() /
-                  static_cast<float>(contents_texture->size().height());
-  }
-  DCHECK_LE(tex_scale_x, 1.0f);
-  DCHECK_LE(tex_scale_y, 1.0f);
+  gfx::RectF tex_rect(src_offset.x(), src_offset.y(), dst_rect.width(),
+                      dst_rect.height());
+  tex_rect.Scale(1.0f / texture_size.width(), 1.0f / texture_size.height());
 
   DCHECK(locations.tex_transform != -1 || IsContextLost());
-  // Flip the content vertically in the shader, as the RenderPass input
-  // texture is already oriented the same way as the framebuffer, but the
-  // projection transform does a flip.
-  gl_->Uniform4f(locations.tex_transform, 0.0f, 1.0f, tex_scale_x,
-                 -tex_scale_y);
+  if (flip_texture) {
+    // Flip the content vertically in the shader, as the RenderPass input
+    // texture is already oriented the same way as the framebuffer, but the
+    // projection transform does a flip.
+    gl_->Uniform4f(locations.tex_transform, tex_rect.x(), 1.0f - tex_rect.y(),
+                   tex_rect.width(), -tex_rect.height());
+  } else {
+    gl_->Uniform4f(locations.tex_transform, tex_rect.x(), tex_rect.y(),
+                   tex_rect.width(), tex_rect.height());
+  }
 
   GLint last_texture_unit = 0;
   if (locations.mask_sampler != -1) {
     DCHECK_NE(locations.mask_tex_coord_scale, 1);
     DCHECK_NE(locations.mask_tex_coord_offset, 1);
     gl_->Uniform1i(locations.mask_sampler, 1);
 
     gfx::RectF mask_uv_rect = quad->MaskUVRect();
     if (mask_sampler != SAMPLER_TYPE_2D) {
       mask_uv_rect.Scale(quad->mask_texture_size.width(),
                          quad->mask_texture_size.height());
     }
 
     // Mask textures are oriented vertically flipped relative to the framebuffer
     // and the RenderPass contents texture, so we flip the tex coords from the
     // RenderPass texture to find the mask texture coords.
-    gl_->Uniform2f(locations.mask_tex_coord_offset, mask_uv_rect.x(),
-                   mask_uv_rect.height() / tex_scale_y + mask_uv_rect.y());
+    gl_->Uniform2f(
+        locations.mask_tex_coord_offset, mask_uv_rect.x(),
+        mask_uv_rect.height() / tex_rect.height() + mask_uv_rect.y());
     gl_->Uniform2f(locations.mask_tex_coord_scale,
-                   mask_uv_rect.width() / tex_scale_x,
-                   -mask_uv_rect.height() / tex_scale_y);
+                   mask_uv_rect.width() / tex_rect.width(),
+                   -mask_uv_rect.height() / tex_rect.height());
 
     last_texture_unit = 1;
   }
 
   if (locations.edge != -1)
     gl_->Uniform3fv(locations.edge, 8, edge);
 
   if (locations.viewport != -1) {
     float viewport[4] = {
         static_cast<float>(current_window_space_viewport_.x()),
@@ skipping 2379 matching lines @@
       texture_id = pending_overlay_resources_.back()->texture_id();
     }
 
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order, overlay.transform, texture_id,
         ToNearestRect(overlay.display_rect), overlay.uv_rect);
   }
 }
 
 }  // namespace cc