WebGL: tex(Sub)Image(2D|3D) texImageSource support for RGB10_A2 textures.

third_party/WebKit/Source/platform/graphics/gpu/WebGLImageConversion.cpp

 // 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 "platform/graphics/gpu/WebGLImageConversion.h"
 
 #include <memory>
 #include "platform/graphics/ImageObserver.h"
 #include "platform/graphics/cpu/arm/WebGLImageConversionNEON.h"
 #include "platform/graphics/cpu/mips/WebGLImageConversionMSA.h"
@@ skipping 1600 matching lines @@
         static_cast<double>(ClampMin(source[1])) * scale_factor);
     destination[2] = static_cast<int32_t>(
         static_cast<double>(ClampMin(source[2])) * scale_factor);
     source += 4;
     destination += 4;
   }
 }
 
 template <>
 void Pack<WebGLImageConversion::kDataFormatRGBA2_10_10_10,
+          WebGLImageConversion::kAlphaDoNothing,
+          float,
+          uint32_t>(const float* source,
+                    uint32_t* destination,
+                    unsigned pixels_per_row) {
+  for (unsigned i = 0; i < pixels_per_row; ++i) {
+    uint32_t r = static_cast<uint32_t>(source[0] * 1023.0f);
+    uint32_t g = static_cast<uint32_t>(source[1] * 1023.0f);
+    uint32_t b = static_cast<uint32_t>(source[2] * 1023.0f);
+    uint32_t a = static_cast<uint32_t>(source[3] * 3.0f);
+    destination[0] = (a << 30) | (b << 20) | (g << 10) | r;
+    source += 4;
+    destination += 1;
+  }
+}
+
+template <>
+void Pack<WebGLImageConversion::kDataFormatRGBA2_10_10_10,
           WebGLImageConversion::kAlphaDoPremultiply,
           float,
           uint32_t>(const float* source,
                     uint32_t* destination,
                     unsigned pixels_per_row) {
   for (unsigned i = 0; i < pixels_per_row; ++i) {
     uint32_t r = static_cast<uint32_t>(source[0] * source[3] * 1023.0f);
     uint32_t g = static_cast<uint32_t>(source[1] * source[3] * 1023.0f);
     uint32_t b = static_cast<uint32_t>(source[2] * source[3] * 1023.0f);
     uint32_t a = static_cast<uint32_t>(source[3] * 3.0f);
     destination[0] = (a << 30) | (b << 20) | (g << 10) | r;
     source += 4;
     destination += 1;
   }
 }
 
 template <>
+void Pack<WebGLImageConversion::kDataFormatRGBA2_10_10_10,
+          WebGLImageConversion::kAlphaDoUnmultiply,
+          float,
+          uint32_t>(const float* source,
+                    uint32_t* destination,
+                    unsigned pixels_per_row) {
+  for (unsigned i = 0; i < pixels_per_row; ++i) {
+    float scale_factor = source[3] ? 1023.0f / source[3] : 1023.0f;
+    uint32_t r = static_cast<uint32_t>(source[0] * scale_factor);
+    uint32_t g = static_cast<uint32_t>(source[1] * scale_factor);
+    uint32_t b = static_cast<uint32_t>(source[2] * scale_factor);
+    uint32_t a = static_cast<uint32_t>(source[3] * 3.0f);
+    destination[0] = (a << 30) | (b << 20) | (g << 10) | r;
+    source += 4;
+    destination += 1;
+  }
+}
+
+template <>
 void Pack<WebGLImageConversion::kDataFormatRG8,
           WebGLImageConversion::kAlphaDoNothing,
           uint8_t,
           uint8_t>(const uint8_t* source,
                    uint8_t* destination,
                    unsigned pixels_per_row) {
   for (unsigned i = 0; i < pixels_per_row; ++i) {
     destination[0] = source[0];
     destination[1] = source[1];
     source += 4;
@@ skipping 750 matching lines @@
       Format == WebGLImageConversion::kDataFormatRG32F ||
       Format == WebGLImageConversion::kDataFormatRA32F ||
       Format == WebGLImageConversion::kDataFormatR32F ||
       Format == WebGLImageConversion::kDataFormatRGBA16F ||
       Format == WebGLImageConversion::kDataFormatRGB16F ||
       Format == WebGLImageConversion::kDataFormatRG16F ||
       Format == WebGLImageConversion::kDataFormatRA16F ||
       Format == WebGLImageConversion::kDataFormatR16F ||
       Format == WebGLImageConversion::kDataFormatRGBA5551 ||
       Format == WebGLImageConversion::kDataFormatRGBA4444 ||
-      Format == WebGLImageConversion::kDataFormatRGB565;
+      Format == WebGLImageConversion::kDataFormatRGB565 ||
+      Format == WebGLImageConversion::kDataFormatRGBA2_10_10_10;
 };
 
 template <WebGLImageConversion::DataFormat SrcFormat,
           WebGLImageConversion::DataFormat DstFormat,
           WebGLImageConversion::AlphaOp alphaOp>
 void FormatConverter::Convert() {
   // Many instantiations of this template function will never be entered, so we
   // try to return immediately in these cases to avoid generating useless code.
   if (SrcFormat == DstFormat &&
       alphaOp == WebGLImageConversion::kAlphaDoNothing) {
@@ skipping 775 matching lines @@
       Pack<WebGLImageConversion::kDataFormatRGB565,
            WebGLImageConversion::kAlphaDoNothing>(src_row_start, dst_row_start,
                                                   pixels_per_row);
     } break;
     default:
       break;
   }
 }
 
 }  // namespace blink