cc: Adding ETC1 support to UIResourceBitmap and ResourceProvider

cc/scheduler/texture_uploader.cc

 // 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/scheduler/texture_uploader.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/debug/trace_event.h"
@@ skipping 125 matching lines @@
                              gfx::Vector2d dest_offset,
                              ResourceFormat format,
                              gfx::Size size) {
   CHECK(image_rect.Contains(source_rect));
 
   bool is_full_upload = dest_offset.IsZero() && source_rect.size() == size;
 
   if (is_full_upload)
     BeginQuery();
 
+  if (format == ETC1) {
+    // ETC1 does not support subimage uploads.
+    DCHECK(is_full_upload);
+    UploadWithTexImageETC1(image, size);
+    return;
+  }
+
   if (use_map_tex_sub_image_) {
     UploadWithMapTexSubImage(
         image, image_rect, source_rect, dest_offset, format);
   } else {
     UploadWithTexSubImage(image, image_rect, source_rect, dest_offset, format);
   }
 
   if (is_full_upload)
     EndQuery();
 
@@ skipping 27 matching lines @@
   // Early-out if this is a no-op, and assert that |image| be valid if this is
   // not a no-op.
   if (source_rect.IsEmpty())
     return;
   DCHECK(image);
 
   // Offset from image-rect to source-rect.
   gfx::Vector2d offset(source_rect.origin() - image_rect.origin());
 
   const uint8* pixel_source;
-  unsigned bytes_per_pixel = BytesPerPixel(format);
+  unsigned bytes_per_pixel = BitsPerPixel(format) / 8;
   // Use 4-byte row alignment (OpenGL default) for upload performance.
   // Assuming that GL_UNPACK_ALIGNMENT has not changed from default.
   unsigned upload_image_stride =
       RoundUp(bytes_per_pixel * source_rect.width(), 4u);
 
   if (upload_image_stride == image_rect.width() * bytes_per_pixel &&
       !offset.x()) {
     pixel_source = &image[image_rect.width() * bytes_per_pixel * offset.y()];
   } else {
     size_t needed_size = upload_image_stride * source_rect.height();
@@ skipping 28 matching lines @@
                                                gfx::Rect source_rect,
                                                gfx::Vector2d dest_offset,
                                                ResourceFormat format) {
   TRACE_EVENT0("cc", "TextureUploader::UploadWithMapTexSubImage");
 
   // Early-out if this is a no-op, and assert that |image| be valid if this is
   // not a no-op.
   if (source_rect.IsEmpty())
     return;
   DCHECK(image);
+  // Compressed textures have no implementation of mapTexSubImage.
+  DCHECK_NE(ETC1, format);
 
   // Offset from image-rect to source-rect.
   gfx::Vector2d offset(source_rect.origin() - image_rect.origin());
 
-  unsigned bytes_per_pixel = BytesPerPixel(format);
+  unsigned bytes_per_pixel = BitsPerPixel(format) / 8;
   // Use 4-byte row alignment (OpenGL default) for upload performance.
   // Assuming that GL_UNPACK_ALIGNMENT has not changed from default.
   unsigned upload_image_stride =
       RoundUp(bytes_per_pixel * source_rect.width(), 4u);
 
   // Upload tile data via a mapped transfer buffer
   uint8* pixel_dest = static_cast<uint8*>(
       context_->mapTexSubImage2DCHROMIUM(GL_TEXTURE_2D,
                                          0,
                                          dest_offset.x(),
@@ skipping 21 matching lines @@
       memcpy(&pixel_dest[upload_image_stride * row],
              &image[bytes_per_pixel *
                  (offset.x() + (offset.y() + row) * image_rect.width())],
              source_rect.width() * bytes_per_pixel);
     }
   }
 
   context_->unmapTexSubImage2DCHROMIUM(pixel_dest);
 }
 
+void TextureUploader::UploadWithTexImageETC1(const uint8* image,
+                                             gfx::Size size) {
+  TRACE_EVENT0("cc", "TextureUploader::UploadWithTexImageETC1");
+  DCHECK_EQ(0, size.width() % 4);
+  DCHECK_EQ(0, size.height() % 4);
+
+  context_->compressedTexImage2D(GL_TEXTURE_2D,
+                                 0,
+                                 GLInternalFormat(ETC1),
+                                 size.width(),
+                                 size.height(),
+                                 0,
+                                 Resource::MemorySizeBytes(size, ETC1),
+                                 image);
+}
+
 void TextureUploader::ProcessQueries() {
   while (!pending_queries_.empty()) {
     if (pending_queries_.front()->IsPending())
       break;
 
     unsigned us_elapsed = pending_queries_.front()->Value();
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "Renderer4.TextureGpuUploadTimeUS", us_elapsed, 0, 100000, 50);
 
     // Clamp the queries to saner values in case the queries fail.
     us_elapsed = std::max(1u, us_elapsed);
     us_elapsed = std::min(15000u, us_elapsed);
 
     if (!pending_queries_.front()->is_non_blocking())
       num_blocking_texture_uploads_--;
 
     // Remove the min and max value from our history and insert the new one.
     double textures_per_second = 1.0 / (us_elapsed * 1e-6);
     if (textures_per_second_history_.size() >= kUploadHistorySizeMax) {
       textures_per_second_history_.erase(textures_per_second_history_.begin());
       textures_per_second_history_.erase(--textures_per_second_history_.end());
     }
     textures_per_second_history_.insert(textures_per_second);
 
     available_queries_.push_back(pending_queries_.take_front());
   }
 }
 
 }  // namespace cc