mix-blend-mode implementation for accelerated layers

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 <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 585 matching lines @@
   // Flush the GL context so rendering results from this context are
   // visible in the compositor's context.
   offscreen_contexts->Context3d()->flush();
 
   // Use the compositor's GL context again.
   renderer->Context()->makeContextCurrent();
 
   return device.accessBitmap(false);
 }
 
-scoped_ptr<ScopedResource> GLRenderer::DrawBackgroundFilters(
+static SkBitmap ApplyBlendModeWithBackdrop(GLRenderer* renderer,
+    ContextProvider* offscreen_contexts,
+    SkBitmap source_bitmap_with_filters,
+    ScopedResource* source_texture_resource,
+    ScopedResource* background_texture_resource,
+    SkXfermode::Mode blendMode) {
+  if (!offscreen_contexts || !offscreen_contexts->GrContext())
+      return source_bitmap_with_filters;
+
+  DCHECK(background_texture_resource);
+  DCHECK(source_texture_resource);
+
+  gfx::Size source_size = source_texture_resource->size();
+  gfx::Size background_size = background_texture_resource->size();
+
+  DCHECK_LE(background_size.width(), source_size.width());
+  DCHECK_LE(background_size.height(), source_size.height());
+
+  int source_texture_with_filters_id;
+  scoped_ptr<ResourceProvider::ScopedReadLockGL> lock;
+  if (source_bitmap_with_filters.getTexture()) {
+      DCHECK(source_size.width() == source_bitmap_with_filters.width());
+      DCHECK(source_size.height() == source_bitmap_with_filters.height());
+      GrTexture* texture =
+          reinterpret_cast<GrTexture*>(source_bitmap_with_filters.getTexture());
+      source_texture_with_filters_id = texture->getTextureHandle();
+  } else {
+      lock.reset(
+          new ResourceProvider::ScopedReadLockGL(renderer->resource_provider(),
+          source_texture_resource->id()));
+      source_texture_with_filters_id = lock->texture_id();
+  }
+
+  ResourceProvider::ScopedReadLockGL lock_background(
+      renderer->resource_provider(), background_texture_resource->id());
+
+  // Flush the compositor context to ensure that textures there are available
+  // in the shared context.  Do this after locking/creating the compositor
+  // texture.
+  renderer->resource_provider()->Flush();
+
+  // Make sure skia uses the correct GL context.
+  offscreen_contexts->Context3d()->makeContextCurrent();
+
+  // Wrap the source texture in a Ganesh platform texture.
+  GrBackendTextureDesc backend_texture_description;
+  backend_texture_description.fConfig = kSkia8888_GrPixelConfig;
+  backend_texture_description.fOrigin = kBottomLeft_GrSurfaceOrigin;
+
+  backend_texture_description.fWidth = source_size.width();
+  backend_texture_description.fHeight = source_size.height();
+  backend_texture_description.fTextureHandle = source_texture_with_filters_id;
+  skia::RefPtr<GrTexture> source_texture =
+      skia::AdoptRef(offscreen_contexts->GrContext()->wrapBackendTexture(
+          backend_texture_description));
+
+  backend_texture_description.fWidth = background_size.width();
+  backend_texture_description.fHeight = background_size.height();
+  backend_texture_description.fTextureHandle = lock_background.texture_id();
+  skia::RefPtr<GrTexture> background_texture =
+      skia::AdoptRef(offscreen_contexts->GrContext()->wrapBackendTexture(
+          backend_texture_description));
+
+  // Place the platform texture inside an SkBitmap.
+  SkBitmap source;
+  source.setConfig(SkBitmap::kARGB_8888_Config,
+      source_size.width(), source_size.height());
+  skia::RefPtr<SkGrPixelRef> source_pixel_ref =
+      skia::AdoptRef(new SkGrPixelRef(source_texture.get()));
+  source.setPixelRef(source_pixel_ref.get());
+
+  SkBitmap background;
+  background.setConfig(SkBitmap::kARGB_8888_Config,
+      background_size.width(), background_size.height());
+  skia::RefPtr<SkGrPixelRef> background_pixel_ref =
+      skia::AdoptRef(new SkGrPixelRef(background_texture.get()));
+  background.setPixelRef(background_pixel_ref.get());
+
+  // Create a scratch texture for backing store.
+  GrTextureDesc desc;
+  desc.fFlags = kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit;
+  desc.fSampleCnt = 0;
+  desc.fWidth = source.width();
+  desc.fHeight = source.height();
+  desc.fConfig = kSkia8888_GrPixelConfig;
+  desc.fOrigin = kBottomLeft_GrSurfaceOrigin;
+  GrAutoScratchTexture scratch_texture(
+      offscreen_contexts->GrContext(), desc, GrContext::kExact_ScratchTexMatch);
+  skia::RefPtr<GrTexture> backing_store =
+      skia::AdoptRef(scratch_texture.detach());
+
+  // Create a device and canvas using that backing store.
+  SkGpuDevice device(offscreen_contexts->GrContext(), backing_store.get());
+  SkCanvas canvas(&device);
+
+  // Draw the source bitmap through the filter to the canvas.
+  canvas.clear(SK_ColorTRANSPARENT);
+  canvas.drawSprite(background, 0, 0);
+  SkPaint paint;
+  paint.setXfermodeMode(blendMode);
+  canvas.drawSprite(source, 0, 0, &paint);
+
+  // Flush skia context so that all the rendered stuff appears on the
+  // texture.
+  offscreen_contexts->GrContext()->flush();
+
+  // Flush the GL context so rendering results from this context are
+  // visible in the compositor's context.
+  offscreen_contexts->Context3d()->flush();
+
+  // Use the compositor's GL context again.
+  renderer->Context()->makeContextCurrent();
+
+  return device.accessBitmap(false);
+}
+
+scoped_ptr<ScopedResource> GLRenderer::CreateBackgroundTextureWithFilters(
     DrawingFrame* frame,
     const RenderPassDrawQuad* quad,
     const gfx::Transform& contents_device_transform,
-    const gfx::Transform& contents_device_transform_inverse) {
+    const gfx::Transform& contents_device_transform_inverse,
+    bool* background_changed) {
   // This method draws a background filter, which applies a filter to any pixels
   // behind the quad and seen through its background.  The algorithm works as
   // follows:
   // 1. Compute a bounding box around the pixels that will be visible through
   // the quad.
   // 2. Read the pixels in the bounding box into a buffer R.
   // 3. Apply the background filter to R, so that it is applied in the pixels'
   // coordinate space.
   // 4. Apply the quad's inverse transform to map the pixels in R into the
   // quad's content space. This implicitly clips R by the content bounds of the
   // quad since the destination texture has bounds matching the quad's content.
   // 5. Draw the background texture for the contents using the same transform as
   // used to draw the contents itself. This is done without blending to replace
   // the current background pixels with the new filtered background.
   // 6. Draw the contents of the quad over drop of the new background with
   // blending, as per usual. The filtered background pixels will show through
   // any non-opaque pixels in this draws.
   //
   // Pixel copies in this algorithm occur at steps 2, 3, 4, and 5.
 
   // TODO(danakj): When this algorithm changes, update
   // LayerTreeHost::PrioritizeTextures() accordingly.
 
   FilterOperations filters =
       RenderSurfaceFilters::Optimize(quad->background_filters);
-  DCHECK(!filters.IsEmpty());
+  DCHECK(!filters.IsEmpty() ||
+      quad->shared_quad_state->blend_mode != SkXfermode::kSrcOver_Mode);
 
   // TODO(danakj): We only allow background filters on an opaque render surface
   // because other surfaces may contain translucent pixels, and the contents
   // behind those translucent pixels wouldn't have the filter applied.
-  if (frame->current_render_pass->has_transparent_background)
-    return scoped_ptr<ScopedResource>();
+  bool apply_background_filters = !filters.IsEmpty() &&

[enne (OOO), 2013/09/26 16:25:13]

How does this TODO not apply to this path as well? Can you add a test for blend
modes on a layer whose target is a non-root (i.e. transparent) render surface?

[rosca, 2013/09/27 10:39:06]

Blend modes should work with transparent pixels. Blending any color with a
transparent pixel will not affect the initial color. I will add a test for this
case. Thanks.

[enne (OOO), 2013/09/27 17:42:33]

Ah, I think there may be some confusion here.  Here's a potential layer tree:

-G (draws green rectangle)
 -S (creates surface)
  -B (some blend mode that uses the background)

G draws into the default root render target.  If you apply the background filter
before drawing B, the current render target is S, which is transparent and has
nothing drawn into it because G drew into the root and not into S.  To blend
correctly, I think B needs to blend with G, yes?

[rosca, 2013/09/30 17:28:36]

According to the spec, an element having a blend mode must blend with all the
underlying content of the stacking context that element belongs to. So, for B in
this case, the underlying content is just a transparent layer, and blending with
a transparent layer will have no effect on the result. Just to make sure I got
it right, I made this codepen: http://codepen.io/anon/pen/glCqo.

[enne (OOO), 2013/09/30 21:26:52]

I think that is true only if S is also a stacking context.  What if G is the
parent stacking context for B?  Not every layer or surface in the compositor
corresponds to a stacking context in Blink.  I think your example would blend
incorrectly when S is not a stacking context but G and B are.

(Also, in your example, .surface only creates a layer and not a surface.  If you
turn on composited layer borders, orange is the color for a layer whereas purple
is the color for a surface.)

In your example, the div for B is a layer with a stacking context (because it
has a blend mode) and by the blending spec it must blend with everything in its
parent stacking context.  G is a non-composited child of the root layer, which
is a stacking context here, so that seems fine.  This all seems good.

However, to be a proper example, S needs to be changed to be promoted to being a
layer without being a stacking context *and* creating a surface while not
creating a stacking context.  Most CSS properties that do either of these things
are also stacking contexts (for good reason), but I don't think it's correct to
assume that all of them do (or will in the future).  It's also not correct to
assume that the compositor will only create surfaces for stacking contexts as
well.

Here are some suggestions off the top of my head to modify your example,
although my confidence level as to whether these are stacking contexts is not
100%:

Two ways you could make S be promoted to a composited layer without being a
stacking context:
1) CompositingReasonOverlap: Have S draw some content and have it overlap some
other layer below it.
2) CompositingReasonBackfaceVisibilityHidden: Give S the backface-visibility:
hidden style.

Two ways you could create a surface without being a stacking context:
1) Give S a parent that has preserves-3d, give S no transform-style, and give S
two layer children that both draw content.
2) Give S a parent with a transform that does not preserve axis alignment
(rotation/perspective) and give S some clip.

+      !frame->current_render_pass->has_transparent_background;
   DCHECK(!frame->current_texture);
 
   // TODO(danakj): Do a single readback for both the surface and replica and
   // cache the filtered results (once filter textures are not reused).
   gfx::Rect window_rect = gfx::ToEnclosingRect(MathUtil::MapClippedRect(
       contents_device_transform, SharedGeometryQuad().BoundingBox()));
 
   int top, right, bottom, left;
   filters.GetOutsets(&top, &right, &bottom, &left);
   window_rect.Inset(-left, -top, -right, -bottom);
 
   window_rect.Intersect(
       MoveFromDrawToWindowSpace(frame->current_render_pass->output_rect));
 
   scoped_ptr<ScopedResource> device_background_texture =
       ScopedResource::create(resource_provider_);
   if (!device_background_texture->Allocate(window_rect.size(),
                                            ResourceProvider::TextureUsageAny,
                                            RGBA_8888)) {
     return scoped_ptr<ScopedResource>();
   } else {
     ResourceProvider::ScopedWriteLockGL lock(resource_provider_,
                                              device_background_texture->id());
-    GetFramebufferTexture(lock.texture_id(),
-                          device_background_texture->format(),
-                          window_rect);
+    GetFramebufferTextureSubImage(lock.texture_id(),

[enne (OOO), 2013/09/26 16:25:13]

This new function seems unnecessary if you are always passing gfx::Point() to
it.

[rosca, 2013/09/27 10:39:06]

The reason I added this function besides GetFramebufferTexture was to be able to
copy RGBA content. The resource provider allocate rgba textures using
testStorage2DEXT, which has immutable internal format, and
GetFramebufferTexture(copyTexImage2D) tries to change the the internal format,
so it's going to fail. GetFramebufferTextureSubImage(copyTexSubImage2D) seams to
work as long as it just copies the pixels without touching the internal format.
Please correct me if I'm wrong. Actually, this was discussed in this thread:
https://groups.google.com/a/chromium.org/d/msg/chromium-dev/_Rc2Cv-ODq4/5CojB...
Though, I removed the offset parameter as it's not used yet.

+                                  gfx::Point(),
+                                  window_rect);
   }
 
