Implement on demand quad rasterization for PicturePiles.

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 <set>
 #include <string>
 #include <vector>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/strings/string_split.h"
 #include "build/build_config.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/video_layer_impl.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/geometry_binding.h"
 #include "cc/output/gl_frame_data.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/render_surface_filters.h"
+#include "cc/quads/picture_draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/stream_video_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/layer_quad.h"
 #include "cc/resources/priority_calculator.h"
 #include "cc/resources/scoped_resource.h"
 #include "cc/trees/damage_tracker.h"
 #include "cc/trees/proxy.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "gpu/GLES2/gl2extchromium.h"
@@ skipping 60 matching lines @@
     : DirectRenderer(client, resource_provider),
       offscreen_framebuffer_id_(0),
       shared_geometry_quad_(gfx::RectF(-0.5f, -0.5f, 1.0f, 1.0f)),
       output_surface_(output_surface),
       context_(output_surface->context3d()),
       is_viewport_changed_(false),
       is_backbuffer_discarded_(false),
       discard_backbuffer_when_not_visible_(false),
       is_using_bind_uniform_(false),
       visible_(true),
-      is_scissor_enabled_(false) {
+      is_scissor_enabled_(false),
+      on_demand_tile_raster_texture_(0),
+      on_demand_tile_raster_resource_id_(0) {
   DCHECK(context_);
 }
 
 bool GLRenderer::Initialize() {
   if (!context_->makeContextCurrent())
     return false;
 
   context_->setContextLostCallback(this);
   context_->pushGroupMarkerEXT("CompositorContext");
 
@@ skipping 178 matching lines @@
       break;
     case DrawQuad::CHECKERBOARD:
       DrawCheckerboardQuad(frame, CheckerboardDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::DEBUG_BORDER:
       DrawDebugBorderQuad(frame, DebugBorderDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::IO_SURFACE_CONTENT:
       DrawIOSurfaceQuad(frame, IOSurfaceDrawQuad::MaterialCast(quad));
       break;
+    case DrawQuad::PICTURE_CONTENT:
+      DrawPictureQuad(frame, PictureDrawQuad::MaterialCast(quad));
+      break;
     case DrawQuad::RENDER_PASS:
       DrawRenderPassQuad(frame, RenderPassDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::SOLID_COLOR:
       DrawSolidColorQuad(frame, SolidColorDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::STREAM_VIDEO_CONTENT:
       DrawStreamVideoQuad(frame, StreamVideoDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::TEXTURE_CONTENT:
       EnqueueTextureQuad(frame, TextureDrawQuad::MaterialCast(quad));
       break;
-    case DrawQuad::TILED_CONTENT:
-      DrawTileQuad(frame, TileDrawQuad::MaterialCast(quad));
+    case DrawQuad::TILED_CONTENT: {
+      const TileDrawQuad* tile_draw_quad = TileDrawQuad::MaterialCast(quad);
+      DrawTileQuad(frame, tile_draw_quad, tile_draw_quad->resource_id);
       break;
+    }
     case DrawQuad::YUV_VIDEO_CONTENT:
       DrawYUVVideoQuad(frame, YUVVideoDrawQuad::MaterialCast(quad));
       break;
   }
 }
 
 void GLRenderer::DrawCheckerboardQuad(const DrawingFrame& frame,
                                       const CheckerboardDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
@@ skipping 697 matching lines @@
   uniforms->matrix_location = program->vertex_shader().matrixLocation();
   uniforms->point_location = program->vertex_shader().pointLocation();
 
   uniforms->sampler_location = program->fragment_shader().samplerLocation();
   uniforms->alpha_location = program->fragment_shader().alphaLocation();
   uniforms->fragment_tex_transform_location =
       program->fragment_shader().fragmentTexTransformLocation();
   uniforms->edge_location = program->fragment_shader().edgeLocation();
 }
 
 void GLRenderer::DrawTileQuad(const DrawingFrame& frame,

[danakj, 2013/03/21 02:34:42]

nit: Can you call this function DrawTileOrPictureQuad(), and add a new
DrawTileQuad() that calls it, instead of adding logic to the DrawQuad() switch?

[Leandro Graciá Gil, 2013/03/21 16:42:48]

Done.

-                              const TileDrawQuad* quad) {
+                              const TileDrawQuadBase* quad,
+                              unsigned resource_id) {
   gfx::Rect tile_rect = quad->visible_rect;
 
   gfx::RectF tex_coord_rect = quad->tex_coord_rect;
   float tex_to_geom_scale_x = quad->rect.width() / tex_coord_rect.width();
   float tex_to_geom_scale_y = quad->rect.height() / tex_coord_rect.height();
 
   // tex_coord_rect corresponds to quad_rect, but quad_visible_rect may be
   // smaller than quad_rect due to occlusion or clipping. Adjust
   // tex_coord_rect to match.
   gfx::Vector2d top_left_diff = tile_rect.origin() - quad->rect.origin();
@@ skipping 68 matching lines @@
   }
 
   SetUseProgram(uniforms.program);
   GLC(Context(), Context()->uniform1i(uniforms.sampler_location, 0));
   bool scaled = (tex_to_geom_scale_x != 1.f || tex_to_geom_scale_y != 1.f);
   GLenum filter = (use_aa || scaled ||
                    !quad->quadTransform().IsIdentityOrIntegerTranslation())
                   ? GL_LINEAR
                   : GL_NEAREST;
   ResourceProvider::ScopedSamplerGL quad_resource_lock(
-      resource_provider_, quad->resource_id, GL_TEXTURE_2D, filter);
+      resource_provider_, resource_id, GL_TEXTURE_2D, filter);
 
   if (use_aa) {
     GLC(Context(), Context()->uniform3fv(uniforms.edge_location, 8, edge));
 
     GLC(Context(),
         Context()->uniform4f(uniforms.vertex_tex_transform_location,
                              vertex_tex_translate_x,
                              vertex_tex_translate_y,
                              vertex_tex_scale_x,
                              vertex_tex_scale_y));
@@ skipping 133 matching lines @@
   GLC(Context(),
       Context()->uniform1i(program->fragment_shader().samplerLocation(), 0));
 
   SetShaderOpacity(quad->opacity(), program->fragment_shader().alphaLocation());
   DrawQuadGeometry(frame,
                    quad->quadTransform(),
                    quad->rect,
                    program->vertex_shader().matrixLocation());
 }
 
+void GLRenderer::DrawPictureQuad(const DrawingFrame& frame, const PictureDrawQuad* quad) {
+  if (on_demand_tile_raster_bitmap_.width() != quad->texture_size.width() ||
+      on_demand_tile_raster_bitmap_.height() != quad->texture_size.height()) {
+    on_demand_tile_raster_bitmap_.setConfig(
+        SkBitmap::kARGB_8888_Config,
+        quad->texture_size.width(),
+        quad->texture_size.height());
+    on_demand_tile_raster_bitmap_.allocPixels();
+  }
+
+  SkDevice device(on_demand_tile_raster_bitmap_);
+  SkCanvas canvas(&device);
+
+  int64 total_pixels_rasterized = 0;
+  quad->picture_pile->Raster(
+      &canvas,
+      quad->content_rect,
+      quad->contents_scale,
+      &total_pixels_rasterized);
+
+  GLC(Context(), Context()->bindTexture(
+      GL_TEXTURE_2D,
+      on_demand_tile_raster_texture_));
+
+  GLC(Context(), Context()->texImage2D(
+      GL_TEXTURE_2D,
+      0,
+      GL_RGBA,
+      quad->texture_size.width(),
+      quad->texture_size.height(),
+      0,
+      GL_RGBA,
+      GL_UNSIGNED_BYTE,
+      on_demand_tile_raster_bitmap_.getPixels()));
+
+  DrawTileQuad(frame, quad, on_demand_tile_raster_resource_id_);
+}
+
 struct TextureProgramBinding {
   template <class Program>
   void Set(Program* program, WebKit::WebGraphicsContext3D* context) {
     DCHECK(program && (program->initialized() || context->isContextLost()));
     program_id = program->program();
     sampler_location = program->fragment_shader().samplerLocation();
     matrix_location = program->vertex_shader().matrixLocation();
     alpha_location = program->fragment_shader().alphaLocation();
   }
   int program_id;
@@ skipping 663 matching lines @@
 
   // We will always need these programs to render, so create the programs
   // eagerly so that the shader compilation can start while we do other work.
   // Other programs are created lazily on first access.
   shared_geometry_ =
       make_scoped_ptr(new GeometryBinding(context_, QuadVertexRect()));
   render_pass_program_ = make_scoped_ptr(new RenderPassProgram(context_));
   tile_program_ = make_scoped_ptr(new TileProgram(context_));
   tile_program_opaque_ = make_scoped_ptr(new TileProgramOpaque(context_));
 
+  on_demand_tile_raster_texture_ = Context()->createTexture();

[danakj, 2013/03/21 02:34:42]

Can you do this in DrawPictureQuad() the first time it is called instead?

[Leandro Graciá Gil, 2013/03/21 16:42:48]

Done.

+  on_demand_tile_raster_resource_id_ =
+      resource_provider_->CreateResourceFromExternalTexture(
+          on_demand_tile_raster_texture_);
+
   GLC(context_, context_->flush());
 
   return true;
 }
 
 const GLRenderer::TileCheckerboardProgram*
 GLRenderer::GetTileCheckerboardProgram() {
   if (!tile_checkerboard_program_) {
     tile_checkerboard_program_ =
         make_scoped_ptr(new TileCheckerboardProgram(context_));
@@ skipping 242 matching lines @@
   if (debug_border_program_)
     debug_border_program_->Cleanup(context_);
   if (solid_color_program_)
     solid_color_program_->Cleanup(context_);
   if (solid_color_program_aa_)
     solid_color_program_aa_->Cleanup(context_);
 
   if (offscreen_framebuffer_id_)
     GLC(context_, context_->deleteFramebuffer(offscreen_framebuffer_id_));
 
+  if (on_demand_tile_raster_texture_)
+    GLC(context_, context_->deleteTexture(on_demand_tile_raster_texture_));

[danakj, 2013/03/21 02:34:42]

You need to clean up with the ResourceProvider too

[Leandro Graciá Gil, 2013/03/21 03:35:50]

Can I use ResourceProvider to clean external textures? Should this be an
external texture?

[danakj, 2013/03/21 04:33:39]

ya, there's actually no need for this to be an external texture. You could just
use CreateGLTexture() and then DeleteResource() here. And you'll need to lock
the resource appropriately to get at the texture id when you want to use it. See
other uses of ResourceProvider::ScopedWriteLockGL in this file.

[Leandro Graciá Gil, 2013/03/21 16:42:48]

Looking at ResourceProvider it seems that doing it that way associates a size to
the texture. We would need to destroy the resource and create a new one if the
size changes, and apparently the current texture size isn't exposed either.

Also, I don't think for this case we want the resource provider to manage
allocation or to put it in a texture pool. Perhaps an external texture is more
convenient after all. I'm adding the code to delete the resource in the
provider.

[danakj, 2013/03/21 17:20:22]

I talked to piman@ and he suggested to just not register with the resource
provider at all. So what you've got minus registering it as an external texture.

Basically resource provider is for managing resources that can be sent between
compositors, but this one being internal to the GLRenderer does not need to
worry about that.

[Leandro Graciá Gil, 2013/03/21 18:14:16]

Registering as an external texture makes things simpler when using it in the
common rendering method for normal and on-demand tiles. We could manually bind
the texture, but the method also sets texture filtering dynamically.

Normally the provider ensures filtering is only changed if different. However,
if we use glBindTexture directly rather than the
ResourceProvider::ScopedSamplerGL resource lock we'll be setting the filters on
every frame even if not really required. That, or we save them separately and
start duplicating provider functionalities and making the code more different
for each case.

I think that's worth registering the external texture. Let me know if you think
otherwise.

[piman, 2013/03/21 18:26:30]

I want to get rid of the non-mailbox external texture feature because it's
essentially a big thorn in the resource provider, that was meant as a crutch.
We're getting rid of users currently, so I'd strongly prefer if we didn't add
any.
Please either create a resource through the RP, or skip the RP altogether.

If you want to do the latter but share the filter-tracking feature, feel free to
factor it out.

+
   ReleaseRenderPassTextures();
 }
 
 bool GLRenderer::IsContextLost() {
   return (context_->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc