Add OES_texture_half_float extension support in Chromium for desktop GL implementation.

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 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 "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 289 matching lines @@
         gl_internal_format = GL_ALPHA16F_ARB;
         break;
       default:
         NOTREACHED();
         break;
     }
   }
   return gl_internal_format;
 }
 
+static inline GLenum GetTexType(GLenum type) {
+  if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
+    if (type == GL_HALF_FLOAT_OES)
+      return GL_HALF_FLOAT_ARB;
+  }
+  return type;
+}
+
 static void WrappedTexImage2D(
     GLenum target,
     GLint level,
     GLenum internal_format,
     GLsizei width,
     GLsizei height,
     GLint border,
     GLenum format,
     GLenum type,
     const void* pixels) {
   glTexImage2D(
       target, level, GetTexInternalFormat(internal_format, format, type),
-      width, height, border, format, type, pixels);
+      width, height, border, format, GetTexType(type), pixels);
+}
+
+static void WrappedTexSubImage2D(
+      GLenum target,
+      GLint level,
+      GLint xoffset,
+      GLint yoffset,
+      GLsizei width,
+      GLsizei height,
+      GLenum format,
+      GLenum type,
+      const void * data) {
+  glTexSubImage2D(
+      target, level, xoffset, yoffset, width, height, format,
+      GetTexType(type), data);
 }
 
 // Wrapper for glEnable/glDisable that doesn't suck.
 static void EnableDisable(GLenum pname, bool enable) {
   if (enable) {
     glEnable(pname);
   } else {
     glDisable(pname);
   }
 }
@@ skipping 6575 matching lines @@
     GLint read_width = read_end_x - read_x;
     for (GLint yy = 0; yy < height; ++yy) {
       GLint ry = y + yy;
 
       // Clear the row.
       memset(dst, 0, unpadded_row_size);
 
       // If the row is in range, copy it.
       if (ry >= 0 && ry < max_size.height() && read_width > 0) {
         glReadPixels(
-            read_x, ry, read_width, 1, format, type, dst + dest_row_offset);
+            read_x, ry, read_width, 1, format, GetTexType(type),
+            dst + dest_row_offset);
       }
       dst += padded_row_size;
     }
   } else {
-    glReadPixels(x, y, width, height, format, type, pixels);
+    glReadPixels(x, y, width, height, format, GetTexType(type), pixels);
   }
   GLenum error = LOCAL_PEEK_GL_ERROR("glReadPixels");
   if (error == GL_NO_ERROR) {
     if (result != NULL) {
       *result = true;
     }
 
     GLenum read_format = GetBoundReadFrameBufferInternalFormat();
     uint32 channels_exist = GLES2Util::GetChannelsForFormat(read_format);
     if ((channels_exist & 0x0008) == 0 &&
@@ skipping 944 matching lines @@
   }
 
   if (texture->IsAttachedToFramebuffer()) {
     clear_state_dirty_ = true;
     // TODO(gman): If textures tracked which framebuffers they were attached to
     // we could just mark those framebuffers as not complete.
     framebuffer_manager()->IncFramebufferStateChangeCount();
   }
 
   if (!teximage2d_faster_than_texsubimage2d_ && level_is_same && pixels) {
-    glTexSubImage2D(target, level, 0, 0, width, height, format, type, pixels);
+    WrappedTexSubImage2D(target, level, 0, 0, width, height, format,
+                         type, pixels);
     texture_manager()->SetLevelCleared(texture, target, level, true);
     tex_image_2d_failed_ = false;
     return;
   }
 
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glTexImage2D");
   WrappedTexImage2D(
       target, level, internal_format, width, height, border, format, type,
       pixels);
   GLenum error = LOCAL_PEEK_GL_ERROR("glTexImage2D");
@@ skipping 469 matching lines @@
   bool ok = texture->GetLevelSize(target, level, &tex_width, &tex_height);
   DCHECK(ok);
   if (xoffset != 0 || yoffset != 0 ||
       width != tex_width || height != tex_height) {
     if (!texture_manager()->ClearTextureLevel(this, texture, target, level)) {
       LOCAL_SET_GL_ERROR(
           GL_OUT_OF_MEMORY, "glTexSubImage2D", "dimensions too big");
       return error::kNoError;
     }
     ScopedTextureUploadTimer timer(this);
-    glTexSubImage2D(
+    WrappedTexSubImage2D(
         target, level, xoffset, yoffset, width, height, format, type, data);
     return error::kNoError;
   }
 
   if (teximage2d_faster_than_texsubimage2d_ && !texture->IsImmutable()) {
     ScopedTextureUploadTimer timer(this);
     // NOTE: In OpenGL ES 2.0 border is always zero and format is always the
     // same as internal_foramt. If that changes we'll need to look them up.
     WrappedTexImage2D(
         target, level, format, width, height, 0, format, type, data);
   } else {
     ScopedTextureUploadTimer timer(this);
-    glTexSubImage2D(
+    WrappedTexSubImage2D(
         target, level, xoffset, yoffset, width, height, format, type, data);
   }
   texture_manager()->SetLevelCleared(texture, target, level, true);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleTexSubImage2D(
     uint32 immediate_data_size, const cmds::TexSubImage2D& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleTexSubImage2D");
   GLboolean internal = static_cast<GLboolean>(c.internal);
@@ skipping 1861 matching lines @@
   // it might need to be duped to prevent use-after-free of the memory.
   gpu::Buffer buffer = GetSharedMemoryBuffer(c.pixels_shm_id);
   base::SharedMemory* shared_memory = buffer.shared_memory;
   uint32 shm_size = buffer.size;
   uint32 shm_data_offset = c.pixels_shm_offset;
   uint32 shm_data_size = pixels_size;
 
   // Setup the parameters.
   GLenum gl_internal_format =
       GetTexInternalFormat(internal_format, format, type);
+  GLenum gl_type = GetTexType(type);
   gfx::AsyncTexImage2DParams tex_params = {target, level, gl_internal_format,
-                                           width, height, border, format, type};
+                                           width, height, border, format,
+                                           gl_type};
   gfx::AsyncMemoryParams mem_params = {shared_memory, shm_size,
                                        shm_data_offset, shm_data_size};
 
   // Set up the async state if needed, and make the texture
   // immutable so the async state stays valid. The level info
   // is set up lazily when the transfer completes.
   DCHECK(!texture->GetAsyncTransferState());
   texture->SetAsyncTransferState(
       make_scoped_ptr(
           async_pixel_transfer_delegate_->CreatePixelTransferState(
@@ skipping 68 matching lines @@
 
   // We know the memory/size is safe, so get the real shared memory since
   // it might need to be duped to prevent use-after-free of the memory.
   gpu::Buffer buffer = GetSharedMemoryBuffer(c.data_shm_id);
   base::SharedMemory* shared_memory = buffer.shared_memory;
   uint32 shm_size = buffer.size;
   uint32 shm_data_offset = c.data_shm_offset;
   uint32 shm_data_size = data_size;
 
   // Setup the parameters.
+  GLenum gl_type = GetTexType(type);
   gfx::AsyncTexSubImage2DParams tex_params = {target, level, xoffset, yoffset,
-                                              width, height, format, type};
+                                              width, height, format, gl_type};
   gfx::AsyncMemoryParams mem_params = {shared_memory, shm_size,
                                        shm_data_offset, shm_data_size};
   if (!texture->GetAsyncTransferState()) {
     // TODO(epenner): We may want to enforce exclusive use
     // of async APIs in which case this should become an error,
     // (the texture should have been async defined).
     gfx::AsyncTexImage2DParams define_params = {target, level,
                                                 0, 0, 0, 0, 0, 0};
     texture->GetLevelSize(target, level, &define_params.width,
                                          &define_params.height);
     texture->GetLevelType(target, level, &define_params.type,
                                          &define_params.internal_format);
+
+    // Update the internal_format and type for PixelTransferState if needed.
+    define_params.internal_format =
+      GetTexInternalFormat(define_params.internal_format,
+                           define_params.internal_format, type);
+    define_params.type = GetTexType(define_params.type);
+
     // Set up the async state if needed, and make the texture
     // immutable so the async state stays valid.
     texture->SetAsyncTransferState(
         make_scoped_ptr(
             async_pixel_transfer_delegate_->CreatePixelTransferState(
                 texture->service_id(),
                 define_params)));
     texture->SetImmutable(true);
   }
 
@@ skipping 25 matching lines @@
   return error::kNoError;
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu