ui: Add RGBX_8888 buffer format.

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/gfx/buffer_format_util.h"
 #include "ui/gl/gl_bindings.h"
 
 namespace gfx {
 namespace {
 
 bool ValidInternalFormat(unsigned internalformat) {
   switch (internalformat) {
     case GL_ATC_RGB_AMD:
     case GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD:
     case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
     case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
     case GL_ETC1_RGB8_OES:
     case GL_R8:
+    case GL_RGB:
     case GL_RGBA:
     case GL_BGRA_EXT:
       return true;
     default:
       return false;
   }
 }
 
 bool ValidFormat(BufferFormat format) {
   switch (format) {
     case BufferFormat::ATC:
     case BufferFormat::ATCIA:
     case BufferFormat::DXT1:
     case BufferFormat::DXT5:
     case BufferFormat::ETC1:
     case BufferFormat::R_8:
     case BufferFormat::RGBA_4444:
+    case BufferFormat::RGBX_8888:
     case BufferFormat::RGBA_8888:
+    case BufferFormat::BGRX_8888:
     case BufferFormat::BGRA_8888:
       return true;
-    case BufferFormat::BGRX_8888:
     case BufferFormat::YUV_420:
     case BufferFormat::YUV_420_BIPLANAR:
     case BufferFormat::UYVY_422:
       return false;
   }
 
   NOTREACHED();
   return false;
 }
 
 bool IsCompressedFormat(BufferFormat format) {
   switch (format) {
     case BufferFormat::ATC:
     case BufferFormat::ATCIA:
     case BufferFormat::DXT1:
     case BufferFormat::DXT5:
     case BufferFormat::ETC1:
       return true;
     case BufferFormat::R_8:
     case BufferFormat::RGBA_4444:
+    case BufferFormat::RGBX_8888:
     case BufferFormat::RGBA_8888:
+    case BufferFormat::BGRX_8888:
     case BufferFormat::BGRA_8888:
-    case BufferFormat::BGRX_8888:
     case BufferFormat::YUV_420:
     case BufferFormat::YUV_420_BIPLANAR:
     case BufferFormat::UYVY_422:
       return false;
   }
 
   NOTREACHED();
   return false;
 }
 
 GLenum TextureFormat(BufferFormat format) {
   switch (format) {
     case BufferFormat::ATC:
       return GL_ATC_RGB_AMD;
     case BufferFormat::ATCIA:
       return GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD;
     case BufferFormat::DXT1:
       return GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
     case BufferFormat::DXT5:
       return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
     case BufferFormat::ETC1:
       return GL_ETC1_RGB8_OES;
     case BufferFormat::R_8:
       return GL_RED;
     case BufferFormat::RGBA_4444:
     case BufferFormat::RGBA_8888:
       return GL_RGBA;
     case BufferFormat::BGRA_8888:
       return GL_BGRA_EXT;
+    case BufferFormat::RGBX_8888:
     case BufferFormat::BGRX_8888:
+      return GL_RGB;
     case BufferFormat::YUV_420:
     case BufferFormat::YUV_420_BIPLANAR:
     case BufferFormat::UYVY_422:
       NOTREACHED();
       return 0;
   }
 
   NOTREACHED();
   return 0;
 }
 
 GLenum DataFormat(BufferFormat format) {
-  return TextureFormat(format);
+  switch (format) {
+    case BufferFormat::RGBX_8888:
+      return GL_RGBA;
+    case BufferFormat::BGRX_8888:
+      return GL_BGRA_EXT;
+    case BufferFormat::RGBA_4444:
+    case BufferFormat::RGBA_8888:
+    case BufferFormat::BGRA_8888:
+    case BufferFormat::R_8:
+    case BufferFormat::ATC:
+    case BufferFormat::ATCIA:
+    case BufferFormat::DXT1:
+    case BufferFormat::DXT5:
+    case BufferFormat::ETC1:
+    case BufferFormat::YUV_420:
+    case BufferFormat::YUV_420_BIPLANAR:
+    case BufferFormat::UYVY_422:
+      return TextureFormat(format);
+  }
+
+  NOTREACHED();
+  return 0;
 }
 
 GLenum DataType(BufferFormat format) {
   switch (format) {
     case BufferFormat::RGBA_4444:
       return GL_UNSIGNED_SHORT_4_4_4_4;
     case BufferFormat::RGBA_8888:
     case BufferFormat::BGRA_8888:
     case BufferFormat::R_8:
       return GL_UNSIGNED_BYTE;
+    case BufferFormat::RGBX_8888:
+      return GL_UNSIGNED_INT_8_8_8_8;
+    case BufferFormat::BGRX_8888:
+      return GL_UNSIGNED_INT_8_8_8_8_REV;

[piman, 2015/10/23 00:52:44]

Hmm, I'm not sure what the expectation is here. Those 2 packed types are not
supported by GLES.

But even then, I can't work out why this is what you want.

The difference between GL_BGRA_EXT/GL_UNSIGNED_BYTE and
GL_BGRA_EXT/GL_UNSIGNED_INT_8_8_8_8_REV is inexistent on little-endian (and
would cause an undesirable swap on big-endian).

I'm even more confused by the RGBX_8888 one - on little-endian it would put the
4th byte (the X of RGBX) as the MSB of the unsigned int, which would then go
into the first component of the format (the R in GL_RGBA).


I realize that these end up not being used, but I think they make things
confusing.

[reveman, 2015/10/23 13:44:43]

Yea, that made no sense. Thanks for noticing. Latest patch uses GL_UNSIGNED_BYTE
for both formats and checks if we have full GL and in that case avoids the
conversion to 24bpp.

     case BufferFormat::ATC:
     case BufferFormat::ATCIA:
     case BufferFormat::DXT1:
     case BufferFormat::DXT5:
     case BufferFormat::ETC1:
-    case BufferFormat::BGRX_8888:
     case BufferFormat::YUV_420:
     case BufferFormat::YUV_420_BIPLANAR:
     case BufferFormat::UYVY_422:
       NOTREACHED();
       return 0;
   }
 
   NOTREACHED();
   return 0;
 }
 
-GLsizei SizeInBytes(const Size& size, BufferFormat format) {
-  size_t stride_in_bytes = 0;
-  bool valid_stride = GLImageMemory::StrideInBytes(
-      size.width(), format, &stride_in_bytes);
-  DCHECK(valid_stride);
-  return static_cast<GLsizei>(stride_in_bytes * size.height());
+template <typename F>
+scoped_ptr<uint8_t[]> GLES2RGBData(const Size& size,
+                                   BufferFormat format,
+                                   const uint8_t* data,
+                                   F const& data_to_rgb,
+                                   GLenum* data_format,
+                                   GLenum* data_type) {
+  TRACE_EVENT2("gpu", "GLES2RGBData", "width", size.width(), "height",
+               size.height());
+
+  // Four-byte row alignment as specified by glPixelStorei with argument
+  // GL_UNPACK_ALIGNMENT set to 4.
+  size_t gles2_rgb_data_stride = (size.width() * 3 + 3) & ~3;
+  scoped_ptr<uint8_t[]> gles2_rgb_data(
+      new uint8_t[gles2_rgb_data_stride * size.height()]);
+  size_t data_stride = RowSizeForBufferFormat(size.width(), format, 0);
+
+  for (int y = 0; y < size.height(); ++y) {
+    for (int x = 0; x < size.width(); ++x) {
+      data_to_rgb(&data[y * data_stride + x * 4],
+                  &gles2_rgb_data[y * gles2_rgb_data_stride + x * 3]);
+    }
+  }
+
+  *data_format = GL_RGB;
+  *data_type = GL_UNSIGNED_BYTE;
+  return gles2_rgb_data.Pass();
+}
+
+scoped_ptr<uint8_t[]> GLES2Data(const Size& size,
+                                BufferFormat format,
+                                const uint8_t* data,
+                                GLenum* data_format,
+                                GLenum* data_type) {
+  switch (format) {
+    case BufferFormat::RGBX_8888:
+      return GLES2RGBData(size, format,
+                          data, [](const uint8_t* src, uint8_t* dst) {
+                            dst[0] = src[0];
+                            dst[1] = src[1];
+                            dst[2] = src[2];
+                          }, data_format, data_type);
+    case BufferFormat::BGRX_8888:
+      return GLES2RGBData(size, format,
+                          data, [](const uint8_t* src, uint8_t* dst) {
+                            dst[0] = src[2];
+                            dst[1] = src[1];
+                            dst[2] = src[0];
+                          }, data_format, data_type);
+    case BufferFormat::RGBA_4444:
+    case BufferFormat::RGBA_8888:
+    case BufferFormat::BGRA_8888:
+    case BufferFormat::R_8:
+    case BufferFormat::ATC:
+    case BufferFormat::ATCIA:
+    case BufferFormat::DXT1:
+    case BufferFormat::DXT5:
+    case BufferFormat::ETC1:
+    case BufferFormat::YUV_420:
+    case BufferFormat::YUV_420_BIPLANAR:
+    case BufferFormat::UYVY_422:
+      // No data conversion needed.
+      return nullptr;
+  }
+
+  NOTREACHED();
+  return 0;
 }
 
 }  // namespace
 
 GLImageMemory::GLImageMemory(const Size& size, unsigned internalformat)
     : size_(size),
       internalformat_(internalformat),
       memory_(nullptr),
       format_(BufferFormat::RGBA_8888) {}
 
 GLImageMemory::~GLImageMemory() {
   DCHECK(!memory_);
 }
 
-// static
-bool GLImageMemory::StrideInBytes(size_t width,
-                                  BufferFormat format,
-                                  size_t* stride_in_bytes) {
-  base::CheckedNumeric<size_t> checked_stride = width;
-  switch (format) {
-    case BufferFormat::ATCIA:
-    case BufferFormat::DXT5:
-      *stride_in_bytes = width;
-      return true;
-    case BufferFormat::ATC:
-    case BufferFormat::DXT1:
-    case BufferFormat::ETC1:
-      DCHECK_EQ(width % 2, 0u);
-      *stride_in_bytes = width / 2;
-      return true;
-    case BufferFormat::R_8:
-      checked_stride += 3;
-      if (!checked_stride.IsValid())
-        return false;
-      *stride_in_bytes = checked_stride.ValueOrDie() & ~0x3;
-      return true;
-    case BufferFormat::RGBA_4444:
-      checked_stride *= 2;
-      if (!checked_stride.IsValid())
-        return false;
-      *stride_in_bytes = checked_stride.ValueOrDie();
-      return true;
-    case BufferFormat::RGBA_8888:
-    case BufferFormat::BGRA_8888:
-      checked_stride *= 4;
-      if (!checked_stride.IsValid())
-        return false;
-      *stride_in_bytes = checked_stride.ValueOrDie();
-      return true;
-    case BufferFormat::BGRX_8888:
-    case BufferFormat::YUV_420:
-    case BufferFormat::YUV_420_BIPLANAR:
-    case BufferFormat::UYVY_422:
-      NOTREACHED();
-      return false;
-  }
-
-  NOTREACHED();
-  return false;
-}
-
 bool GLImageMemory::Initialize(const unsigned char* memory,
                                BufferFormat format) {
   if (!ValidInternalFormat(internalformat_)) {
     LOG(ERROR) << "Invalid internalformat: " << internalformat_;
     return false;
   }
 
   if (!ValidFormat(format)) {
     LOG(ERROR) << "Invalid format: " << static_cast<int>(format);
     return false;
@@ skipping 27 matching lines @@
 bool GLImageMemory::CopyTexImage(unsigned target) {
   TRACE_EVENT2("gpu", "GLImageMemory::CopyTexImage", "width", size_.width(),
                "height", size_.height());
 
   // GL_TEXTURE_EXTERNAL_OES is not a supported target.
   if (target == GL_TEXTURE_EXTERNAL_OES)
     return false;
 
   if (IsCompressedFormat(format_)) {
     glCompressedTexImage2D(target, 0, TextureFormat(format_), size_.width(),
-                           size_.height(), 0, SizeInBytes(size_, format_),
-                           memory_);
+                           size_.height(), 0,
+                           BufferSizeForBufferFormat(size_, format_), memory_);
   } else {
+    GLenum data_format = DataFormat(format_);
+    GLenum data_type = DataType(format_);
+    // Note: Conversion of data to a GLES2 supported format is not necessary
+    // when using full OpenGL and additional data types are available. To keep
+    // things simple, always convert to GLES2 supported format for now.
+    scoped_ptr<uint8_t[]> gles2_data =
+        GLES2Data(size_, format_, memory_, &data_format, &data_type);
+
     glTexImage2D(target, 0, TextureFormat(format_), size_.width(),
-                 size_.height(), 0, DataFormat(format_), DataType(format_),
-                 memory_);
+                 size_.height(), 0, data_format, data_type,
+                 gles2_data ? gles2_data.get() : memory_);
   }
 
   return true;
 }
 
 bool GLImageMemory::CopyTexSubImage(unsigned target,
                                     const Point& offset,
                                     const Rect& rect) {
   TRACE_EVENT2("gpu", "GLImageMemory::CopyTexSubImage", "width", rect.width(),
                "height", rect.height());
 
   // GL_TEXTURE_EXTERNAL_OES is not a supported target.
   if (target == GL_TEXTURE_EXTERNAL_OES)
     return false;
 
   // Sub width is not supported.
   if (rect.width() != size_.width())
     return false;
 
   // Height must be a multiple of 4 if compressed.
   if (IsCompressedFormat(format_) && rect.height() % 4)
     return false;
 
-  size_t stride_in_bytes = 0;
-  bool rv = StrideInBytes(size_.width(), format_, &stride_in_bytes);
-  DCHECK(rv);
-  DCHECK(memory_);
-  const unsigned char* data = memory_ + rect.y() * stride_in_bytes;
+  const uint8_t* data =
+      memory_ + rect.y() * RowSizeForBufferFormat(size_.width(), format_, 0);
   if (IsCompressedFormat(format_)) {
     glCompressedTexSubImage2D(target, 0, offset.x(), offset.y(), rect.width(),
                               rect.height(), DataFormat(format_),
-                              SizeInBytes(rect.size(), format_), data);
+                              BufferSizeForBufferFormat(rect.size(), format_),
+                              data);
   } else {
+    GLenum data_format = DataFormat(format_);
+    GLenum data_type = DataType(format_);
+    scoped_ptr<uint8_t[]> gles2_data =
+        GLES2Data(rect.size(), format_, data, &data_format, &data_type);
+
     glTexSubImage2D(target, 0, offset.x(), offset.y(), rect.width(),
-                    rect.height(), DataFormat(format_), DataType(format_),
-                    data);
+                    rect.height(), data_format, data_type,
+                    gles2_data ? gles2_data.get() : data);
   }
 
   return true;
 }
 
 bool GLImageMemory::ScheduleOverlayPlane(AcceleratedWidget widget,
                                          int z_order,
                                          OverlayTransform transform,
                                          const Rect& bounds_rect,
                                          const RectF& crop_rect) {
   return false;
 }
 
+// static
+unsigned GLImageMemory::GetInternalFormatForTesting(BufferFormat format) {
+  DCHECK(ValidFormat(format));
+  return TextureFormat(format);
+}
+
 }  // namespace gfx