cc: Adding support for RGBA_4444 tile textures

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 644 matching lines @@
   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(),
-                                           GL_RGB,
-                                           ResourceProvider::TextureUsageAny)) {
+                                           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);
   }
 
   SkBitmap filtered_device_background =
       ApplyFilters(this,
                    frame->offscreen_context_provider,
                    filters,
                    device_background_texture.get());
   if (!filtered_device_background.getTexture())
     return scoped_ptr<ScopedResource>();
 
   GrTexture* texture =
       reinterpret_cast<GrTexture*>(filtered_device_background.getTexture());
   int filtered_device_background_texture_id = texture->getTextureHandle();
 
   scoped_ptr<ScopedResource> background_texture =
       ScopedResource::create(resource_provider_);
   if (!background_texture->Allocate(quad->rect.size(),
-                                    GL_RGBA,
-                                    ResourceProvider::TextureUsageFramebuffer))
+                                    ResourceProvider::TextureUsageFramebuffer,
+                                    RGBA_8888))
     return scoped_ptr<ScopedResource>();
 
   const RenderPass* target_render_pass = frame->current_render_pass;
   bool using_background_texture =
       UseScopedTexture(frame, background_texture.get(), quad->rect);
 
   if (using_background_texture) {
     // Copy the readback pixels from device to the background texture for the
     // surface.
     gfx::Transform device_to_framebuffer_transform;
@@ skipping 1001 matching lines @@
         SkBitmap::kARGB_8888_Config,
         quad->texture_size.width(),
         quad->texture_size.height());
     on_demand_tile_raster_bitmap_.allocPixels();
 
     if (on_demand_tile_raster_resource_id_)
       resource_provider_->DeleteResource(on_demand_tile_raster_resource_id_);
 
     on_demand_tile_raster_resource_id_ = resource_provider_->CreateGLTexture(
         quad->texture_size,
-        GL_RGBA,
         GL_TEXTURE_POOL_UNMANAGED_CHROMIUM,
         GL_CLAMP_TO_EDGE,
-        ResourceProvider::TextureUsageAny);
+        ResourceProvider::TextureUsageAny,
+        settings_->use_rgba_4444_textures ? RGBA_4444 : RGBA_8888);

[reveman, 2013/09/14 00:58:39]

I think this should be using resource_provider->best_tile_texture_format()
instead?

[kaanb, 2013/09/16 07:22:25]

Yes, since previously GL_RGBA was hardcoded, raster-on-demand pixel tests were
expecting the output in GL_RGBA format. When I changed this to use
best_tile_texture_format() those tests started failing since
best_tile_texture_format() was BGRA, so I added a field to LayerTreeSettings to
enforce using RGBA textures to fix the tests.

   }
 
   SkBitmapDevice device(on_demand_tile_raster_bitmap_);
   SkCanvas canvas(&device);
 
   quad->picture_pile->RasterToBitmap(&canvas, quad->content_rect,
                                      quad->contents_scale, NULL);
 