-  SkBitmap filtered_device_background =
-      ApplyFilters(this,
-                   frame->offscreen_context_provider,
-                   filters,
-                   device_background_texture.get());
-  if (!filtered_device_background.getTexture())
-    return scoped_ptr<ScopedResource>();
+  int filtered_device_background_texture_id = 0;
 
-  GrTexture* texture =
-      reinterpret_cast<GrTexture*>(filtered_device_background.getTexture());
-  int filtered_device_background_texture_id = texture->getTextureHandle();
+  SkBitmap filtered_device_background;
+  if (apply_background_filters)
+      filtered_device_background = ApplyFilters(this,
+          frame->offscreen_context_provider, filters,
+          device_background_texture.get());
+  if (background_changed)
+    *background_changed = filtered_device_background.getTexture();
+
+  scoped_ptr<ResourceProvider::ScopedReadLockGL> lock;
+  if (filtered_device_background.getTexture()) {
+      GrTexture* texture =
+          reinterpret_cast<GrTexture*>(filtered_device_background.getTexture());
+      filtered_device_background_texture_id = texture->getTextureHandle();
+  } else {
+      lock.reset(new ResourceProvider::ScopedReadLockGL(resource_provider_,
+          device_background_texture->id()));
+      filtered_device_background_texture_id = lock->texture_id();
+  }
 
   scoped_ptr<ScopedResource> background_texture =
       ScopedResource::create(resource_provider_);
   if (!background_texture->Allocate(quad->rect.size(),
                                     ResourceProvider::TextureUsageFramebuffer,
                                     RGBA_8888))
     return scoped_ptr<ScopedResource>();
 
   const RenderPass* target_render_pass = frame->current_render_pass;
   bool using_background_texture =
@@ skipping 50 matching lines @@
   gfx::Transform contents_device_transform =
       frame->window_matrix * frame->projection_matrix * quad_rect_matrix;
   contents_device_transform.FlattenTo2d();
 
   // Can only draw surface if device matrix is invertible.
   gfx::Transform contents_device_transform_inverse(
       gfx::Transform::kSkipInitialization);
   if (!contents_device_transform.GetInverse(&contents_device_transform_inverse))
     return;
 
+  bool applyBlendMode =
+      quad->shared_quad_state->blend_mode != SkXfermode::kSrcOver_Mode;
+  bool backgroundChanged = false;
   scoped_ptr<ScopedResource> background_texture;
-  if (!quad->background_filters.IsEmpty()) {
+  if (!quad->background_filters.IsEmpty() || applyBlendMode) {
     // The pixels from the filtered background should completely replace the
     // current pixel values.
     bool disable_blending = blend_enabled();
     if (disable_blending)
       SetBlendEnabled(false);
 
-    background_texture = DrawBackgroundFilters(
+    background_texture = CreateBackgroundTextureWithFilters(

[enne (OOO), 2013/09/26 16:25:13]

This function seems incorrectly named at this point.

[rosca, 2013/09/27 10:39:06]

I changed it to GetBackgroundWithFilters, would this work?

[enne (OOO), 2013/09/27 17:42:33]

It's the "filters" part that seems like the misnomer to me.

[rosca, 2013/09/30 17:28:36]

Do you mean that I should make it something like
"GetBackgroundWithBackgroundFilters"? I think it's obvious that filters are
those, applied to the background. What would be your suggestion?

         frame,
         quad,
         contents_device_transform,
-        contents_device_transform_inverse);
+        contents_device_transform_inverse,
+        &backgroundChanged);
 
     if (disable_blending)
       SetBlendEnabled(true);
   }
 
   // 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.
   SkBitmap filter_bitmap;
   SkScalar color_matrix[20];
   bool use_color_matrix = false;
@@ skipping 27 matching lines @@
           color_matrix, optimized_filters.at(0).matrix(), sizeof(color_matrix));
       use_color_matrix = true;
     } else {
       filter_bitmap = ApplyFilters(this,
                                    frame->offscreen_context_provider,
                                    optimized_filters,
                                    contents_texture);
     }
   }
 
