Add support for compressed GPU memory buffers.

ui/gl/gl_image_memory.cc

 // Copyright 2014 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 "ui/gl/gl_image_memory.h"
 
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/scoped_binders.h"
@@ skipping 10 matching lines @@
   switch (internalformat) {
     case GL_RGBA:
       return true;
     default:
       return false;
   }
 }
 
 bool ValidFormat(gfx::GpuMemoryBuffer::Format format) {
   switch (format) {
+    case gfx::GpuMemoryBuffer::ATC:
+    case gfx::GpuMemoryBuffer::ATCIA:
+    case gfx::GpuMemoryBuffer::DXT1:
+    case gfx::GpuMemoryBuffer::DXT5:
+    case gfx::GpuMemoryBuffer::ETC1:
     case gfx::GpuMemoryBuffer::RGBA_8888:
     case gfx::GpuMemoryBuffer::BGRA_8888:
       return true;
     case gfx::GpuMemoryBuffer::RGBX_8888:
       return false;
   }
 
   NOTREACHED();
   return false;
 }
 
+bool CompressedFormat(gfx::GpuMemoryBuffer::Format format) {
+  switch (format) {
+    case gfx::GpuMemoryBuffer::ATC:
+    case gfx::GpuMemoryBuffer::ATCIA:
+    case gfx::GpuMemoryBuffer::DXT1:
+    case gfx::GpuMemoryBuffer::DXT5:
+    case gfx::GpuMemoryBuffer::ETC1:
+      return true;
+    case gfx::GpuMemoryBuffer::RGBA_8888:
+    case gfx::GpuMemoryBuffer::BGRA_8888:
+    case gfx::GpuMemoryBuffer::RGBX_8888:
+      return false;
+  }
+
+  NOTREACHED();
+  return false;
+}
+
 GLenum TextureFormat(gfx::GpuMemoryBuffer::Format format) {
   switch (format) {
+    case gfx::GpuMemoryBuffer::ATC:
+      return GL_ATC_RGB_AMD;
+    case gfx::GpuMemoryBuffer::ATCIA:
+      return GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD;
+    case gfx::GpuMemoryBuffer::DXT1:
+      return GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
+    case gfx::GpuMemoryBuffer::DXT5:
+      return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+    case gfx::GpuMemoryBuffer::ETC1:
+      return GL_ETC1_RGB8_OES;
     case gfx::GpuMemoryBuffer::RGBA_8888:
       return GL_RGBA;
     case gfx::GpuMemoryBuffer::BGRA_8888:
       return GL_BGRA_EXT;
     case gfx::GpuMemoryBuffer::RGBX_8888:
       NOTREACHED();
       return 0;
   }
 
   NOTREACHED();
   return 0;
 }
 
 GLenum DataFormat(gfx::GpuMemoryBuffer::Format format) {
   return TextureFormat(format);
 }
 
 GLenum DataType(gfx::GpuMemoryBuffer::Format format) {
   switch (format) {
     case gfx::GpuMemoryBuffer::RGBA_8888:
     case gfx::GpuMemoryBuffer::BGRA_8888:
       return GL_UNSIGNED_BYTE;
+    case gfx::GpuMemoryBuffer::ATC:
+    case gfx::GpuMemoryBuffer::ATCIA:
+    case gfx::GpuMemoryBuffer::DXT1:
+    case gfx::GpuMemoryBuffer::DXT5:
+    case gfx::GpuMemoryBuffer::ETC1:
     case gfx::GpuMemoryBuffer::RGBX_8888:
       NOTREACHED();
       return 0;
   }
 
   NOTREACHED();
   return 0;
 }
 
+size_t SizeInBytes(const gfx::Size& size,
+                   gfx::GpuMemoryBuffer::Format format) {
+  size_t stride_in_bytes = 0;
+  bool valid_stride = GLImageMemory::StrideInBytes(
+      size.width(), format, &stride_in_bytes);
+  DCHECK(valid_stride);
+  return stride_in_bytes * size.height();
+}
+
 }  // namespace
 
 GLImageMemory::GLImageMemory(const gfx::Size& size, unsigned internalformat)
     : size_(size),
       internalformat_(internalformat),
       memory_(NULL),
       format_(gfx::GpuMemoryBuffer::RGBA_8888),
       in_use_(false),
       target_(0),
       need_do_bind_tex_image_(false)
@@ skipping 13 matching lines @@
   DCHECK_EQ(0u, egl_texture_id_);
 #endif
 }
 
 // static
 bool GLImageMemory::StrideInBytes(size_t width,
                                   gfx::GpuMemoryBuffer::Format format,
                                   size_t* stride_in_bytes) {
   base::CheckedNumeric<size_t> s = width;
   switch (format) {
+    case gfx::GpuMemoryBuffer::ATCIA:
+    case gfx::GpuMemoryBuffer::DXT5:
+      *stride_in_bytes = width;
+      return true;
+    case gfx::GpuMemoryBuffer::ATC:
+    case gfx::GpuMemoryBuffer::DXT1:
+    case gfx::GpuMemoryBuffer::ETC1:
+      DCHECK_EQ(width % 2, 0U);

[piman, 2015/02/14 00:50:21]

Hmm, this needs to be validated somewhere, we can't rely on the client side to
do the right thing.

OTOH, I think most (all?) compressed formats support texture sizes that are not
a multiple of the block size... essentially they need to provide a full block
but they can limit the texture definition to a subset of it. I.e it is valid to
call glCompressedTexImage2D(GL_TEXTURE_2D, 0, COMPRESSED_RGBA_S3TC_DXT1_EXT, 3,
3, 0, 8, data).

Is this something we should support? Otherwise, we need to add logic to verify
both width and height are both a multiple of the block size.

[christiank, 2015/02/18 14:38:25]

We only plan on supporting compressed textures that are a multiple of the block
size in size.

What do you think about adding a check in GpuCommandBufferStub::OnCreateImage?
Will that cover it?

[reveman, 2015/02/18 16:10:30]

Could we have SizeInBytes in gl_image_shared_memory.cc fail instead? Maybe add a
GLImageMemory::ValidHeight(size_t height, gfx::GpuMemoryBuffer::Format format)
function and this function can just return false if width is not valid.

[reveman, 2015/02/18 16:10:30]

Could we have SizeInBytes in gl_image_shared_memory.cc fail instead? Maybe add a
GLImageMemory::ValidHeight(size_t height, gfx::GpuMemoryBuffer::Format format)
function and this function can just return false if width is not valid. Would be
nice to keep these checks at this level rather than GpuCommandBufferStub if
possible as it would cover more use-cases. ie. single process unit tests..

[christiank, 2015/02/19 10:56:56]

Sure, sounds good to me. I have now added size checking.

+      s /= 2;
+      if (!s.IsValid())
+        return false;
+
+      *stride_in_bytes = s.ValueOrDie();
+      return true;
     case gfx::GpuMemoryBuffer::RGBA_8888:
     case gfx::GpuMemoryBuffer::BGRA_8888:
       s *= 4;
       if (!s.IsValid())
         return false;
 
       *stride_in_bytes = s.ValueOrDie();
       return true;
     case gfx::GpuMemoryBuffer::RGBX_8888:
       NOTREACHED();
@@ skipping 62 matching lines @@
 }
 
 bool GLImageMemory::CopyTexImage(unsigned target) {
   TRACE_EVENT0("gpu", "GLImageMemory::CopyTexImage");
 
   // GL_TEXTURE_EXTERNAL_OES is not a supported CopyTexImage target.
   if (target == GL_TEXTURE_EXTERNAL_OES)
     return false;
 
   DCHECK(memory_);
-  glTexSubImage2D(target, 0,  // level
-                  0,          // x
-                  0,          // y
-                  size_.width(), size_.height(), DataFormat(format_),
-                  DataType(format_), memory_);
+  if (CompressedFormat(format_)) {
+    glCompressedTexSubImage2D(target,
+                              0,  // level
+                              0,  // x-offset
+                              0,  // y-offset
+                              size_.width(), size_.height(),

[piman, 2015/02/14 00:50:21]

For the SubImage case, we definitely need width and height to be a multiple of
the block size.

[christiank, 2015/02/18 14:38:25]

Adding a check in GpuCommandBufferStub::OnCreateImage would cover this as well,
right?

[reveman, 2015/02/18 16:10:30]

Yes, or a check in SizeInBytes if we go that way.

+                              DataFormat(format_), SizeInBytes(size_, format_),
+                              memory_);
+  } else {
+    glTexSubImage2D(target, 0,  // level
+                    0,          // x
+                    0,          // y
+                    size_.width(), size_.height(), DataFormat(format_),
+                    DataType(format_), memory_);
+  }
 
   return true;
 }
 
 void GLImageMemory::WillUseTexImage() {
   DCHECK(!in_use_);
   in_use_ = true;
 
   if (!need_do_bind_tex_image_)
     return;
@@ skipping 28 matching lines @@
     if (egl_image_ == EGL_NO_IMAGE_KHR) {
       DCHECK_EQ(0u, egl_texture_id_);
       glGenTextures(1, &egl_texture_id_);
 
       {
         ScopedTextureBinder texture_binder(GL_TEXTURE_2D, egl_texture_id_);
 
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-        glTexImage2D(GL_TEXTURE_2D,
-                     0,  // mip level
-                     TextureFormat(format_),
-                     size_.width(),
-                     size_.height(),
-                     0,  // border
-                     DataFormat(format_),
-                     DataType(format_),
-                     memory_);
+        if (CompressedFormat(format_)) {
+          glCompressedTexImage2D(GL_TEXTURE_2D,
+                                 0,  // mip level
+                                 TextureFormat(format_), size_.width(),
+                                 size_.height(),
+                                 0,  // border
+                                 SizeInBytes(size_, format_), memory_);
+        } else {
+          glTexImage2D(GL_TEXTURE_2D,
+                       0,  // mip level
+                       TextureFormat(format_),
+                       size_.width(),
+                       size_.height(),
+                       0,  // border
+                       DataFormat(format_),
+                       DataType(format_),
+                       memory_);
+        }
       }
 
       EGLint attrs[] = {EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE};
       // Need to pass current EGL rendering context to eglCreateImageKHR for
       // target type EGL_GL_TEXTURE_2D_KHR.
       egl_image_ =
           eglCreateImageKHR(GLSurfaceEGL::GetHardwareDisplay(),
                             eglGetCurrentContext(),
                             EGL_GL_TEXTURE_2D_KHR,
                             reinterpret_cast<EGLClientBuffer>(egl_texture_id_),
                             attrs);
       DCHECK_NE(EGL_NO_IMAGE_KHR, egl_image_)
           << "Error creating EGLImage: " << eglGetError();
     } else {
       ScopedTextureBinder texture_binder(GL_TEXTURE_2D, egl_texture_id_);
 
-      glTexSubImage2D(GL_TEXTURE_2D,
-                      0,  // mip level
-                      0,  // x-offset
-                      0,  // y-offset
-                      size_.width(),
-                      size_.height(),
-                      DataFormat(format_),
-                      DataType(format_),
-                      memory_);
+      if (CompressedFormat(format_)) {
+        glCompressedTexSubImage2D(GL_TEXTURE_2D,
+                                  0,  // mip level
+                                  0,  // x-offset
+                                  0,  // y-offset
+                                  size_.width(), size_.height(),
+                                  DataFormat(format_),
+                                  SizeInBytes(size_, format_),
+                                  memory_);
+      } else {
+        glTexSubImage2D(GL_TEXTURE_2D,
+                        0,  // mip level
+                        0,  // x-offset
+                        0,  // y-offset
+                        size_.width(),
+                        size_.height(),
+                        DataFormat(format_),
+                        DataType(format_),
+                        memory_);
+      }
     }
 
     glEGLImageTargetTexture2DOES(target, egl_image_);
     DCHECK_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
     return;
   }
 #endif
 
   DCHECK_NE(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), target);
-  glTexImage2D(target,
-               0,  // mip level
-               TextureFormat(format_),
-               size_.width(),
-               size_.height(),
-               0,  // border
-               DataFormat(format_),
-               DataType(format_),
-               memory_);
+  if (CompressedFormat(format_)) {
+    glCompressedTexImage2D(target,
+                           0,  // mip level
+                           TextureFormat(format_), size_.width(),
+                           size_.height(),
+                           0,  // border
+                           SizeInBytes(size_, format_), memory_);
+  } else {
+    glTexImage2D(target,
+                 0,  // mip level
+                 TextureFormat(format_),
+                 size_.width(),
+                 size_.height(),
+                 0,  // border
+                 DataFormat(format_),
+                 DataType(format_),
+                 memory_);
+  }
 }
 
 }  // namespace gfx