+  const uint8_t* bitmap_pixels = NULL;
+  if (settings_->use_rgba_4444_textures) {

[reveman, 2013/09/14 00:58:39]

I think this code should be similar to PBRWP code and not use
use_rgba_4444_textures directly. You might want to move the helper function you
added to PBRWP to resource_format.h.

[kaanb, 2013/09/16 07:22:25]

Done.

+    on_demand_tile_raster_bitmap_.copyTo(
+        &on_demand_tile_raster_bitmap_4444_, SkBitmap::kARGB_4444_Config);
+    bitmap_pixels = reinterpret_cast<uint8_t*>(
+        on_demand_tile_raster_bitmap_4444_.getPixels());

[reveman, 2013/09/14 00:58:39]

does caching on_demand_tile_raster_bitmap_4444_ really make a difference? I'd
prefer if this was just a temporary variable like in the case of PBRWP for now.

[kaanb, 2013/09/16 07:22:25]

Done.

+  } else {
+    bitmap_pixels = reinterpret_cast<uint8_t*>(
+        on_demand_tile_raster_bitmap_.getPixels());
+  }
+
   resource_provider_->SetPixels(
       on_demand_tile_raster_resource_id_,
-      reinterpret_cast<uint8_t*>(on_demand_tile_raster_bitmap_.getPixels()),
+      bitmap_pixels,
       gfx::Rect(quad->texture_size),
       gfx::Rect(quad->texture_size),
       gfx::Vector2d());
 
   DrawContentQuad(frame, quad, on_demand_tile_raster_resource_id_);
 }
 
 struct TextureProgramBinding {
   template <class Program>
   void Set(Program* program, WebKit::WebGraphicsContext3D* context) {
@@ skipping 468 matching lines @@
     unsigned int texture_id = context_->createTexture();
     GLC(context_, context_->bindTexture(GL_TEXTURE_2D, texture_id));
     GLC(context_, context_->texParameteri(
         GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
     GLC(context_, context_->texParameteri(
         GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
     GLC(context_, context_->texParameteri(
         GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
     GLC(context_, context_->texParameteri(
         GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
-    GetFramebufferTexture(texture_id, GL_RGBA, window_rect);
+    GetFramebufferTexture(texture_id, RGBA_8888, window_rect);
 
     gpu::Mailbox mailbox;
     unsigned sync_point = 0;
     GLC(context_, context_->genMailboxCHROMIUM(mailbox.name));
     if (mailbox.IsZero()) {
       context_->deleteTexture(texture_id);
       request->SendEmptyResult();
       return;
     }
 
@@ skipping 71 matching lines @@
         GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
     GLC(context_, context_->texParameteri(
         GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
     GLC(context_, context_->texParameteri(
         GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
     GLC(context_, context_->texParameteri(
         GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
     // Copy the contents of the current (IOSurface-backed) framebuffer into a
     // temporary texture.
     GetFramebufferTexture(temporary_texture,
-                          GL_RGBA,
+                          RGBA_8888,
                           gfx::Rect(current_surface_size_));
     temporary_fbo = context_->createFramebuffer();
     // Attach this texture to an FBO, and perform the readback from that FBO.
     GLC(context_, context_->bindFramebuffer(GL_FRAMEBUFFER, temporary_fbo));
     GLC(context_, context_->framebufferTexture2D(GL_FRAMEBUFFER,
                                                  GL_COLOR_ATTACHMENT0,
                                                  GL_TEXTURE_2D,
                                                  temporary_texture,
                                                  0));
 
@@ skipping 129 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::GetFramebufferTexture(unsigned texture_id,
-                                       unsigned texture_format,
-                                       gfx::Rect window_rect) {
+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_,
-      context_->copyTexImage2D(GL_TEXTURE_2D,
-                               0,
-                               texture_format,
-                               window_rect.x(),
-                               window_rect.y(),
-                               window_rect.width(),
-                               window_rect.height(),
-                               0));
+      context_->copyTexImage2D(
+          GL_TEXTURE_2D,
+          0,
+          ResourceProvider::GetGLDataFormat(texture_format),
+          window_rect.x(),
+          window_rect.y(),
+          window_rect.width(),
+          window_rect.height(),
+          0));
   GLC(context_, context_->bindTexture(GL_TEXTURE_2D, 0));
 }
 
 bool GLRenderer::UseScopedTexture(DrawingFrame* frame,
                                   const ScopedResource* texture,
                                   gfx::Rect viewport_rect) {
   DCHECK(texture->id());
   frame->current_render_pass = NULL;
   frame->current_texture = texture;
 
@@ skipping 652 matching lines @@
     return;
   offscreen_context_labelled_ = true;
   std::string unique_context_name = base::StringPrintf(
       "%s-Offscreen-%p", settings_->compositor_name.c_str(), context_);
   offscreen_context_provider->Context3d()
       ->pushGroupMarkerEXT(unique_context_name.c_str());
 }
 
 
 }  // namespace cc