cc: Adding ETC1 support to UIResourceBitmap and ResourceProvider

cc/resources/resource_provider.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/resources/resource_provider.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/containers/hash_tables.h"
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "cc/base/util.h"
 #include "cc/output/gl_renderer.h"  // For the GLC() macro.
 #include "cc/resources/platform_color.h"
+#include "cc/resources/resource.h"

[kaanb, 2013/10/18 16:54:49]

you shouldn't need this include, isn't it already included in
resource_provider.h?

[powei, 2013/10/23 05:36:15]

Done.

 #include "cc/resources/returned_resource.h"
 #include "cc/resources/transferable_resource.h"
 #include "cc/scheduler/texture_uploader.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/vector2d.h"
 
 using WebKit::WebGraphicsContext3D;
 
 namespace cc {
 
 namespace {
 
 // Measured in seconds.
 const double kSoftwareUploadTickRate = 0.000250;
 const double kTextureUploadTickRate = 0.004;
 
 GLenum TextureToStorageFormat(ResourceFormat format) {
   GLenum storage_format = GL_RGBA8_OES;
   switch (format) {
     case RGBA_8888:
       break;
     case BGRA_8888:
       storage_format = GL_BGRA8_EXT;
       break;
+    case ETC1:
     case RGBA_4444:
     case LUMINANCE_8:
     case RGB_565:
       NOTREACHED();
       break;
   }
 
   return storage_format;
 }
 
 bool IsFormatSupportedForStorage(ResourceFormat format) {
   switch (format) {
     case RGBA_8888:
     case BGRA_8888:
       return true;
+    case ETC1:
     case RGBA_4444:
     case LUMINANCE_8:
     case RGB_565:
       return false;
   }
   return false;
 }
 
 class ScopedSetActiveTexture {
  public:
@@ skipping 1313 matching lines @@
     context3d->bindTexture(GL_TEXTURE_2D, resource->gl_id);
     context3d->bindBuffer(
         GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
         resource->gl_pixel_buffer_id);
     if (!resource->gl_upload_query_id)
       resource->gl_upload_query_id = context3d->createQueryEXT();
     context3d->beginQueryEXT(
         GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM,
         resource->gl_upload_query_id);
     if (allocate) {
-      context3d->asyncTexImage2DCHROMIUM(
-          GL_TEXTURE_2D,
-          0, /* level */
-          GLInternalFormat(resource->format),
-          resource->size.width(),
-          resource->size.height(),
-          0, /* border */
-          GLDataFormat(resource->format),
-          GLDataType(resource->format),
-          NULL);
+      if (resource->format == ETC1) {
+        context3d->compressedTexImage2D(
+            GL_TEXTURE_2D,
+            0, /* level */
+            GLInternalFormat(resource->format),
+            resource->size.width(),
+            resource->size.height(),
+            0, /* border */
+            cc::Resource::ETC1SizeInBytes(resource->size),
+            NULL);
+      } else {
+        context3d->asyncTexImage2DCHROMIUM(
+            GL_TEXTURE_2D,
+            0, /* level */
+            GLInternalFormat(resource->format),
+            resource->size.width(),
+            resource->size.height(),
+            0, /* border */
+            GLDataFormat(resource->format),
+            GLDataType(resource->format),
+            NULL);
+      }
     } else {
-      context3d->asyncTexSubImage2DCHROMIUM(
-          GL_TEXTURE_2D,
-          0, /* level */
-          0, /* x */
-          0, /* y */
-          resource->size.width(),
-          resource->size.height(),
-          GLDataFormat(resource->format),
-          GLDataType(resource->format),
-          NULL);
+      if (resource->format == ETC1) {
+        context3d->compressedTexSubImage2D(
+            GL_TEXTURE_2D,
+            0, /* level */
+            0, /* x */
+            0, /* y */
+            resource->size.width(),
+            resource->size.height(),
+            GLDataFormat(resource->format),
+            cc::Resource::ETC1SizeInBytes(resource->size),
+            NULL);
+      } else {
+        context3d->asyncTexSubImage2DCHROMIUM(
+            GL_TEXTURE_2D,
+            0, /* level */
+            0, /* x */
+            0, /* y */
+            resource->size.width(),
+            resource->size.height(),
+            GLDataFormat(resource->format),
+            GLDataType(resource->format),
+            NULL);
+      }
     }
     context3d->endQueryEXT(GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM);
     context3d->bindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
   }
 
   if (resource->pixels) {
     DCHECK(!resource->mailbox.IsValid());
     DCHECK(resource->pixel_buffer);
     DCHECK_EQ(RGBA_8888, resource->format);
 
@@ skipping 109 matching lines @@
   if (resource->allocated || !resource->gl_id)
     return;
   resource->allocated = true;
   WebGraphicsContext3D* context3d = Context3d();
   gfx::Size& size = resource->size;
   DCHECK_EQ(resource->target, static_cast<GLenum>(GL_TEXTURE_2D));
   ResourceFormat format = resource->format;
   GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, resource->gl_id));
   if (use_texture_storage_ext_ && IsFormatSupportedForStorage(format)) {
     GLenum storage_format = TextureToStorageFormat(format);
-    GLC(context3d, context3d->texStorage2DEXT(GL_TEXTURE_2D,
-                                              1,
-                                              storage_format,
-                                              size.width(),
-                                              size.height()));
+    GLC(context3d,
+        context3d->texStorage2DEXT(

[kaanb, 2013/10/18 16:54:49]

please revert this block, it just changes formatting

[powei, 2013/10/23 05:36:15]

Done.

+            GL_TEXTURE_2D, 1, storage_format, size.width(), size.height()));
   } else {
-    GLC(context3d, context3d->texImage2D(GL_TEXTURE_2D,
-                                         0,
-                                         GLInternalFormat(format),
-                                         size.width(),
-                                         size.height(),
-                                         0,
-                                         GLDataFormat(format),
-                                         GLDataType(format),
-                                         NULL));
+    if (format == ETC1) {
+      GLC(context3d,
+          context3d->compressedTexImage2D(
+              GL_TEXTURE_2D,
+              0,
+              GLInternalFormat(format),
+              size.width(),
+              size.height(),
+              0,
+              cc::Resource::ETC1SizeInBytes(resource->size),
+              NULL));
+    } else {
+      GLC(context3d,
+          context3d->texImage2D(GL_TEXTURE_2D,
+                                0,
+                                GLInternalFormat(format),
+                                size.width(),
+                                size.height(),
+                                0,
+                                GLDataFormat(format),
+                                GLDataType(format),
+                                NULL));
+    }
   }
 }
 
 void ResourceProvider::EnableReadLockFences(ResourceProvider::ResourceId id,
                                             bool enable) {
   Resource* resource = GetResource(id);
   resource->enable_read_lock_fences = enable;
 }
 
 void ResourceProvider::AcquireImage(ResourceId id) {
@@ skipping 84 matching lines @@
   context->getIntegerv(GL_ACTIVE_TEXTURE, &active_unit);
   return active_unit;
 }
 
 WebKit::WebGraphicsContext3D* ResourceProvider::Context3d() const {
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->Context3d() : NULL;
 }
 
 }  // namespace cc