+  if (background_texture && applyBlendMode) {
+    filter_bitmap = ApplyBlendModeWithBackdrop(this,
+        frame->offscreen_context_provider,
+        filter_bitmap,
+        contents_texture,
+        background_texture.get(),
+        quad->shared_quad_state->blend_mode);
+  }
+
   // Draw the background texture if there is one.
-  if (background_texture) {
+  if (background_texture && backgroundChanged) {
     DCHECK(background_texture->size() == quad->rect.size());
     ResourceProvider::ScopedReadLockGL lock(resource_provider_,
                                             background_texture->id());
 
     // The background_texture is oriented the same as the frame buffer. The
     // transform we are copying with has a vertical flip, so flip the contents
     // in the shader to maintain orientation
     bool flip_vertically = true;
 
     CopyTextureToFramebuffer(frame,
@@ skipping 1629 matching lines @@
     scoped_ptr<SkAutoLockPixels> lock,
     scoped_ptr<CopyOutputRequest> request,
     bool success) {
   DCHECK(request->force_bitmap_result());
 
   lock.reset();
   if (success)
     request->SendBitmapResult(bitmap.Pass());
 }
 
+void GLRenderer::GetFramebufferTextureSubImage(unsigned texture_id,
+                                               gfx::Point offset,
+                                               gfx::Rect window_rect) {
+  DCHECK(texture_id);
+  DCHECK_GE(window_rect.x(), 0);
+  DCHECK_GE(window_rect.y(), 0);
+  DCHECK_LE(window_rect.right(), current_surface_size_.width());
+  DCHECK_LE(window_rect.bottom(), current_surface_size_.height());
+
+  GLC(context_, context_->bindTexture(GL_TEXTURE_2D, texture_id));
+  GLC(context_,
+      context_->copyTexSubImage2D(GL_TEXTURE_2D,
+      0,
+      offset.x(),
+      offset.y(),
+      window_rect.x(),
+      window_rect.y(),
+      window_rect.width(),
+      window_rect.height()));
+  GLC(context_, context_->bindTexture(GL_TEXTURE_2D, 0));
+}
+
 void GLRenderer::GetFramebufferTexture(
     unsigned texture_id, ResourceFormat texture_format, gfx::Rect window_rect) {
   DCHECK(texture_id);
   DCHECK_GE(window_rect.x(), 0);
   DCHECK_GE(window_rect.y(), 0);
   DCHECK_LE(window_rect.right(), current_surface_size_.width());
   DCHECK_LE(window_rect.bottom(), current_surface_size_.height());
 
   GLC(context_, context_->bindTexture(GL_TEXTURE_2D, texture_id));
   GLC(context_,
@@ skipping 659 matching lines @@
   // The Skia GPU backend requires a stencil buffer.  See ReinitializeGrCanvas
   // implementation.
   return gr_context_ && context_->getContextAttributes().stencil;
 }
 
 bool GLRenderer::IsContextLost() {
   return (context_->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc