Clean up the functions in loadimage.h/cpp.

BUILD.gn

@@ -390,6 +390,7 @@ if (is_win) {
       "src/libGLESv2/renderer/imageformats.h",
       "src/libGLESv2/renderer/loadimage.cpp",
       "src/libGLESv2/renderer/loadimage.h",
+      "src/libGLESv2/renderer/loadimage.inl",
       "src/libGLESv2/renderer/loadimageSSE2.cpp",
       "src/libGLESv2/renderer/vertexconversion.h",
       "src/libGLESv2/resource.h",

projects/src/libGLESv2.vcxproj

@@ -113,6 +113,7 @@
   <ItemGroup>
     <None Include="..\..\src\angle.gyp"/>
     <None Include="..\..\src\libGLESv2\libGLESv2.def"/>
+    <None Include="..\..\src\libGLESv2\renderer\loadimage.inl"/>
     <None Include="..\..\src\libGLESv2\renderer\d3d\d3d11\shaders\Swizzle11.hlsl"/>
     <None Include="..\..\src\libGLESv2\renderer\d3d\d3d11\shaders\generate_shaders.bat"/>
     <None Include="..\..\src\libGLESv2\renderer\d3d\d3d11\shaders\Passthrough3D11.hlsl"/>

projects/src/libGLESv2.vcxproj.filters

@@ -264,6 +264,9 @@
     <ClInclude Include="..\..\src\libGLESv2\renderer\TextureStorage.h">
       <Filter>src\libGLESv2\renderer</Filter>
     </ClInclude>
+    <None Include="..\..\src\libGLESv2\renderer\loadimage.inl">
+      <Filter>src\libGLESv2\renderer</Filter>
+    </None>
     <ClInclude Include="..\..\src\libGLESv2\renderer\ShaderExecutable.h">
       <Filter>src\libGLESv2\renderer</Filter>
     </ClInclude>

src/libGLESv2.gypi

@@ -37,7 +37,7 @@
                     [
                         '<!@(python <(angle_path)/enumerate_files.py \
                              -dirs common libGLESv2 third_party/murmurhash ../include third_party/systeminfo \
-                             -types *.cpp *.h *.hlsl *.vs *.ps *.bat *.def *.rc \
+                             -types *.cpp *.h *.inl *.hlsl *.vs *.ps *.bat *.def *.rc \
                              -excludes */d3d/*)',
                     ],
                     'defines':
@@ -54,7 +54,7 @@
                             [
                                 '<!@(python <(angle_path)/enumerate_files.py \
                                      -dirs libGLESv2/renderer/d3d libGLESv2/renderer/d3d/d3d9 \
-                                     -types *.cpp *.h *.vs *.ps *.bat)',
+                                     -types *.cpp *.h *.inl *.vs *.ps *.bat)',
                             ],
                             'defines':
                             [
@@ -77,7 +77,7 @@
                             [
                                 '<!@(python <(angle_path)/enumerate_files.py \
                                      -dirs libGLESv2/renderer/d3d libGLESv2/renderer/d3d/d3d/d3d11 \
-                                     -types *.cpp *.h *.hlsl *.bat)',
+                                     -types *.cpp *.h *.inl *.hlsl *.bat)',
                             ],
                             'defines':
                             [

src/libGLESv2/formatutils.h

@@ -14,16 +14,18 @@
 #include "libGLESv2/Caps.h"
 #include "libGLESv2/angletypes.h"
 
+#include <cstddef>
+
 typedef void (*MipGenerationFunction)(unsigned int sourceWidth, unsigned int sourceHeight, unsigned int sourceDepth,
                                       const unsigned char *sourceData, int sourceRowPitch, int sourceDepthPitch,
                                       unsigned char *destData, int destRowPitch, int destDepthPitch);
 
-typedef void (*LoadImageFunction)(int width, int height, int depth,
-                                  const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                  void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+typedef void (*LoadImageFunction)(size_t width, size_t height, size_t depth,
+                                  const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                                  uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-typedef void (*InitializeTextureDataFunction)(int width, int height, int depth,
-                                              void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+typedef void (*InitializeTextureDataFunction)(size_t width, size_t height, size_t depth,
+                                              uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
 typedef void (*ColorReadFunction)(const void *source, void *dest);
 typedef void (*ColorWriteFunction)(const void *source, void *dest);

src/libGLESv2/renderer/d3d/d3d11/Image11.cpp

@@ -168,8 +168,10 @@ void Image11::loadData(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei widt
         return;
     }
 
-    void* offsetMappedData = (void*)((BYTE *)mappedImage.pData + (yoffset * mappedImage.RowPitch + xoffset * outputPixelSize + zoffset * mappedImage.DepthPitch));
-    loadFunction(width, height, depth, input, inputRowPitch, inputDepthPitch, offsetMappedData, mappedImage.RowPitch, mappedImage.DepthPitch);
+    uint8_t* offsetMappedData = (reinterpret_cast<uint8_t*>(mappedImage.pData) + (yoffset * mappedImage.RowPitch + xoffset * outputPixelSize + zoffset * mappedImage.DepthPitch));
+    loadFunction(width, height, depth,
+                 reinterpret_cast<const uint8_t*>(input), inputRowPitch, inputDepthPitch,
+                 offsetMappedData, mappedImage.RowPitch, mappedImage.DepthPitch);
 
     unmap();
 }
@@ -198,11 +200,12 @@ void Image11::loadCompressedData(GLint xoffset, GLint yoffset, GLint zoffset, GL
         return;
     }
 
-    void* offsetMappedData = (void*)((BYTE*)mappedImage.pData + ((yoffset / outputBlockHeight) * mappedImage.RowPitch +
-                                                                 (xoffset / outputBlockWidth) * outputPixelSize +
-                                                                 zoffset * mappedImage.DepthPitch));
+    uint8_t* offsetMappedData = reinterpret_cast<uint8_t*>(mappedImage.pData) + ((yoffset / outputBlockHeight) * mappedImage.RowPitch +
+                                                                           (xoffset / outputBlockWidth) * outputPixelSize +
+                                                                           zoffset * mappedImage.DepthPitch);
 
-    loadFunction(width, height, depth, input, inputRowPitch, inputDepthPitch,
+    loadFunction(width, height, depth,
+                 reinterpret_cast<const uint8_t*>(input), inputRowPitch, inputDepthPitch,
                  offsetMappedData, mappedImage.RowPitch, mappedImage.DepthPitch);
 
     unmap();

src/libGLESv2/renderer/d3d/d3d11/formatutils11.cpp

@@ -183,16 +183,16 @@ typedef std::pair<GLenum, GLenum> InternalFormatTypePair;
 typedef std::pair<InternalFormatTypePair, LoadImageFunction> D3D11LoadFunctionPair;
 typedef std::map<InternalFormatTypePair, LoadImageFunction> D3D11LoadFunctionMap;
 
-static void UnimplementedLoadFunction(int width, int height, int depth,
-                                      const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                      void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+static void UnimplementedLoadFunction(size_t width, size_t height, size_t depth,
+                                      const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                                      uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
     UNIMPLEMENTED();
 }
 
-static void UnreachableLoadFunction(int width, int height, int depth,
-                                    const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                    void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+static void UnreachableLoadFunction(size_t width, size_t height, size_t depth,
+                                    const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                                    uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
     UNREACHABLE();
 }
@@ -209,79 +209,79 @@ D3D11LoadFunctionMap buildD3D11LoadFunctionMap()
     D3D11LoadFunctionMap map;
 
     //                      | Internal format      | Type                             | Load function                       |
-    insertLoadFunction(&map, GL_RGBA8,              GL_UNSIGNED_BYTE,                  loadToNative<GLubyte, 4>             );
-    insertLoadFunction(&map, GL_RGB5_A1,            GL_UNSIGNED_BYTE,                  loadToNative<GLubyte, 4>             );
-    insertLoadFunction(&map, GL_RGBA4,              GL_UNSIGNED_BYTE,                  loadToNative<GLubyte, 4>             );
-    insertLoadFunction(&map, GL_SRGB8_ALPHA8,       GL_UNSIGNED_BYTE,                  loadToNative<GLubyte, 4>             );
-    insertLoadFunction(&map, GL_RGBA8_SNORM,        GL_BYTE,                           loadToNative<GLbyte, 4>              );
-    insertLoadFunction(&map, GL_RGBA4,              GL_UNSIGNED_SHORT_4_4_4_4,         loadRGBA4444DataToRGBA               );
-    insertLoadFunction(&map, GL_RGB10_A2,           GL_UNSIGNED_INT_2_10_10_10_REV,    loadToNative<GLuint, 1>              );
-    insertLoadFunction(&map, GL_RGB5_A1,            GL_UNSIGNED_SHORT_5_5_5_1,         loadRGBA5551DataToRGBA               );
-    insertLoadFunction(&map, GL_RGB5_A1,            GL_UNSIGNED_INT_2_10_10_10_REV,    loadRGBA2101010ToRGBA                );
-    insertLoadFunction(&map, GL_RGBA16F,            GL_HALF_FLOAT,                     loadToNative<GLhalf, 4>              );
-    insertLoadFunction(&map, GL_RGBA16F,            GL_HALF_FLOAT_OES,                 loadToNative<GLhalf, 4>              );
-    insertLoadFunction(&map, GL_RGBA32F,            GL_FLOAT,                          loadToNative<GLfloat, 4>             );
-    insertLoadFunction(&map, GL_RGBA16F,            GL_FLOAT,                          loadFloatDataToHalfFloat<4>          );
-    insertLoadFunction(&map, GL_RGBA8UI,            GL_UNSIGNED_BYTE,                  loadToNative<GLubyte, 4>             );
-    insertLoadFunction(&map, GL_RGBA8I,             GL_BYTE,                           loadToNative<GLbyte, 4>              );
-    insertLoadFunction(&map, GL_RGBA16UI,           GL_UNSIGNED_SHORT,                 loadToNative<GLushort, 4>            );
-    insertLoadFunction(&map, GL_RGBA16I,            GL_SHORT,                          loadToNative<GLshort, 4>             );
-    insertLoadFunction(&map, GL_RGBA32UI,           GL_UNSIGNED_INT,                   loadToNative<GLuint, 4>              );
-    insertLoadFunction(&map, GL_RGBA32I,            GL_INT,                            loadToNative<GLint, 4>               );
-    insertLoadFunction(&map, GL_RGB10_A2UI,         GL_UNSIGNED_INT_2_10_10_10_REV,    loadToNative<GLuint, 1>              );
-    insertLoadFunction(&map, GL_RGB8,               GL_UNSIGNED_BYTE,                  loadRGBUByteDataToRGBA               );
-    insertLoadFunction(&map, GL_RGB565,             GL_UNSIGNED_BYTE,                  loadToNative3To4<GLubyte, 0xFF>      );
-    insertLoadFunction(&map, GL_SRGB8,              GL_UNSIGNED_BYTE,                  loadToNative3To4<GLubyte, 0xFF>      );
-    insertLoadFunction(&map, GL_RGB8_SNORM,         GL_BYTE,                           loadRGBSByteDataToRGBA               );
-    insertLoadFunction(&map, GL_RGB565,             GL_UNSIGNED_SHORT_5_6_5,           loadRGB565DataToRGBA                 );
-    insertLoadFunction(&map, GL_R11F_G11F_B10F,     GL_UNSIGNED_INT_10F_11F_11F_REV,   loadToNative<GLuint, 1>              );
-    insertLoadFunction(&map, GL_RGB9_E5,            GL_UNSIGNED_INT_5_9_9_9_REV,       loadToNative<GLuint, 1>              );
-    insertLoadFunction(&map, GL_RGB16F,             GL_HALF_FLOAT,                     loadToNative3To4<GLhalf, gl::Float16One>);
-    insertLoadFunction(&map, GL_RGB16F,             GL_HALF_FLOAT_OES,                 loadToNative3To4<GLhalf, gl::Float16One>);
-    insertLoadFunction(&map, GL_R11F_G11F_B10F,     GL_HALF_FLOAT,                     loadRGBHalfFloatDataTo111110Float    );
-    insertLoadFunction(&map, GL_R11F_G11F_B10F,     GL_HALF_FLOAT_OES,                 loadRGBHalfFloatDataTo111110Float    );
-    insertLoadFunction(&map, GL_RGB9_E5,            GL_HALF_FLOAT,                     loadRGBHalfFloatDataTo999E5          );
-    insertLoadFunction(&map, GL_RGB9_E5,            GL_HALF_FLOAT_OES,                 loadRGBHalfFloatDataTo999E5          );
-    insertLoadFunction(&map, GL_RGB32F,             GL_FLOAT,                          loadToNative3To4<GLfloat, gl::Float32One>);
-    insertLoadFunction(&map, GL_RGB16F,             GL_FLOAT,                          loadFloatRGBDataToHalfFloatRGBA      );
-    insertLoadFunction(&map, GL_R11F_G11F_B10F,     GL_FLOAT,                          loadRGBFloatDataTo111110Float        );
-    insertLoadFunction(&map, GL_RGB9_E5,            GL_FLOAT,                          loadRGBFloatDataTo999E5              );
-    insertLoadFunction(&map, GL_RGB8UI,             GL_UNSIGNED_BYTE,                  loadToNative3To4<GLubyte, 0x01>      );
-    insertLoadFunction(&map, GL_RGB8I,              GL_BYTE,                           loadToNative3To4<GLbyte, 0x01>       );
-    insertLoadFunction(&map, GL_RGB16UI,            GL_UNSIGNED_SHORT,                 loadToNative3To4<GLushort, 0x0001>   );
-    insertLoadFunction(&map, GL_RGB16I,             GL_SHORT,                          loadToNative3To4<GLshort, 0x0001>    );
-    insertLoadFunction(&map, GL_RGB32UI,            GL_UNSIGNED_INT,                   loadToNative3To4<GLuint, 0x00000001> );
-    insertLoadFunction(&map, GL_RGB32I,             GL_INT,                            loadToNative3To4<GLint, 0x00000001>  );
-    insertLoadFunction(&map, GL_RG8,                GL_UNSIGNED_BYTE,                  loadToNative<GLubyte, 2>             );
-    insertLoadFunction(&map, GL_RG8_SNORM,          GL_BYTE,                           loadToNative<GLbyte, 2>              );
-    insertLoadFunction(&map, GL_RG16F,              GL_HALF_FLOAT,                     loadToNative<GLhalf, 2>              );
-    insertLoadFunction(&map, GL_RG16F,              GL_HALF_FLOAT_OES,                 loadToNative<GLhalf, 2>              );
-    insertLoadFunction(&map, GL_RG32F,              GL_FLOAT,                          loadToNative<GLfloat, 2>             );
-    insertLoadFunction(&map, GL_RG16F,              GL_FLOAT,                          loadFloatDataToHalfFloat<2>          );
-    insertLoadFunction(&map, GL_RG8UI,              GL_UNSIGNED_BYTE,                  loadToNative<GLubyte, 2>             );
-    insertLoadFunction(&map, GL_RG8I,               GL_BYTE,                           loadToNative<GLbyte, 2>              );
-    insertLoadFunction(&map, GL_RG16UI,             GL_UNSIGNED_SHORT,                 loadToNative<GLushort, 2>            );
-    insertLoadFunction(&map, GL_RG16I,              GL_SHORT,                          loadToNative<GLshort, 2>             );
-    insertLoadFunction(&map, GL_RG32UI,             GL_UNSIGNED_INT,                   loadToNative<GLuint, 2>              );
-    insertLoadFunction(&map, GL_RG32I,              GL_INT,                            loadToNative<GLint, 2>               );
-    insertLoadFunction(&map, GL_R8,                 GL_UNSIGNED_BYTE,                  loadToNative<GLubyte, 1>             );
-    insertLoadFunction(&map, GL_R8_SNORM,           GL_BYTE,                           loadToNative<GLbyte, 1>              );
-    insertLoadFunction(&map, GL_R16F,               GL_HALF_FLOAT,                     loadToNative<GLhalf, 1>              );
-    insertLoadFunction(&map, GL_R16F,               GL_HALF_FLOAT_OES,                 loadToNative<GLhalf, 1>              );
-    insertLoadFunction(&map, GL_R32F,               GL_FLOAT,                          loadToNative<GLfloat, 1>             );
-    insertLoadFunction(&map, GL_R16F,               GL_FLOAT,                          loadFloatDataToHalfFloat<1>          );
-    insertLoadFunction(&map, GL_R8UI,               GL_UNSIGNED_BYTE,                  loadToNative<GLubyte, 1>             );
-    insertLoadFunction(&map, GL_R8I,                GL_BYTE,                           loadToNative<GLbyte, 1>              );
-    insertLoadFunction(&map, GL_R16UI,              GL_UNSIGNED_SHORT,                 loadToNative<GLushort, 1>            );
-    insertLoadFunction(&map, GL_R16I,               GL_SHORT,                          loadToNative<GLshort, 1>             );
-    insertLoadFunction(&map, GL_R32UI,              GL_UNSIGNED_INT,                   loadToNative<GLuint, 1>              );
-    insertLoadFunction(&map, GL_R32I,               GL_INT,                            loadToNative<GLint, 1>               );
-    insertLoadFunction(&map, GL_DEPTH_COMPONENT16,  GL_UNSIGNED_SHORT,                 loadToNative<GLushort, 1>            );
-    insertLoadFunction(&map, GL_DEPTH_COMPONENT24,  GL_UNSIGNED_INT,                   loadG8R24DataToR24G8                 );
-    insertLoadFunction(&map, GL_DEPTH_COMPONENT16,  GL_UNSIGNED_INT,                   loadUintDataToUshort                 );
-    insertLoadFunction(&map, GL_DEPTH_COMPONENT32F, GL_FLOAT,                          loadToNative<GLfloat, 1>             );
-    insertLoadFunction(&map, GL_DEPTH24_STENCIL8,   GL_UNSIGNED_INT_24_8,              loadG8R24DataToR24G8                 );
-    insertLoadFunction(&map, GL_DEPTH32F_STENCIL8,  GL_FLOAT_32_UNSIGNED_INT_24_8_REV, loadToNative<GLuint, 2>              );
+    insertLoadFunction(&map, GL_RGBA8,              GL_UNSIGNED_BYTE,                  LoadToNative<GLubyte, 4>             );
+    insertLoadFunction(&map, GL_RGB5_A1,            GL_UNSIGNED_BYTE,                  LoadToNative<GLubyte, 4>             );
+    insertLoadFunction(&map, GL_RGBA4,              GL_UNSIGNED_BYTE,                  LoadToNative<GLubyte, 4>             );
+    insertLoadFunction(&map, GL_SRGB8_ALPHA8,       GL_UNSIGNED_BYTE,                  LoadToNative<GLubyte, 4>             );
+    insertLoadFunction(&map, GL_RGBA8_SNORM,        GL_BYTE,                           LoadToNative<GLbyte, 4>              );
+    insertLoadFunction(&map, GL_RGBA4,              GL_UNSIGNED_SHORT_4_4_4_4,         LoadRGBA4ToRGBA8                     );
+    insertLoadFunction(&map, GL_RGB10_A2,           GL_UNSIGNED_INT_2_10_10_10_REV,    LoadToNative<GLuint, 1>              );
+    insertLoadFunction(&map, GL_RGB5_A1,            GL_UNSIGNED_SHORT_5_5_5_1,         LoadRGB5A1ToRGBA8                    );
+    insertLoadFunction(&map, GL_RGB5_A1,            GL_UNSIGNED_INT_2_10_10_10_REV,    LoadRGB10A2ToRGBA8                   );
+    insertLoadFunction(&map, GL_RGBA16F,            GL_HALF_FLOAT,                     LoadToNative<GLhalf, 4>              );
+    insertLoadFunction(&map, GL_RGBA16F,            GL_HALF_FLOAT_OES,                 LoadToNative<GLhalf, 4>              );
+    insertLoadFunction(&map, GL_RGBA32F,            GL_FLOAT,                          LoadToNative<GLfloat, 4>             );
+    insertLoadFunction(&map, GL_RGBA16F,            GL_FLOAT,                          Load32FTo16F<4>                      );
+    insertLoadFunction(&map, GL_RGBA8UI,            GL_UNSIGNED_BYTE,                  LoadToNative<GLubyte, 4>             );
+    insertLoadFunction(&map, GL_RGBA8I,             GL_BYTE,                           LoadToNative<GLbyte, 4>              );
+    insertLoadFunction(&map, GL_RGBA16UI,           GL_UNSIGNED_SHORT,                 LoadToNative<GLushort, 4>            );
+    insertLoadFunction(&map, GL_RGBA16I,            GL_SHORT,                          LoadToNative<GLshort, 4>             );
+    insertLoadFunction(&map, GL_RGBA32UI,           GL_UNSIGNED_INT,                   LoadToNative<GLuint, 4>              );
+    insertLoadFunction(&map, GL_RGBA32I,            GL_INT,                            LoadToNative<GLint, 4>               );
+    insertLoadFunction(&map, GL_RGB10_A2UI,         GL_UNSIGNED_INT_2_10_10_10_REV,    LoadToNative<GLuint, 1>              );
+    insertLoadFunction(&map, GL_RGB8,               GL_UNSIGNED_BYTE,                  LoadToNative3To4<GLubyte, 0xFF>      );
+    insertLoadFunction(&map, GL_RGB565,             GL_UNSIGNED_BYTE,                  LoadToNative3To4<GLubyte, 0xFF>      );
+    insertLoadFunction(&map, GL_SRGB8,              GL_UNSIGNED_BYTE,                  LoadToNative3To4<GLubyte, 0xFF>      );
+    insertLoadFunction(&map, GL_RGB8_SNORM,         GL_BYTE,                           LoadToNative3To4<GLbyte, 0x7F>       );
+    insertLoadFunction(&map, GL_RGB565,             GL_UNSIGNED_SHORT_5_6_5,           LoadR5G6B5ToRGBA8                    );
+    insertLoadFunction(&map, GL_R11F_G11F_B10F,     GL_UNSIGNED_INT_10F_11F_11F_REV,   LoadToNative<GLuint, 1>              );
+    insertLoadFunction(&map, GL_RGB9_E5,            GL_UNSIGNED_INT_5_9_9_9_REV,       LoadToNative<GLuint, 1>              );
+    insertLoadFunction(&map, GL_RGB16F,             GL_HALF_FLOAT,                     LoadToNative3To4<GLhalf, gl::Float16One>);
+    insertLoadFunction(&map, GL_RGB16F,             GL_HALF_FLOAT_OES,                 LoadToNative3To4<GLhalf, gl::Float16One>);
+    insertLoadFunction(&map, GL_R11F_G11F_B10F,     GL_HALF_FLOAT,                     LoadRGB16FToRG11B10F                 );
+    insertLoadFunction(&map, GL_R11F_G11F_B10F,     GL_HALF_FLOAT_OES,                 LoadRGB16FToRG11B10F                 );
+    insertLoadFunction(&map, GL_RGB9_E5,            GL_HALF_FLOAT,                     LoadRGB16FToRGB9E5                   );
+    insertLoadFunction(&map, GL_RGB9_E5,            GL_HALF_FLOAT_OES,                 LoadRGB16FToRGB9E5                   );
+    insertLoadFunction(&map, GL_RGB32F,             GL_FLOAT,                          LoadToNative3To4<GLfloat, gl::Float32One>);
+    insertLoadFunction(&map, GL_RGB16F,             GL_FLOAT,                          LoadRGB32FToRGBA16F                  );
+    insertLoadFunction(&map, GL_R11F_G11F_B10F,     GL_FLOAT,                          LoadRGB32FToRG11B10F                 );
+    insertLoadFunction(&map, GL_RGB9_E5,            GL_FLOAT,                          LoadRGB32FToRGB9E5                   );
+    insertLoadFunction(&map, GL_RGB8UI,             GL_UNSIGNED_BYTE,                  LoadToNative3To4<GLubyte, 0x01>      );
+    insertLoadFunction(&map, GL_RGB8I,              GL_BYTE,                           LoadToNative3To4<GLbyte, 0x01>       );
+    insertLoadFunction(&map, GL_RGB16UI,            GL_UNSIGNED_SHORT,                 LoadToNative3To4<GLushort, 0x0001>   );
+    insertLoadFunction(&map, GL_RGB16I,             GL_SHORT,                          LoadToNative3To4<GLshort, 0x0001>    );
+    insertLoadFunction(&map, GL_RGB32UI,            GL_UNSIGNED_INT,                   LoadToNative3To4<GLuint, 0x00000001> );
+    insertLoadFunction(&map, GL_RGB32I,             GL_INT,                            LoadToNative3To4<GLint, 0x00000001>  );
+    insertLoadFunction(&map, GL_RG8,                GL_UNSIGNED_BYTE,                  LoadToNative<GLubyte, 2>             );
+    insertLoadFunction(&map, GL_RG8_SNORM,          GL_BYTE,                           LoadToNative<GLbyte, 2>              );
+    insertLoadFunction(&map, GL_RG16F,              GL_HALF_FLOAT,                     LoadToNative<GLhalf, 2>              );
+    insertLoadFunction(&map, GL_RG16F,              GL_HALF_FLOAT_OES,                 LoadToNative<GLhalf, 2>              );
+    insertLoadFunction(&map, GL_RG32F,              GL_FLOAT,                          LoadToNative<GLfloat, 2>             );
+    insertLoadFunction(&map, GL_RG16F,              GL_FLOAT,                          Load32FTo16F<2>                      );
+    insertLoadFunction(&map, GL_RG8UI,              GL_UNSIGNED_BYTE,                  LoadToNative<GLubyte, 2>             );
+    insertLoadFunction(&map, GL_RG8I,               GL_BYTE,                           LoadToNative<GLbyte, 2>              );
+    insertLoadFunction(&map, GL_RG16UI,             GL_UNSIGNED_SHORT,                 LoadToNative<GLushort, 2>            );
+    insertLoadFunction(&map, GL_RG16I,              GL_SHORT,                          LoadToNative<GLshort, 2>             );
+    insertLoadFunction(&map, GL_RG32UI,             GL_UNSIGNED_INT,                   LoadToNative<GLuint, 2>              );
+    insertLoadFunction(&map, GL_RG32I,              GL_INT,                            LoadToNative<GLint, 2>               );
+    insertLoadFunction(&map, GL_R8,                 GL_UNSIGNED_BYTE,                  LoadToNative<GLubyte, 1>             );
+    insertLoadFunction(&map, GL_R8_SNORM,           GL_BYTE,                           LoadToNative<GLbyte, 1>              );
+    insertLoadFunction(&map, GL_R16F,               GL_HALF_FLOAT,                     LoadToNative<GLhalf, 1>              );
+    insertLoadFunction(&map, GL_R16F,               GL_HALF_FLOAT_OES,                 LoadToNative<GLhalf, 1>              );
+    insertLoadFunction(&map, GL_R32F,               GL_FLOAT,                          LoadToNative<GLfloat, 1>             );
+    insertLoadFunction(&map, GL_R16F,               GL_FLOAT,                          Load32FTo16F<1>                      );
+    insertLoadFunction(&map, GL_R8UI,               GL_UNSIGNED_BYTE,                  LoadToNative<GLubyte, 1>             );
+    insertLoadFunction(&map, GL_R8I,                GL_BYTE,                           LoadToNative<GLbyte, 1>              );
+    insertLoadFunction(&map, GL_R16UI,              GL_UNSIGNED_SHORT,                 LoadToNative<GLushort, 1>            );
+    insertLoadFunction(&map, GL_R16I,               GL_SHORT,                          LoadToNative<GLshort, 1>             );
+    insertLoadFunction(&map, GL_R32UI,              GL_UNSIGNED_INT,                   LoadToNative<GLuint, 1>              );
+    insertLoadFunction(&map, GL_R32I,               GL_INT,                            LoadToNative<GLint, 1>               );
+    insertLoadFunction(&map, GL_DEPTH_COMPONENT16,  GL_UNSIGNED_SHORT,                 LoadToNative<GLushort, 1>            );
+    insertLoadFunction(&map, GL_DEPTH_COMPONENT24,  GL_UNSIGNED_INT,                   LoadR32ToR24G8                       );
+    insertLoadFunction(&map, GL_DEPTH_COMPONENT16,  GL_UNSIGNED_INT,                   LoadR32ToR16                         );
+    insertLoadFunction(&map, GL_DEPTH_COMPONENT32F, GL_FLOAT,                          LoadToNative<GLfloat, 1>             );
+    insertLoadFunction(&map, GL_DEPTH24_STENCIL8,   GL_UNSIGNED_INT_24_8,              LoadR32ToR24G8                       );
+    insertLoadFunction(&map, GL_DEPTH32F_STENCIL8,  GL_FLOAT_32_UNSIGNED_INT_24_8_REV, LoadToNative<GLuint, 2>              );
 
     // Unsized formats
     // Load functions are unreachable because they are converted to sized internal formats based on
@@ -296,41 +296,41 @@ D3D11LoadFunctionMap buildD3D11LoadFunctionMap()
     insertLoadFunction(&map, GL_ALPHA,              GL_UNSIGNED_BYTE,                  UnreachableLoadFunction              );
 
     // From GL_OES_texture_float
-    insertLoadFunction(&map, GL_LUMINANCE_ALPHA,    GL_FLOAT,                          loadLuminanceAlphaFloatDataToRGBA    );
-    insertLoadFunction(&map, GL_LUMINANCE,          GL_FLOAT,                          loadLuminanceFloatDataToRGBA         );
-    insertLoadFunction(&map, GL_ALPHA,              GL_FLOAT,                          loadAlphaFloatDataToRGBA             );
+    insertLoadFunction(&map, GL_LUMINANCE_ALPHA,    GL_FLOAT,                          LoadLA32FToRGBA32F                   );
+    insertLoadFunction(&map, GL_LUMINANCE,          GL_FLOAT,                          LoadL32FToRGBA32F                    );
+    insertLoadFunction(&map, GL_ALPHA,              GL_FLOAT,                          LoadA32FToRGBA32F                    );
 
     // From GL_OES_texture_half_float
-    insertLoadFunction(&map, GL_LUMINANCE_ALPHA,    GL_HALF_FLOAT,                     loadLuminanceAlphaHalfFloatDataToRGBA);
-    insertLoadFunction(&map, GL_LUMINANCE_ALPHA,    GL_HALF_FLOAT_OES,                 loadLuminanceAlphaHalfFloatDataToRGBA);
-    insertLoadFunction(&map, GL_LUMINANCE,          GL_HALF_FLOAT,                     loadLuminanceHalfFloatDataToRGBA     );
-    insertLoadFunction(&map, GL_LUMINANCE,          GL_HALF_FLOAT_OES,                 loadLuminanceHalfFloatDataToRGBA     );
-    insertLoadFunction(&map, GL_ALPHA,              GL_HALF_FLOAT,                     loadAlphaHalfFloatDataToRGBA         );
-    insertLoadFunction(&map, GL_ALPHA,              GL_HALF_FLOAT_OES,                 loadAlphaHalfFloatDataToRGBA         );
+    insertLoadFunction(&map, GL_LUMINANCE_ALPHA,    GL_HALF_FLOAT,                     LoadLA16FToRGBA16F                   );
+    insertLoadFunction(&map, GL_LUMINANCE_ALPHA,    GL_HALF_FLOAT_OES,                 LoadLA16FToRGBA16F                   );
+    insertLoadFunction(&map, GL_LUMINANCE,          GL_HALF_FLOAT,                     LoadL16FToRGBA16F                    );
+    insertLoadFunction(&map, GL_LUMINANCE,          GL_HALF_FLOAT_OES,                 LoadL16FToRGBA16F                    );
+    insertLoadFunction(&map, GL_ALPHA,              GL_HALF_FLOAT,                     LoadA16FToRGBA16F                    );
+    insertLoadFunction(&map, GL_ALPHA,              GL_HALF_FLOAT_OES,                 LoadA16FToRGBA16F                    );
 
     // From GL_EXT_texture_storage
-    insertLoadFunction(&map, GL_ALPHA8_EXT,             GL_UNSIGNED_BYTE,              loadToNative<GLubyte, 1>             );
-    insertLoadFunction(&map, GL_LUMINANCE8_EXT,         GL_UNSIGNED_BYTE,              loadLuminanceDataToBGRA              );
-    insertLoadFunction(&map, GL_LUMINANCE8_ALPHA8_EXT,  GL_UNSIGNED_BYTE,              loadLuminanceAlphaDataToBGRA         );
-    insertLoadFunction(&map, GL_ALPHA32F_EXT,           GL_FLOAT,                      loadAlphaFloatDataToRGBA             );
-    insertLoadFunction(&map, GL_LUMINANCE32F_EXT,       GL_FLOAT,                      loadLuminanceFloatDataToRGBA         );
-    insertLoadFunction(&map, GL_LUMINANCE_ALPHA32F_EXT, GL_FLOAT,                      loadLuminanceAlphaFloatDataToRGBA    );
-    insertLoadFunction(&map, GL_ALPHA16F_EXT,           GL_HALF_FLOAT,                 loadAlphaHalfFloatDataToRGBA         );
-    insertLoadFunction(&map, GL_ALPHA16F_EXT,           GL_HALF_FLOAT_OES,             loadAlphaHalfFloatDataToRGBA         );
-    insertLoadFunction(&map, GL_LUMINANCE16F_EXT,       GL_HALF_FLOAT,                 loadLuminanceHalfFloatDataToRGBA     );
-    insertLoadFunction(&map, GL_LUMINANCE16F_EXT,       GL_HALF_FLOAT_OES,             loadLuminanceHalfFloatDataToRGBA     );
-    insertLoadFunction(&map, GL_LUMINANCE_ALPHA16F_EXT, GL_HALF_FLOAT,                 loadLuminanceAlphaHalfFloatDataToRGBA);
-    insertLoadFunction(&map, GL_LUMINANCE_ALPHA16F_EXT, GL_HALF_FLOAT_OES,             loadLuminanceAlphaHalfFloatDataToRGBA);
+    insertLoadFunction(&map, GL_ALPHA8_EXT,             GL_UNSIGNED_BYTE,              LoadToNative<GLubyte, 1>             );
+    insertLoadFunction(&map, GL_LUMINANCE8_EXT,         GL_UNSIGNED_BYTE,              LoadL8ToRGBA8                        );
+    insertLoadFunction(&map, GL_LUMINANCE8_ALPHA8_EXT,  GL_UNSIGNED_BYTE,              LoadLA8ToRGBA8                       );
+    insertLoadFunction(&map, GL_ALPHA32F_EXT,           GL_FLOAT,                      LoadA32FToRGBA32F                    );
+    insertLoadFunction(&map, GL_LUMINANCE32F_EXT,       GL_FLOAT,                      LoadL32FToRGBA32F                    );
+    insertLoadFunction(&map, GL_LUMINANCE_ALPHA32F_EXT, GL_FLOAT,                      LoadLA32FToRGBA32F                   );
+    insertLoadFunction(&map, GL_ALPHA16F_EXT,           GL_HALF_FLOAT,                 LoadA16FToRGBA16F                    );
+    insertLoadFunction(&map, GL_ALPHA16F_EXT,           GL_HALF_FLOAT_OES,             LoadA16FToRGBA16F                    );
+    insertLoadFunction(&map, GL_LUMINANCE16F_EXT,       GL_HALF_FLOAT,                 LoadL16FToRGBA16F                    );
+    insertLoadFunction(&map, GL_LUMINANCE16F_EXT,       GL_HALF_FLOAT_OES,             LoadL16FToRGBA16F                    );
+    insertLoadFunction(&map, GL_LUMINANCE_ALPHA16F_EXT, GL_HALF_FLOAT,                 LoadLA16FToRGBA16F                   );
+    insertLoadFunction(&map, GL_LUMINANCE_ALPHA16F_EXT, GL_HALF_FLOAT_OES,             LoadLA16FToRGBA16F                   );
 
     // From GL_ANGLE_depth_texture
-    insertLoadFunction(&map, GL_DEPTH_COMPONENT32_OES,  GL_UNSIGNED_INT,               loadUintDataToUint24X8               );
+    insertLoadFunction(&map, GL_DEPTH_COMPONENT32_OES,  GL_UNSIGNED_INT,               LoadR32ToR24G8                       );
 
     // From GL_EXT_texture_format_BGRA8888
-    insertLoadFunction(&map, GL_BGRA8_EXT,              GL_UNSIGNED_BYTE,                  loadToNative<GLubyte, 4>         );
-    insertLoadFunction(&map, GL_BGRA4_ANGLEX,           GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT, loadRGBA4444DataToRGBA           );
-    insertLoadFunction(&map, GL_BGRA4_ANGLEX,           GL_UNSIGNED_BYTE,                  loadToNative<GLubyte, 4>         );
-    insertLoadFunction(&map, GL_BGR5_A1_ANGLEX,         GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT, loadRGBA5551DataToRGBA           );
-    insertLoadFunction(&map, GL_BGR5_A1_ANGLEX,         GL_UNSIGNED_BYTE,                  loadToNative<GLubyte, 4>         );
+    insertLoadFunction(&map, GL_BGRA8_EXT,              GL_UNSIGNED_BYTE,                  LoadToNative<GLubyte, 4>         );
+    insertLoadFunction(&map, GL_BGRA4_ANGLEX,           GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT, LoadRGBA4ToRGBA8                 );
+    insertLoadFunction(&map, GL_BGRA4_ANGLEX,           GL_UNSIGNED_BYTE,                  LoadToNative<GLubyte, 4>         );
+    insertLoadFunction(&map, GL_BGR5_A1_ANGLEX,         GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT, LoadRGB5A1ToRGBA8                );
+    insertLoadFunction(&map, GL_BGR5_A1_ANGLEX,         GL_UNSIGNED_BYTE,                  LoadToNative<GLubyte, 4>         );
 
     // Compressed formats
     // From ES 3.0.1 spec, table 3.16
@@ -348,14 +348,14 @@ D3D11LoadFunctionMap buildD3D11LoadFunctionMap()
     insertLoadFunction(&map, GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,          GL_UNSIGNED_BYTE, UnimplementedLoadFunction          );
 
     // From GL_EXT_texture_compression_dxt1
-    insertLoadFunction(&map, GL_COMPRESSED_RGB_S3TC_DXT1_EXT,              GL_UNSIGNED_BYTE, loadCompressedBlockDataToNative<4, 4,  8>);
-    insertLoadFunction(&map, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,             GL_UNSIGNED_BYTE, loadCompressedBlockDataToNative<4, 4,  8>);
+    insertLoadFunction(&map, GL_COMPRESSED_RGB_S3TC_DXT1_EXT,              GL_UNSIGNED_BYTE, LoadCompressedToNative<4, 4,  8>);
+    insertLoadFunction(&map, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,             GL_UNSIGNED_BYTE, LoadCompressedToNative<4, 4,  8>);
 
     // From GL_ANGLE_texture_compression_dxt3
-    insertLoadFunction(&map, GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE,           GL_UNSIGNED_BYTE, loadCompressedBlockDataToNative<4, 4, 16>);
+    insertLoadFunction(&map, GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE,           GL_UNSIGNED_BYTE, LoadCompressedToNative<4, 4, 16>);
 
     // From GL_ANGLE_texture_compression_dxt5
-    insertLoadFunction(&map, GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE,           GL_UNSIGNED_BYTE, loadCompressedBlockDataToNative<4, 4, 16>);
+    insertLoadFunction(&map, GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE,           GL_UNSIGNED_BYTE, LoadCompressedToNative<4, 4, 16>);
 
     return map;
 }
@@ -759,17 +759,17 @@ static InternalFormatInitializerMap BuildInternalFormatInitializerMap()
 {
     InternalFormatInitializerMap map;
 
-    map.insert(InternalFormatInitializerPair(GL_RGB8,    initialize4ComponentData<GLubyte,  0x00,       0x00,       0x00,       0xFF>          ));
-    map.insert(InternalFormatInitializerPair(GL_RGB565,  initialize4ComponentData<GLubyte,  0x00,       0x00,       0x00,       0xFF>          ));
-    map.insert(InternalFormatInitializerPair(GL_SRGB8,   initialize4ComponentData<GLubyte,  0x00,       0x00,       0x00,       0xFF>          ));
-    map.insert(InternalFormatInitializerPair(GL_RGB16F,  initialize4ComponentData<GLhalf,   0x0000,     0x0000,     0x0000,     gl::Float16One>));
-    map.insert(InternalFormatInitializerPair(GL_RGB32F,  initialize4ComponentData<GLfloat,  0x00000000, 0x00000000, 0x00000000, gl::Float32One>));
-    map.insert(InternalFormatInitializerPair(GL_RGB8UI,  initialize4ComponentData<GLubyte,  0x00,       0x00,       0x00,       0x01>          ));
-    map.insert(InternalFormatInitializerPair(GL_RGB8I,   initialize4ComponentData<GLbyte,   0x00,       0x00,       0x00,       0x01>          ));
-    map.insert(InternalFormatInitializerPair(GL_RGB16UI, initialize4ComponentData<GLushort, 0x0000,     0x0000,     0x0000,     0x0001>        ));
-    map.insert(InternalFormatInitializerPair(GL_RGB16I,  initialize4ComponentData<GLshort,  0x0000,     0x0000,     0x0000,     0x0001>        ));
-    map.insert(InternalFormatInitializerPair(GL_RGB32UI, initialize4ComponentData<GLuint,   0x00000000, 0x00000000, 0x00000000, 0x00000001>    ));
-    map.insert(InternalFormatInitializerPair(GL_RGB32I,  initialize4ComponentData<GLint,    0x00000000, 0x00000000, 0x00000000, 0x00000001>    ));
+    map.insert(InternalFormatInitializerPair(GL_RGB8,    Initialize4ComponentData<GLubyte,  0x00,       0x00,       0x00,       0xFF>          ));
+    map.insert(InternalFormatInitializerPair(GL_RGB565,  Initialize4ComponentData<GLubyte,  0x00,       0x00,       0x00,       0xFF>          ));
+    map.insert(InternalFormatInitializerPair(GL_SRGB8,   Initialize4ComponentData<GLubyte,  0x00,       0x00,       0x00,       0xFF>          ));
+    map.insert(InternalFormatInitializerPair(GL_RGB16F,  Initialize4ComponentData<GLhalf,   0x0000,     0x0000,     0x0000,     gl::Float16One>));
+    map.insert(InternalFormatInitializerPair(GL_RGB32F,  Initialize4ComponentData<GLfloat,  0x00000000, 0x00000000, 0x00000000, gl::Float32One>));
+    map.insert(InternalFormatInitializerPair(GL_RGB8UI,  Initialize4ComponentData<GLubyte,  0x00,       0x00,       0x00,       0x01>          ));
+    map.insert(InternalFormatInitializerPair(GL_RGB8I,   Initialize4ComponentData<GLbyte,   0x00,       0x00,       0x00,       0x01>          ));
+    map.insert(InternalFormatInitializerPair(GL_RGB16UI, Initialize4ComponentData<GLushort, 0x0000,     0x0000,     0x0000,     0x0001>        ));
+    map.insert(InternalFormatInitializerPair(GL_RGB16I,  Initialize4ComponentData<GLshort,  0x0000,     0x0000,     0x0000,     0x0001>        ));
+    map.insert(InternalFormatInitializerPair(GL_RGB32UI, Initialize4ComponentData<GLuint,   0x00000000, 0x00000000, 0x00000000, 0x00000001>    ));
+    map.insert(InternalFormatInitializerPair(GL_RGB32I,  Initialize4ComponentData<GLint,    0x00000000, 0x00000000, 0x00000000, 0x00000001>    ));
 
     return map;
 }

src/libGLESv2/renderer/d3d/d3d9/Image9.cpp

@@ -208,7 +208,7 @@ void Image9::createSurface()
             result = newSurface->LockRect(&lockedRect, &entireRect, 0);
             ASSERT(SUCCEEDED(result));
 
-            initializeFunc(mWidth, mHeight, 1, lockedRect.pBits, lockedRect.Pitch, 0);
+            initializeFunc(mWidth, mHeight, 1, reinterpret_cast<uint8_t*>(lockedRect.pBits), lockedRect.Pitch, 0);
 
             result = newSurface->UnlockRect();
             ASSERT(SUCCEEDED(result));
@@ -405,7 +405,9 @@ void Image9::loadData(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width
         return;
     }
 
-    loadFunction(width, height, depth, input, inputRowPitch, 0, locked.pBits, locked.Pitch, 0);
+    loadFunction(width, height, depth,
+                 reinterpret_cast<const uint8_t*>(input), inputRowPitch, 0,
+                 reinterpret_cast<uint8_t*>(locked.pBits), locked.Pitch, 0);
 
     unlock();
 }
@@ -438,8 +440,9 @@ void Image9::loadCompressedData(GLint xoffset, GLint yoffset, GLint zoffset, GLs
         return;
     }
 
-    loadFunction(width, height, depth, input, inputRowPitch, inputDepthPitch,
-                 locked.pBits, locked.Pitch, 0);
+    loadFunction(width, height, depth,
+                 reinterpret_cast<const uint8_t*>(input), inputRowPitch, inputDepthPitch,
+                 reinterpret_cast<uint8_t*>(locked.pBits), locked.Pitch, 0);
 
     unlock();
 }

src/libGLESv2/renderer/d3d/d3d9/formatutils9.cpp

@@ -26,9 +26,9 @@ namespace rx
 typedef bool(*FallbackPredicateFunction)();
 
 template <FallbackPredicateFunction pred, LoadImageFunction prefered, LoadImageFunction fallback>
-static void FallbackLoad(int width, int height, int depth,
-                         const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                         void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+static void FallbackLoad(size_t width, size_t height, size_t depth,
+                         const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                         uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
     if (pred())
     {
@@ -40,9 +40,9 @@ static void FallbackLoad(int width, int height, int depth,
     }
 }
 
-static void UnreachableLoad(int width, int height, int depth,
-                            const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                            void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+static void UnreachableLoad(size_t width, size_t height, size_t depth,
+                            const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                            uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
     UNREACHABLE();
 }
@@ -80,45 +80,45 @@ static D3D9FormatMap BuildD3D9FormatMap()
     map.insert(D3D9FormatPair(GL_DEPTH24_STENCIL8_OES,             D3D9FormatInfo(D3DFMT_INTZ,          D3DFMT_D24S8,          UnreachableLoad                          )));
     map.insert(D3D9FormatPair(GL_STENCIL_INDEX8,                   D3D9FormatInfo(D3DFMT_UNKNOWN,       D3DFMT_D24S8,          UnreachableLoad                          ))); // TODO: What's the texture format?
 
-    map.insert(D3D9FormatPair(GL_RGBA32F_EXT,                      D3D9FormatInfo(D3DFMT_A32B32G32R32F, D3DFMT_A32B32G32R32F,  loadToNative<GLfloat, 4>                 )));
-    map.insert(D3D9FormatPair(GL_RGB32F_EXT,                       D3D9FormatInfo(D3DFMT_A32B32G32R32F, D3DFMT_A32B32G32R32F,  loadToNative3To4<GLfloat, gl::Float32One>)));
-    map.insert(D3D9FormatPair(GL_RG32F_EXT,                        D3D9FormatInfo(D3DFMT_G32R32F,       D3DFMT_G32R32F,        loadToNative<GLfloat, 2>                 )));
-    map.insert(D3D9FormatPair(GL_R32F_EXT,                         D3D9FormatInfo(D3DFMT_R32F,          D3DFMT_R32F,           loadToNative<GLfloat, 1>                 )));
-    map.insert(D3D9FormatPair(GL_ALPHA32F_EXT,                     D3D9FormatInfo(D3DFMT_A32B32G32R32F, D3DFMT_UNKNOWN,        loadAlphaFloatDataToRGBA                 )));
-    map.insert(D3D9FormatPair(GL_LUMINANCE32F_EXT,                 D3D9FormatInfo(D3DFMT_A32B32G32R32F, D3DFMT_UNKNOWN,        loadLuminanceFloatDataToRGBA             )));
-    map.insert(D3D9FormatPair(GL_LUMINANCE_ALPHA32F_EXT,           D3D9FormatInfo(D3DFMT_A32B32G32R32F, D3DFMT_UNKNOWN,        loadLuminanceAlphaFloatDataToRGBA        )));
-
-    map.insert(D3D9FormatPair(GL_RGBA16F_EXT,                      D3D9FormatInfo(D3DFMT_A16B16G16R16F, D3DFMT_A16B16G16R16F,  loadToNative<GLhalf, 4>                  )));
-    map.insert(D3D9FormatPair(GL_RGB16F_EXT,                       D3D9FormatInfo(D3DFMT_A16B16G16R16F, D3DFMT_A16B16G16R16F,  loadToNative3To4<GLhalf, gl::Float16One> )));
-    map.insert(D3D9FormatPair(GL_RG16F_EXT,                        D3D9FormatInfo(D3DFMT_G16R16F,       D3DFMT_G16R16F,        loadToNative<GLhalf, 2>                  )));
-    map.insert(D3D9FormatPair(GL_R16F_EXT,                         D3D9FormatInfo(D3DFMT_R16F,          D3DFMT_R16F,           loadToNative<GLhalf, 1>                  )));
-    map.insert(D3D9FormatPair(GL_ALPHA16F_EXT,                     D3D9FormatInfo(D3DFMT_A16B16G16R16F, D3DFMT_UNKNOWN,        loadAlphaHalfFloatDataToRGBA             )));
-    map.insert(D3D9FormatPair(GL_LUMINANCE16F_EXT,                 D3D9FormatInfo(D3DFMT_A16B16G16R16F, D3DFMT_UNKNOWN,        loadLuminanceHalfFloatDataToRGBA         )));
-    map.insert(D3D9FormatPair(GL_LUMINANCE_ALPHA16F_EXT,           D3D9FormatInfo(D3DFMT_A16B16G16R16F, D3DFMT_UNKNOWN,        loadLuminanceAlphaHalfFloatDataToRGBA    )));
-
-    map.insert(D3D9FormatPair(GL_ALPHA8_EXT,                       D3D9FormatInfo(D3DFMT_A8R8G8B8,      D3DFMT_A8R8G8B8,       FallbackLoad<gl::supportsSSE2, loadAlphaDataToBGRASSE2, loadAlphaDataToBGRA>)));
-
-    map.insert(D3D9FormatPair(GL_RGB8_OES,                         D3D9FormatInfo(D3DFMT_X8R8G8B8,      D3DFMT_X8R8G8B8,       loadRGBUByteDataToBGRX                    )));
-    map.insert(D3D9FormatPair(GL_RGB565,                           D3D9FormatInfo(D3DFMT_X8R8G8B8,      D3DFMT_X8R8G8B8,       loadRGB565DataToBGRA                      )));
-    map.insert(D3D9FormatPair(GL_RGBA8_OES,                        D3D9FormatInfo(D3DFMT_A8R8G8B8,      D3DFMT_A8R8G8B8,       FallbackLoad<gl::supportsSSE2, loadRGBAUByteDataToBGRASSE2, loadRGBAUByteDataToBGRA>)));
-    map.insert(D3D9FormatPair(GL_RGBA4,                            D3D9FormatInfo(D3DFMT_A8R8G8B8,      D3DFMT_A8R8G8B8,       loadRGBA4444DataToBGRA                    )));
-    map.insert(D3D9FormatPair(GL_RGB5_A1,                          D3D9FormatInfo(D3DFMT_A8R8G8B8,      D3DFMT_A8R8G8B8,       loadRGBA5551DataToBGRA                    )));
-    map.insert(D3D9FormatPair(GL_R8_EXT,                           D3D9FormatInfo(D3DFMT_X8R8G8B8,      D3DFMT_X8R8G8B8,       loadRUByteDataToBGRX                      )));
-    map.insert(D3D9FormatPair(GL_RG8_EXT,                          D3D9FormatInfo(D3DFMT_X8R8G8B8,      D3DFMT_X8R8G8B8,       loadRGUByteDataToBGRX                     )));
-
-    map.insert(D3D9FormatPair(GL_BGRA8_EXT,                        D3D9FormatInfo(D3DFMT_A8R8G8B8,      D3DFMT_A8R8G8B8,       loadToNative<GLubyte, 4>                  )));
-    map.insert(D3D9FormatPair(GL_BGRA4_ANGLEX,                     D3D9FormatInfo(D3DFMT_A8R8G8B8,      D3DFMT_A8R8G8B8,       loadRGBA4444DataToRGBA                    )));
-    map.insert(D3D9FormatPair(GL_BGR5_A1_ANGLEX,                   D3D9FormatInfo(D3DFMT_A8R8G8B8,      D3DFMT_A8R8G8B8,       loadRGBA5551DataToRGBA                    )));
-
-    map.insert(D3D9FormatPair(GL_COMPRESSED_RGB_S3TC_DXT1_EXT,     D3D9FormatInfo(D3DFMT_DXT1,          D3DFMT_UNKNOWN,        loadCompressedBlockDataToNative<4, 4,  8> )));
-    map.insert(D3D9FormatPair(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,    D3D9FormatInfo(D3DFMT_DXT1,          D3DFMT_UNKNOWN,        loadCompressedBlockDataToNative<4, 4,  8> )));
-    map.insert(D3D9FormatPair(GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE,  D3D9FormatInfo(D3DFMT_DXT3,          D3DFMT_UNKNOWN,        loadCompressedBlockDataToNative<4, 4, 16> )));
-    map.insert(D3D9FormatPair(GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE,  D3D9FormatInfo(D3DFMT_DXT5,          D3DFMT_UNKNOWN,        loadCompressedBlockDataToNative<4, 4, 16> )));
+    map.insert(D3D9FormatPair(GL_RGBA32F_EXT,                      D3D9FormatInfo(D3DFMT_A32B32G32R32F, D3DFMT_A32B32G32R32F,  LoadToNative<GLfloat, 4>                 )));
+    map.insert(D3D9FormatPair(GL_RGB32F_EXT,                       D3D9FormatInfo(D3DFMT_A32B32G32R32F, D3DFMT_A32B32G32R32F,  LoadToNative3To4<GLfloat, gl::Float32One>)));
+    map.insert(D3D9FormatPair(GL_RG32F_EXT,                        D3D9FormatInfo(D3DFMT_G32R32F,       D3DFMT_G32R32F,        LoadToNative<GLfloat, 2>                 )));
+    map.insert(D3D9FormatPair(GL_R32F_EXT,                         D3D9FormatInfo(D3DFMT_R32F,          D3DFMT_R32F,           LoadToNative<GLfloat, 1>                 )));
+    map.insert(D3D9FormatPair(GL_ALPHA32F_EXT,                     D3D9FormatInfo(D3DFMT_A32B32G32R32F, D3DFMT_UNKNOWN,        LoadA32FToRGBA32F                        )));
+    map.insert(D3D9FormatPair(GL_LUMINANCE32F_EXT,                 D3D9FormatInfo(D3DFMT_A32B32G32R32F, D3DFMT_UNKNOWN,        LoadL32FToRGBA32F                        )));
+    map.insert(D3D9FormatPair(GL_LUMINANCE_ALPHA32F_EXT,           D3D9FormatInfo(D3DFMT_A32B32G32R32F, D3DFMT_UNKNOWN,        LoadLA32FToRGBA32F                       )));
+
+    map.insert(D3D9FormatPair(GL_RGBA16F_EXT,                      D3D9FormatInfo(D3DFMT_A16B16G16R16F, D3DFMT_A16B16G16R16F,  LoadToNative<GLhalf, 4>                  )));
+    map.insert(D3D9FormatPair(GL_RGB16F_EXT,                       D3D9FormatInfo(D3DFMT_A16B16G16R16F, D3DFMT_A16B16G16R16F,  LoadToNative3To4<GLhalf, gl::Float16One> )));
+    map.insert(D3D9FormatPair(GL_RG16F_EXT,                        D3D9FormatInfo(D3DFMT_G16R16F,       D3DFMT_G16R16F,        LoadToNative<GLhalf, 2>                  )));
+    map.insert(D3D9FormatPair(GL_R16F_EXT,                         D3D9FormatInfo(D3DFMT_R16F,          D3DFMT_R16F,           LoadToNative<GLhalf, 1>                  )));
+    map.insert(D3D9FormatPair(GL_ALPHA16F_EXT,                     D3D9FormatInfo(D3DFMT_A16B16G16R16F, D3DFMT_UNKNOWN,        LoadA16FToRGBA16F                        )));
+    map.insert(D3D9FormatPair(GL_LUMINANCE16F_EXT,                 D3D9FormatInfo(D3DFMT_A16B16G16R16F, D3DFMT_UNKNOWN,        LoadL16FToRGBA16F                        )));
+    map.insert(D3D9FormatPair(GL_LUMINANCE_ALPHA16F_EXT,           D3D9FormatInfo(D3DFMT_A16B16G16R16F, D3DFMT_UNKNOWN,        LoadLA16FToRGBA16F                       )));
+
+    map.insert(D3D9FormatPair(GL_ALPHA8_EXT,                       D3D9FormatInfo(D3DFMT_A8R8G8B8,      D3DFMT_A8R8G8B8,       FallbackLoad<gl::supportsSSE2, LoadA8ToBGRA8_SSE2, LoadA8ToBGRA8>)));
+
+    map.insert(D3D9FormatPair(GL_RGB8_OES,                         D3D9FormatInfo(D3DFMT_X8R8G8B8,      D3DFMT_X8R8G8B8,       LoadRGB8ToBGRX8                          )));
+    map.insert(D3D9FormatPair(GL_RGB565,                           D3D9FormatInfo(D3DFMT_X8R8G8B8,      D3DFMT_X8R8G8B8,       LoadR5G6B5ToBGRA8                        )));
+    map.insert(D3D9FormatPair(GL_RGBA8_OES,                        D3D9FormatInfo(D3DFMT_A8R8G8B8,      D3DFMT_A8R8G8B8,       FallbackLoad<gl::supportsSSE2, LoadRGBA8ToBGRA8_SSE2, LoadRGBA8ToBGRA8>)));
+    map.insert(D3D9FormatPair(GL_RGBA4,                            D3D9FormatInfo(D3DFMT_A8R8G8B8,      D3DFMT_A8R8G8B8,       LoadRGBA4ToBGRA8                         )));
+    map.insert(D3D9FormatPair(GL_RGB5_A1,                          D3D9FormatInfo(D3DFMT_A8R8G8B8,      D3DFMT_A8R8G8B8,       LoadRGB5A1ToBGRA8                        )));
+    map.insert(D3D9FormatPair(GL_R8_EXT,                           D3D9FormatInfo(D3DFMT_X8R8G8B8,      D3DFMT_X8R8G8B8,       LoadR8ToBGRX8                            )));
+    map.insert(D3D9FormatPair(GL_RG8_EXT,                          D3D9FormatInfo(D3DFMT_X8R8G8B8,      D3DFMT_X8R8G8B8,       LoadRG8ToBGRX8                           )));
+
+    map.insert(D3D9FormatPair(GL_BGRA8_EXT,                        D3D9FormatInfo(D3DFMT_A8R8G8B8,      D3DFMT_A8R8G8B8,       LoadToNative<GLubyte, 4>                 )));
+    map.insert(D3D9FormatPair(GL_BGRA4_ANGLEX,                     D3D9FormatInfo(D3DFMT_A8R8G8B8,      D3DFMT_A8R8G8B8,       LoadBGRA4ToBGRA8                         )));
+    map.insert(D3D9FormatPair(GL_BGR5_A1_ANGLEX,                   D3D9FormatInfo(D3DFMT_A8R8G8B8,      D3DFMT_A8R8G8B8,       LoadBGR5A1ToBGRA8                        )));
+
+    map.insert(D3D9FormatPair(GL_COMPRESSED_RGB_S3TC_DXT1_EXT,     D3D9FormatInfo(D3DFMT_DXT1,          D3DFMT_UNKNOWN,        LoadCompressedToNative<4, 4,  8>         )));
+    map.insert(D3D9FormatPair(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,    D3D9FormatInfo(D3DFMT_DXT1,          D3DFMT_UNKNOWN,        LoadCompressedToNative<4, 4,  8>         )));
+    map.insert(D3D9FormatPair(GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE,  D3D9FormatInfo(D3DFMT_DXT3,          D3DFMT_UNKNOWN,        LoadCompressedToNative<4, 4, 16>         )));
+    map.insert(D3D9FormatPair(GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE,  D3D9FormatInfo(D3DFMT_DXT5,          D3DFMT_UNKNOWN,        LoadCompressedToNative<4, 4, 16>         )));
 
     // These formats require checking if the renderer supports D3DFMT_L8 or D3DFMT_A8L8 and
     // then changing the format and loading function appropriately.
-    map.insert(D3D9FormatPair(GL_LUMINANCE8_EXT,                   D3D9FormatInfo(D3DFMT_L8,            D3DFMT_UNKNOWN,        loadToNative<GLubyte, 1>                  )));
-    map.insert(D3D9FormatPair(GL_LUMINANCE8_ALPHA8_EXT,            D3D9FormatInfo(D3DFMT_A8L8,          D3DFMT_UNKNOWN,        loadToNative<GLubyte, 2>                  )));
+    map.insert(D3D9FormatPair(GL_LUMINANCE8_EXT,                   D3D9FormatInfo(D3DFMT_L8,            D3DFMT_UNKNOWN,        LoadToNative<GLubyte, 1>                 )));
+    map.insert(D3D9FormatPair(GL_LUMINANCE8_ALPHA8_EXT,            D3D9FormatInfo(D3DFMT_A8L8,          D3DFMT_UNKNOWN,        LoadToNative<GLubyte, 2>                 )));
 
     return map;
 }
@@ -275,8 +275,8 @@ static InternalFormatInitialzerMap BuildInternalFormatInitialzerMap()
 {
     InternalFormatInitialzerMap map;
 
-    map.insert(InternalFormatInitialzerPair(GL_RGB16F,  initialize4ComponentData<GLhalf,   0x0000,     0x0000,     0x0000,     gl::Float16One>));
-    map.insert(InternalFormatInitialzerPair(GL_RGB32F,  initialize4ComponentData<GLfloat,  0x00000000, 0x00000000, 0x00000000, gl::Float32One>));
+    map.insert(InternalFormatInitialzerPair(GL_RGB16F,  Initialize4ComponentData<GLhalf,   0x0000,     0x0000,     0x0000,     gl::Float16One>));
+    map.insert(InternalFormatInitialzerPair(GL_RGB32F,  Initialize4ComponentData<GLfloat,  0x00000000, 0x00000000, 0x00000000, gl::Float32One>));
 
     return map;
 }

src/libGLESv2/renderer/loadimage.cpp

 #include "precompiled.h"
 //
-// Copyright (c) 0013 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2013-2014 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
@@ -12,86 +12,64 @@
 namespace rx
 {
 
-void loadAlphaDataToBGRA(int width, int height, int depth,
-                         const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                         void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadA8ToRGBA8(size_t width, size_t height, size_t depth,
+                   const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                   uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned char *source = NULL;
-    unsigned char *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<unsigned char>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned char>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
+            const uint8_t *source = OffsetDataPointer<uint8_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint32_t *dest = OffsetDataPointer<uint32_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
-                dest[4 * x + 0] = 0;
-                dest[4 * x + 1] = 0;
-                dest[4 * x + 2] = 0;
-                dest[4 * x + 3] = source[x];
+                dest[x] = static_cast<uint32_t>(source[x]) << 24;
             }
         }
     }
 }
 
-void loadAlphaDataToNative(int width, int height, int depth,
-                           const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                           void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadA8ToBGRA8(size_t width, size_t height, size_t depth,
+                   const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                   uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned char *source = NULL;
-    unsigned char *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
-    {
-        for (int y = 0; y < height; y++)
-        {
-            source = offsetDataPointer<unsigned char>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned char>(output, y, z, outputRowPitch, outputDepthPitch);
-            memcpy(dest, source, width);
-        }
-    }
+    // Same as loading to RGBA
+    LoadA8ToRGBA8(width, height, depth, input, inputRowPitch, inputDepthPitch, output, outputRowPitch, outputDepthPitch);
 }
 
-void loadAlphaFloatDataToRGBA(int width, int height, int depth,
-                              const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                              void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadA32FToRGBA32F(size_t width, size_t height, size_t depth,
+                       const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                       uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const float *source = NULL;
-    float *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<float>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<float>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
+            const float *source = OffsetDataPointer<float>(input, y, z, inputRowPitch, inputDepthPitch);
+            float *dest = OffsetDataPointer<float>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
-                dest[4 * x + 0] = 0;
-                dest[4 * x + 1] = 0;
-                dest[4 * x + 2] = 0;
+                dest[4 * x + 0] = 0.0f;
+                dest[4 * x + 1] = 0.0f;
+                dest[4 * x + 2] = 0.0f;
                 dest[4 * x + 3] = source[x];
             }
         }
     }
 }
 
-void loadAlphaHalfFloatDataToRGBA(int width, int height, int depth,
-                                  const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                  void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadA16FToRGBA16F(size_t width, size_t height, size_t depth,
+                       const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                       uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned short *source = NULL;
-    unsigned short *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<unsigned short>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned short>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
+            const uint16_t *source = OffsetDataPointer<uint16_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint16_t *dest = OffsetDataPointer<uint16_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
                 dest[4 * x + 0] = 0;
                 dest[4 * x + 1] = 0;
@@ -102,38 +80,17 @@ void loadAlphaHalfFloatDataToRGBA(int width, int height, int depth,
     }
 }
 
-void loadLuminanceDataToNative(int width, int height, int depth,
-                               const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                               void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadL8ToRGBA8(size_t width, size_t height, size_t depth,
+                   const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                   uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned char *source = NULL;
-    unsigned char *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<unsigned char>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned char>(output, y, z, outputRowPitch, outputDepthPitch);
-            memcpy(dest, source, width);
-        }
-    }
-}
-
-void loadLuminanceDataToBGRA(int width, int height, int depth,
-                             const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                             void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
-{
-    const unsigned char *source = NULL;
-    unsigned char *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
-    {
-        for (int y = 0; y < height; y++)
-        {
-            source = offsetDataPointer<unsigned char>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned char>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
+            const uint8_t *source = OffsetDataPointer<uint8_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint8_t *dest = OffsetDataPointer<uint8_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
                 dest[4 * x + 0] = source[x];
                 dest[4 * x + 1] = source[x];
@@ -144,20 +101,25 @@ void loadLuminanceDataToBGRA(int width, int height, int depth,
     }
 }
 
-void loadLuminanceFloatDataToRGBA(int width, int height, int depth,
-                                  const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                  void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadL8ToBGRA8(size_t width, size_t height, size_t depth,
+                   const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                   uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const float *source = NULL;
-    float *dest = NULL;
+    // Same as loading to RGBA
+    LoadL8ToRGBA8(width, height, depth, input, inputRowPitch, inputDepthPitch, output, outputRowPitch, outputDepthPitch);
+}
 
-    for (int z = 0; z < depth; z++)
+void LoadL32FToRGBA32F(size_t width, size_t height, size_t depth,
+                       const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                       uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
+{
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<float>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<float>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
+            const float *source = OffsetDataPointer<float>(input, y, z, inputRowPitch, inputDepthPitch);
+            float *dest = OffsetDataPointer<float>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
                 dest[4 * x + 0] = source[x];
                 dest[4 * x + 1] = source[x];
@@ -168,43 +130,17 @@ void loadLuminanceFloatDataToRGBA(int width, int height, int depth,
     }
 }
 
-void loadLuminanceFloatDataToRGB(int width, int height, int depth,
-                                 const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                 void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
-{
-    const float *source = NULL;
-    float *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
-    {
-        for (int y = 0; y < height; y++)
-        {
-            source = offsetDataPointer<float>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<float>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
-            {
-                dest[3 * x + 0] = source[x];
-                dest[3 * x + 1] = source[x];
-                dest[3 * x + 2] = source[x];
-            }
-        }
-    }
-}
-
-void loadLuminanceHalfFloatDataToRGBA(int width, int height, int depth,
-                                      const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                      void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadL16FToRGBA16F(size_t width, size_t height, size_t depth,
+                       const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                       uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned short *source = NULL;
-    unsigned short *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<unsigned short>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned short>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
+            const uint16_t *source = OffsetDataPointer<uint16_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint16_t *dest = OffsetDataPointer<uint16_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
                 dest[4 * x + 0] = source[x];
                 dest[4 * x + 1] = source[x];
@@ -215,112 +151,88 @@ void loadLuminanceHalfFloatDataToRGBA(int width, int height, int depth,
     }
 }
 
-void loadLuminanceAlphaDataToNative(int width, int height, int depth,
-                                    const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                    void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadLA8ToRGBA8(size_t width, size_t height, size_t depth,
+                    const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                    uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned char *source = NULL;
-    unsigned char *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<unsigned char>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned char>(output, y, z, outputRowPitch, outputDepthPitch);
-
-            memcpy(dest, source, width * 2);
-        }
-    }
-}
-
-void loadLuminanceAlphaDataToBGRA(int width, int height, int depth,
-                                  const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                  void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
-{
-    const unsigned char *source = NULL;
-    unsigned char *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
-    {
-        for (int y = 0; y < height; y++)
-        {
-            source = offsetDataPointer<unsigned char>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned char>(output, y, z, outputRowPitch, outputDepthPitch);
-
-            for (int x = 0; x < width; x++)
+            const uint8_t *source = OffsetDataPointer<uint8_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint8_t *dest = OffsetDataPointer<uint8_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
-                dest[4 * x + 0] = source[2*x+0];
-                dest[4 * x + 1] = source[2*x+0];
-                dest[4 * x + 2] = source[2*x+0];
-                dest[4 * x + 3] = source[2*x+1];
+                dest[4 * x + 0] = source[2 * x + 0];
+                dest[4 * x + 1] = source[2 * x + 0];
+                dest[4 * x + 2] = source[2 * x + 0];
+                dest[4 * x + 3] = source[2 * x + 1];
             }
         }
     }
 }
 
-void loadLuminanceAlphaFloatDataToRGBA(int width, int height, int depth,
-                                       const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                       void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadLA8ToBGRA8(size_t width, size_t height, size_t depth,
+                    const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                    uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const float *source = NULL;
-    float *dest = NULL;
+    // Same as loading to RGBA
+    LoadLA8ToRGBA8(width, height, depth, input, inputRowPitch, inputDepthPitch, output, outputRowPitch, outputDepthPitch);
+}
 
-    for (int z = 0; z < depth; z++)
+void LoadLA32FToRGBA32F(size_t width, size_t height, size_t depth,
+                        const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                        uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
+{
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<float>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<float>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
+            const float *source = OffsetDataPointer<float>(input, y, z, inputRowPitch, inputDepthPitch);
+            float *dest = OffsetDataPointer<float>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
-                dest[4 * x + 0] = source[2*x+0];
-                dest[4 * x + 1] = source[2*x+0];
-                dest[4 * x + 2] = source[2*x+0];
-                dest[4 * x + 3] = source[2*x+1];
+                dest[4 * x + 0] = source[2 * x + 0];
+                dest[4 * x + 1] = source[2 * x + 0];
+                dest[4 * x + 2] = source[2 * x + 0];
+                dest[4 * x + 3] = source[2 * x + 1];
             }
         }
     }
 }
 
-void loadLuminanceAlphaHalfFloatDataToRGBA(int width, int height, int depth,
-                                           const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                           void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadLA16FToRGBA16F(size_t width, size_t height, size_t depth,
+                        const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                        uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned short *source = NULL;
-    unsigned short *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<unsigned short>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned short>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
+            const uint16_t *source = OffsetDataPointer<uint16_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint16_t *dest = OffsetDataPointer<uint16_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
-                dest[4 * x + 0] = source[2*x+0];
-                dest[4 * x + 1] = source[2*x+0];
-                dest[4 * x + 2] = source[2*x+0];
-                dest[4 * x + 3] = source[2*x+1];
+                dest[4 * x + 0] = source[2 * x + 0];
+                dest[4 * x + 1] = source[2 * x + 0];
+                dest[4 * x + 2] = source[2 * x + 0];
+                dest[4 * x + 3] = source[2 * x + 1];
             }
         }
     }
 }
 
-void loadRGBUByteDataToBGRX(int width, int height, int depth,
-                            const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                            void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadRGB8ToBGRX8(size_t width, size_t height, size_t depth,
+                     const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                     uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned char *source = NULL;
-    unsigned char *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<unsigned char>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned char>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
+            const uint8_t *source = OffsetDataPointer<uint8_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint8_t *dest = OffsetDataPointer<uint8_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
                 dest[4 * x + 0] = source[x * 3 + 2];
                 dest[4 * x + 1] = source[x * 3 + 1];
@@ -331,20 +243,17 @@ void loadRGBUByteDataToBGRX(int width, int height, int depth,
     }
 }
 
-void loadRGUByteDataToBGRX(int width, int height, int depth,
-                           const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                           void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadRG8ToBGRX8(size_t width, size_t height, size_t depth,
+                    const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                    uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned char *source = NULL;
-    unsigned char *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<unsigned char>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned char>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
+            const uint8_t *source = OffsetDataPointer<uint8_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint8_t *dest = OffsetDataPointer<uint8_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
                 dest[4 * x + 0] = 0x00;
                 dest[4 * x + 1] = source[x * 2 + 1];
@@ -355,20 +264,17 @@ void loadRGUByteDataToBGRX(int width, int height, int depth,
     }
 }
 
-void loadRUByteDataToBGRX(int width, int height, int depth,
-                          const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                          void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadR8ToBGRX8(size_t width, size_t height, size_t depth,
+                   const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                   uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned char *source = NULL;
-    unsigned char *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<unsigned char>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned char>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
+            const uint8_t *source = OffsetDataPointer<uint8_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint8_t *dest = OffsetDataPointer<uint8_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
                 dest[4 * x + 0] = 0x00;
                 dest[4 * x + 1] = 0x00;
@@ -379,278 +285,148 @@ void loadRUByteDataToBGRX(int width, int height, int depth,
     }
 }
 
-void loadRGBUByteDataToRGBA(int width, int height, int depth,
-                            const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                            void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
-{
-    const unsigned char *source = NULL;
-    unsigned char *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
-    {
-        for (int y = 0; y < height; y++)
-        {
-            source = offsetDataPointer<unsigned char>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned char>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
-            {
-                dest[4 * x + 0] = source[x * 3 + 0];
-                dest[4 * x + 1] = source[x * 3 + 1];
-                dest[4 * x + 2] = source[x * 3 + 2];
-                dest[4 * x + 3] = 0xFF;
-            }
-        }
-    }
-}
-
-void loadRGBSByteDataToRGBA(int width, int height, int depth,
-                            const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                            void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
-{
-    const char *source = NULL;
-    char *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
-    {
-        for (int y = 0; y < height; y++)
-        {
-            source = offsetDataPointer<char>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<char>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
-            {
-                dest[4 * x + 0] = source[x * 3 + 0];
-                dest[4 * x + 1] = source[x * 3 + 1];
-                dest[4 * x + 2] = source[x * 3 + 2];
-                dest[4 * x + 3] = 0x7F;
-            }
-        }
-    }
-}
-
-void loadRGB565DataToBGRA(int width, int height, int depth,
-                          const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                          void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadR5G6B5ToBGRA8(size_t width, size_t height, size_t depth,
+                       const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                       uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned short *source = NULL;
-    unsigned char *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<unsigned short>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned char>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
+            const uint16_t *source = OffsetDataPointer<uint16_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint8_t *dest = OffsetDataPointer<uint8_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
-                unsigned short rgba = source[x];
-                dest[4 * x + 0] = ((rgba & 0x001F) << 3) | ((rgba & 0x001F) >> 2);
-                dest[4 * x + 1] = ((rgba & 0x07E0) >> 3) | ((rgba & 0x07E0) >> 9);
-                dest[4 * x + 2] = ((rgba & 0xF800) >> 8) | ((rgba & 0xF800) >> 13);
+                uint16_t rgb = source[x];
+                dest[4 * x + 0] = ((rgb & 0x001F) << 3) | ((rgb & 0x001F) >> 2);
+                dest[4 * x + 1] = ((rgb & 0x07E0) >> 3) | ((rgb & 0x07E0) >> 9);
+                dest[4 * x + 2] = ((rgb & 0xF800) >> 8) | ((rgb & 0xF800) >> 13);
                 dest[4 * x + 3] = 0xFF;
             }
         }
     }
 }
 
-void loadRGB565DataToRGBA(int width, int height, int depth,
-                          const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                          void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadR5G6B5ToRGBA8(size_t width, size_t height, size_t depth,
+                       const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                       uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned short *source = NULL;
-    unsigned char *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<unsigned short>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned char>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
+            const uint16_t *source = OffsetDataPointer<uint16_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint8_t *dest = OffsetDataPointer<uint8_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
-                unsigned short rgba = source[x];
-                dest[4 * x + 0] = ((rgba & 0xF800) >> 8) | ((rgba & 0xF800) >> 13);
-                dest[4 * x + 1] = ((rgba & 0x07E0) >> 3) | ((rgba & 0x07E0) >> 9);
-                dest[4 * x + 2] = ((rgba & 0x001F) << 3) | ((rgba & 0x001F) >> 2);
+                uint16_t rgb = source[x];
+                dest[4 * x + 0] = ((rgb & 0xF800) >> 8) | ((rgb & 0xF800) >> 13);
+                dest[4 * x + 1] = ((rgb & 0x07E0) >> 3) | ((rgb & 0x07E0) >> 9);
+                dest[4 * x + 2] = ((rgb & 0x001F) << 3) | ((rgb & 0x001F) >> 2);
                 dest[4 * x + 3] = 0xFF;
             }
         }
     }
 }
 
-void loadRGBFloatDataToRGBA(int width, int height, int depth,
-                            const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                            void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadRGBA8ToBGRA8(size_t width, size_t height, size_t depth,
+                      const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                      uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const float *source = NULL;
-    float *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<float>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<float>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
+            const uint32_t *source = OffsetDataPointer<uint32_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint32_t *dest = OffsetDataPointer<uint32_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
-                dest[4 * x + 0] = source[x * 3 + 0];
-                dest[4 * x + 1] = source[x * 3 + 1];
-                dest[4 * x + 2] = source[x * 3 + 2];
-                dest[4 * x + 3] = 1.0f;
-            }
-        }
-    }
-}
-
-void loadRGBFloatDataToNative(int width, int height, int depth,
-                              const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                              void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
-{
-    const float *source = NULL;
-    float *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
-    {
-        for (int y = 0; y < height; y++)
-        {
-            source = offsetDataPointer<float>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<float>(output, y, z, outputRowPitch, outputDepthPitch);
-            memcpy(dest, source, width * 12);
-        }
-    }
-}
-
-void loadRGBHalfFloatDataToRGBA(int width, int height, int depth,
-                                const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
-{
-    const unsigned short *source = NULL;
-    unsigned short *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
-    {
-        for (int y = 0; y < height; y++)
-        {
-            source = offsetDataPointer<unsigned short>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned short>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
-            {
-                dest[4 * x + 0] = source[x * 3 + 0];
-                dest[4 * x + 1] = source[x * 3 + 1];
-                dest[4 * x + 2] = source[x * 3 + 2];
-                dest[4 * x + 3] = 0x3C00; // SEEEEEMMMMMMMMMM, S = 0, E = 15, M = 0: 16bit flpt representation of 1
+                uint32_t rgba = source[x];
+                dest[x] = (_rotl(rgba, 16) & 0x00ff00ff) | (rgba & 0xff00ff00);
             }
         }
     }
 }
 
-void loadRGBAUByteDataToBGRA(int width, int height, int depth,
-                             const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                             void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadRGBA4ToBGRA8(size_t width, size_t height, size_t depth,
+                      const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                      uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned int *source = NULL;
-    unsigned int *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<unsigned int>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned int>(output, y, z, outputRowPitch, outputDepthPitch);
-
-            for (int x = 0; x < width; x++)
+            const uint16_t *source = OffsetDataPointer<uint16_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint8_t *dest = OffsetDataPointer<uint8_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
-                unsigned int rgba = source[x];
-                dest[x] = (_rotl(rgba, 16) & 0x00ff00ff) | (rgba & 0xff00ff00);
+                uint16_t rgba = source[x];
+                dest[4 * x + 0] = ((rgba & 0x00F0) << 0) | ((rgba & 0x00F0) >> 4);
+                dest[4 * x + 1] = ((rgba & 0x0F00) >> 4) | ((rgba & 0x0F00) >> 8);
+                dest[4 * x + 2] = ((rgba & 0xF000) >> 8) | ((rgba & 0xF000) >> 12);
+                dest[4 * x + 3] = ((rgba & 0x000F) << 4) | ((rgba & 0x000F) >> 0);
             }
         }
     }
 }
 
-void loadRGBAUByteDataToNative(int width, int height, int depth,
-                               const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                               void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadRGBA4ToRGBA8(size_t width, size_t height, size_t depth,
+                      const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                      uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned int *source = NULL;
-    unsigned int *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<unsigned int>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned int>(output, y, z, outputRowPitch, outputDepthPitch);
-
-            memcpy(dest, source, width * 4);
-        }
-    }
-}
-
-void loadRGBA4444DataToBGRA(int width, int height, int depth,
-                            const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                            void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
-{
-    const unsigned short *source = NULL;
-    unsigned char *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
-    {
-        for (int y = 0; y < height; y++)
-        {
-            source = offsetDataPointer<unsigned short>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned char>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
+            const uint16_t *source = OffsetDataPointer<uint16_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint8_t *dest = OffsetDataPointer<uint8_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
-                unsigned short rgba = source[x];
-                dest[4 * x + 0] = ((rgba & 0x00F0) << 0) | ((rgba & 0x00F0) >> 4);
+                uint16_t rgba = source[x];
+                dest[4 * x + 0] = ((rgba & 0xF000) >> 8) | ((rgba & 0xF000) >> 12);
                 dest[4 * x + 1] = ((rgba & 0x0F00) >> 4) | ((rgba & 0x0F00) >> 8);
-                dest[4 * x + 2] = ((rgba & 0xF000) >> 8) | ((rgba & 0xF000) >> 12);
+                dest[4 * x + 2] = ((rgba & 0x00F0) << 0) | ((rgba & 0x00F0) >> 4);
                 dest[4 * x + 3] = ((rgba & 0x000F) << 4) | ((rgba & 0x000F) >> 0);
             }
         }
     }
 }
 
-void loadRGBA4444DataToRGBA(int width, int height, int depth,
-                            const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                            void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadBGRA4ToBGRA8(size_t width, size_t height, size_t depth,
+                      const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                      uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned short *source = NULL;
-    unsigned char *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<unsigned short>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned char>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
+            const uint16_t *source = OffsetDataPointer<uint16_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint8_t *dest = OffsetDataPointer<uint8_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
-                unsigned short rgba = source[x];
-                dest[4 * x + 0] = ((rgba & 0xF000) >> 8) | ((rgba & 0xF000) >> 12);
-                dest[4 * x + 1] = ((rgba & 0x0F00) >> 4) | ((rgba & 0x0F00) >> 8);
-                dest[4 * x + 2] = ((rgba & 0x00F0) << 0) | ((rgba & 0x00F0) >> 4);
-                dest[4 * x + 3] = ((rgba & 0x000F) << 4) | ((rgba & 0x000F) >> 0);
+                uint16_t bgra = source[x];
+                dest[4 * x + 0] = ((bgra & 0xF000) >> 8) | ((bgra & 0xF000) >> 12);
+                dest[4 * x + 1] = ((bgra & 0x0F00) >> 4) | ((bgra & 0x0F00) >> 8);
+                dest[4 * x + 2] = ((bgra & 0x00F0) << 0) | ((bgra & 0x00F0) >> 4);
+                dest[4 * x + 3] = ((bgra & 0x000F) << 4) | ((bgra & 0x000F) >> 0);
             }
         }
     }
 }
 
-void loadRGBA5551DataToBGRA(int width, int height, int depth,
-                            const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                            void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadRGB5A1ToBGRA8(size_t width, size_t height, size_t depth,
+                       const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                       uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned short *source = NULL;
-    unsigned char *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<unsigned short>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned char>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
+            const uint16_t *source = OffsetDataPointer<uint16_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint8_t *dest = OffsetDataPointer<uint8_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
-                unsigned short rgba = source[x];
+                uint16_t rgba = source[x];
                 dest[4 * x + 0] = ((rgba & 0x003E) << 2) | ((rgba & 0x003E) >> 3);
                 dest[4 * x + 1] = ((rgba & 0x07C0) >> 3) | ((rgba & 0x07C0) >> 8);
                 dest[4 * x + 2] = ((rgba & 0xF800) >> 8) | ((rgba & 0xF800) >> 13);
@@ -659,22 +435,20 @@ void loadRGBA5551DataToBGRA(int width, int height, int depth,
         }
     }
 }
-void loadRGBA5551DataToRGBA(int width, int height, int depth,
-                            const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                            void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
-{
-    const unsigned short *source = NULL;
-    unsigned char *dest = NULL;
 
-    for (int z = 0; z < depth; z++)
+void LoadRGB5A1ToRGBA8(size_t width, size_t height, size_t depth,
+                       const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                       uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
+{
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<unsigned short>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned char>(output, y, z, outputRowPitch, outputDepthPitch);
-            for (int x = 0; x < width; x++)
+            const uint16_t *source = OffsetDataPointer<uint16_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint8_t *dest = OffsetDataPointer<uint8_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
-                unsigned short rgba = source[x];
+                uint16_t rgba = source[x];
                 dest[4 * x + 0] = ((rgba & 0xF800) >> 8) | ((rgba & 0xF800) >> 13);
                 dest[4 * x + 1] = ((rgba & 0x07C0) >> 3) | ((rgba & 0x07C0) >> 8);
                 dest[4 * x + 2] = ((rgba & 0x003E) << 2) | ((rgba & 0x003E) >> 3);
@@ -684,95 +458,42 @@ void loadRGBA5551DataToRGBA(int width, int height, int depth,
     }
 }
 
-void loadRGBAFloatDataToRGBA(int width, int height, int depth,
-                             const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                             void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
-{
-    const float *source = NULL;
-    float *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
-    {
-        for (int y = 0; y < height; y++)
-        {
-            source = offsetDataPointer<float>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<float>(output, y, z, outputRowPitch, outputDepthPitch);
-            memcpy(dest, source, width * 16);
-        }
-    }
-}
-
-void loadRGBAHalfFloatDataToRGBA(int width, int height, int depth,
-                                 const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                 void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
-{
-    const unsigned char *source = NULL;
-    unsigned char *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
-    {
-        for (int y = 0; y < height; y++)
-        {
-            source = offsetDataPointer<unsigned char>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned char>(output, y, z, outputRowPitch, outputDepthPitch);
-            memcpy(dest, source, width * 8);
-        }
-    }
-}
-
-void loadBGRADataToBGRA(int width, int height, int depth,
-                        const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                        void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
-{
-    const unsigned char *source = NULL;
-    unsigned char *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
-    {
-        for (int y = 0; y < height; y++)
-        {
-            source = offsetDataPointer<unsigned char>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned char>(output, y, z, outputRowPitch, outputDepthPitch);
-            memcpy(dest, source, width*4);
-        }
-    }
-}
 
-void loadRGBA2101010ToNative(int width, int height, int depth,
-                             const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                             void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadBGR5A1ToBGRA8(size_t width, size_t height, size_t depth,
+                       const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                       uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned int *source = NULL;
-    unsigned int *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<unsigned int>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned int>(output, y, z, outputRowPitch, outputDepthPitch);
-            memcpy(dest, source, width * sizeof(unsigned int));
+            const uint16_t *source = OffsetDataPointer<uint16_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint8_t *dest = OffsetDataPointer<uint8_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
+            {
+                uint16_t bgra = source[x];
+                dest[4 * x + 0] = ((bgra & 0xF800) >> 8) | ((bgra & 0xF800) >> 13);
+                dest[4 * x + 1] = ((bgra & 0x07C0) >> 3) | ((bgra & 0x07C0) >> 8);
+                dest[4 * x + 2] = ((bgra & 0x003E) << 2) | ((bgra & 0x003E) >> 3);
+                dest[4 * x + 3] = (bgra & 0x0001) ? 0xFF : 0;
+            }
         }
     }
 }
 
-void loadRGBA2101010ToRGBA(int width, int height, int depth,
-                           const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                           void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadRGB10A2ToRGBA8(size_t width, size_t height, size_t depth,
+                        const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                        uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned int *source = NULL;
-    unsigned char *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<unsigned int>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned char>(output, y, z, outputRowPitch, outputDepthPitch);
-
-            for (int x = 0; x < width; x++)
+            const uint32_t *source = OffsetDataPointer<uint32_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint8_t *dest = OffsetDataPointer<uint8_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
-                unsigned int rgba = source[x];
+                uint32_t rgba = source[x];
                 dest[4 * x + 0] = (rgba & 0x000003FF) >>  2;
                 dest[4 * x + 1] = (rgba & 0x000FFC00) >> 12;
                 dest[4 * x + 2] = (rgba & 0x3FF00000) >> 22;
@@ -782,21 +503,17 @@ void loadRGBA2101010ToRGBA(int width, int height, int depth,
     }
 }
 
-void loadRGBHalfFloatDataTo999E5(int width, int height, int depth,
-                                 const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                 void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadRGB16FToRGB9E5(size_t width, size_t height, size_t depth,
+                        const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                        uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned short *source = NULL;
-    unsigned int *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<unsigned short>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned int>(output, y, z, outputRowPitch, outputDepthPitch);
-
-            for (int x = 0; x < width; x++)
+            const uint16_t *source = OffsetDataPointer<uint16_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint32_t *dest = OffsetDataPointer<uint32_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
                 dest[x] = gl::convertRGBFloatsTo999E5(gl::float16ToFloat32(source[x * 3 + 0]),
                                                       gl::float16ToFloat32(source[x * 3 + 1]),
@@ -806,21 +523,17 @@ void loadRGBHalfFloatDataTo999E5(int width, int height, int depth,
     }
 }
 
-void loadRGBFloatDataTo999E5(int width, int height, int depth,
-                             const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                             void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadRGB32FToRGB9E5(size_t width, size_t height, size_t depth,
+                        const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                        uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const float *source = NULL;
-    unsigned int *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<float>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned int>(output, y, z, outputRowPitch, outputDepthPitch);
-
-            for (int x = 0; x < width; x++)
+            const float *source = OffsetDataPointer<float>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint32_t *dest = OffsetDataPointer<uint32_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
                 dest[x] = gl::convertRGBFloatsTo999E5(source[x * 3 + 0], source[x * 3 + 1], source[x * 3 + 2]);
             }
@@ -828,21 +541,17 @@ void loadRGBFloatDataTo999E5(int width, int height, int depth,
     }
 }
 
-void loadRGBHalfFloatDataTo111110Float(int width, int height, int depth,
-                                       const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                       void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadRGB16FToRG11B10F(size_t width, size_t height, size_t depth,
+                          const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                          uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned short *source = NULL;
-    unsigned int *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<unsigned short>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned int>(output, y, z, outputRowPitch, outputDepthPitch);
-
-            for (int x = 0; x < width; x++)
+            const uint16_t *source = OffsetDataPointer<uint16_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint32_t *dest = OffsetDataPointer<uint32_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
                 dest[x] = (gl::float32ToFloat11(gl::float16ToFloat32(source[x * 3 + 0])) <<  0) |
                           (gl::float32ToFloat11(gl::float16ToFloat32(source[x * 3 + 1])) << 11) |
@@ -852,21 +561,17 @@ void loadRGBHalfFloatDataTo111110Float(int width, int height, int depth,
     }
 }
 
-void loadRGBFloatDataTo111110Float(int width, int height, int depth,
-                                   const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                   void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadRGB32FToRG11B10F(size_t width, size_t height, size_t depth,
+                          const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                          uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const float *source = NULL;
-    unsigned int *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<float>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned int>(output, y, z, outputRowPitch, outputDepthPitch);
-
-            for (int x = 0; x < width; x++)
+            const float *source = OffsetDataPointer<float>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint32_t *dest = OffsetDataPointer<uint32_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
                 dest[x] = (gl::float32ToFloat11(source[x * 3 + 0]) <<  0) |
                           (gl::float32ToFloat11(source[x * 3 + 1]) << 11) |
@@ -876,46 +581,37 @@ void loadRGBFloatDataTo111110Float(int width, int height, int depth,
     }
 }
 
-
-void loadG8R24DataToR24G8(int width, int height, int depth,
-                          const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                          void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadG8R24ToR24G8(size_t width, size_t height, size_t depth,
+                      const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                      uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned int *source = NULL;
-    unsigned int *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<const unsigned int>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned int>(output, y, z, outputRowPitch, outputDepthPitch);
-
-            for (int x = 0; x < width; x++)
+            const uint32_t *source = OffsetDataPointer<uint32_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint32_t *dest = OffsetDataPointer<uint32_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
-                unsigned int d = source[x] >> 8;
-                unsigned int s = source[x] & 0xFF;
+                uint32_t d = source[x] >> 8;
+                uint8_t  s = source[x] & 0xFF;
                 dest[x] = d | (s << 24);
             }
         }
     }
 }
 
-void loadFloatRGBDataToHalfFloatRGBA(int width, int height, int depth,
-                                     const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                     void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadRGB32FToRGBA16F(size_t width, size_t height, size_t depth,
+                         const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                         uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const float *source = NULL;
-    unsigned short *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<float>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned short>(output, y, z, outputRowPitch, outputDepthPitch);
-
-            for (int x = 0; x < width; x++)
+            const float *source = OffsetDataPointer<float>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint16_t *dest = OffsetDataPointer<uint16_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
                 dest[x * 4 + 0] = gl::float32ToFloat16(source[x * 3 + 0]);
                 dest[x * 4 + 1] = gl::float32ToFloat16(source[x * 3 + 1]);
@@ -926,21 +622,17 @@ void loadFloatRGBDataToHalfFloatRGBA(int width, int height, int depth,
     }
 }
 
-void loadUintDataToUshort(int width, int height, int depth,
-                          const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                          void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadR32ToR16(size_t width, size_t height, size_t depth,
+                  const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                  uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned int *source = NULL;
-    unsigned short *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<unsigned int>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned short>(output, y, z, outputRowPitch, outputDepthPitch);
-
-            for (int x = 0; x < width; x++)
+            const uint32_t *source = OffsetDataPointer<uint32_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint16_t *dest = OffsetDataPointer<uint16_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
             {
                 dest[x] = source[x] >> 16;
             }
@@ -948,21 +640,18 @@ void loadUintDataToUshort(int width, int height, int depth,
     }
 }
 
-void loadUintDataToUint24X8(int width, int height, int depth,
-                            const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                            void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
+void LoadR32ToR24G8(size_t width, size_t height, size_t depth,
+                    const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                    uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
 {
-    const unsigned int *source = NULL;
-    unsigned int *dest = NULL;
-
-    for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
     {
-        for (int y = 0; y < height; y++)
+        for (size_t y = 0; y < height; y++)
         {
-            source = offsetDataPointer<const unsigned int>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned int>(output, y, z, outputRowPitch, outputDepthPitch);
+            const uint32_t *source = OffsetDataPointer<uint32_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint32_t *dest = OffsetDataPointer<uint32_t>(output, y, z, outputRowPitch, outputDepthPitch);
 
-            for (int x = 0; x < width; x++)
+            for (size_t x = 0; x < width; x++)
             {
                 dest[x] = source[x] >> 8;
             }

src/libGLESv2/renderer/loadimage.h

 //
-// Copyright (c) 2013 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2013-2014 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
@@ -9,339 +9,185 @@
 #ifndef LIBGLESV2_RENDERER_LOADIMAGE_H_
 #define LIBGLESV2_RENDERER_LOADIMAGE_H_
 
-#include "common/mathutil.h"
+#include "libGLESv2/angletypes.h"
 
-namespace rx
-{
+#include <cstdint>
 
-template <typename T>
-inline static T *offsetDataPointer(void *data, int y, int z, int rowPitch, int depthPitch)
-{
-    return reinterpret_cast<T*>(reinterpret_cast<unsigned char*>(data) + (y * rowPitch) + (z * depthPitch));
-}
-
-template <typename T>
-inline static const T *offsetDataPointer(const void *data, int y, int z, int rowPitch, int depthPitch)
+namespace rx
 {
-    return reinterpret_cast<const T*>(reinterpret_cast<const unsigned char*>(data) + (y * rowPitch) + (z * depthPitch));
-}
-
-void loadAlphaDataToBGRA(int width, int height, int depth,
-                         const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                         void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
-
-void loadAlphaDataToNative(int width, int height, int depth,
-                           const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                           void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
-
-void loadAlphaDataToBGRASSE2(int width, int height, int depth,
-                             const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                             void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
-
-void loadAlphaFloatDataToRGBA(int width, int height, int depth,
-                              const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                              void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
-
-void loadAlphaHalfFloatDataToRGBA(int width, int height, int depth,
-                                  const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                  void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
 
-void loadLuminanceDataToNative(int width, int height, int depth,
-                               const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                               void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadA8ToRGBA8(size_t width, size_t height, size_t depth,
+                   const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                   uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadLuminanceDataToBGRA(int width, int height, int depth,
-                             const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                             void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadA8ToBGRA8(size_t width, size_t height, size_t depth,
+                   const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                   uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadLuminanceFloatDataToRGBA(int width, int height, int depth,
-                                  const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                  void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadA8ToBGRA8_SSE2(size_t width, size_t height, size_t depth,
+                        const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                        uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadLuminanceFloatDataToRGB(int width, int height, int depth,
-                                 const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                 void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadA32FToRGBA32F(size_t width, size_t height, size_t depth,
+                       const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                       uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadLuminanceHalfFloatDataToRGBA(int width, int height, int depth,
-                                      const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                      void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadA16FToRGBA16F(size_t width, size_t height, size_t depth,
+                       const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                       uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadLuminanceAlphaDataToNative(int width, int height, int depth,
-                                    const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                    void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadL8ToRGBA8(size_t width, size_t height, size_t depth,
+                   const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                   uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadLuminanceAlphaDataToBGRA(int width, int height, int depth,
-                                  const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                  void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadL8ToBGRA8(size_t width, size_t height, size_t depth,
+                   const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                   uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadLuminanceAlphaFloatDataToRGBA(int width, int height, int depth,
-                                       const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                       void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadL32FToRGBA32F(size_t width, size_t height, size_t depth,
+                       const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                       uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadLuminanceAlphaHalfFloatDataToRGBA(int width, int height, int depth,
-                                           const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                           void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadL16FToRGBA16F(size_t width, size_t height, size_t depth,
+                       const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                       uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGBUByteDataToBGRX(int width, int height, int depth,
-                            const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                            void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadLA8ToRGBA8(size_t width, size_t height, size_t depth,
+                    const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                    uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGUByteDataToBGRX(int width, int height, int depth,
-                           const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                           void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadLA8ToBGRA8(size_t width, size_t height, size_t depth,
+                    const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                    uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRUByteDataToBGRX(int width, int height, int depth,
-                          const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                          void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadLA32FToRGBA32F(size_t width, size_t height, size_t depth,
+                        const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                        uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGBUByteDataToRGBA(int width, int height, int depth,
-                            const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                            void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadLA16FToRGBA16F(size_t width, size_t height, size_t depth,
+                        const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                        uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGBSByteDataToRGBA(int width, int height, int depth,
-                            const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                            void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadRGB8ToBGRX8(size_t width, size_t height, size_t depth,
+                     const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                     uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGB565DataToBGRA(int width, int height, int depth,
-                          const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                          void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadRG8ToBGRX8(size_t width, size_t height, size_t depth,
+                    const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                    uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGB565DataToRGBA(int width, int height, int depth,
-                          const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                          void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadR8ToBGRX8(size_t width, size_t height, size_t depth,
+                   const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                   uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGBFloatDataToRGBA(int width, int height, int depth,
-                            const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                            void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadR5G6B5ToBGRA8(size_t width, size_t height, size_t depth,
+                       const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                       uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGBFloatDataToNative(int width, int height, int depth,
-                              const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                              void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadR5G6B5ToRGBA8(size_t width, size_t height, size_t depth,
+                       const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                       uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGBHalfFloatDataToRGBA(int width, int height, int depth,
-                                const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadRGBA8ToBGRA8_SSE2(size_t width, size_t height, size_t depth,
+                           const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                           uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGBAUByteDataToBGRASSE2(int width, int height, int depth,
-                                 const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                 void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadRGBA8ToBGRA8(size_t width, size_t height, size_t depth,
+                      const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                      uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGBAUByteDataToBGRA(int width, int height, int depth,
-                             const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                             void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadRGBA4ToBGRA8(size_t width, size_t height, size_t depth,
+                      const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                      uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGBAUByteDataToNative(int width, int height, int depth,
-                               const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                               void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadRGBA4ToRGBA8(size_t width, size_t height, size_t depth,
+                      const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                      uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGBA4444DataToBGRA(int width, int height, int depth,
-                            const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                            void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadBGRA4ToBGRA8(size_t width, size_t height, size_t depth,
+                      const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                      uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGBA4444DataToRGBA(int width, int height, int depth,
-                            const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                            void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadRGB5A1ToBGRA8(size_t width, size_t height, size_t depth,
+                       const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                       uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGBA5551DataToBGRA(int width, int height, int depth,
-                            const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                            void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadRGB5A1ToRGBA8(size_t width, size_t height, size_t depth,
+                       const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                       uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGBA5551DataToRGBA(int width, int height, int depth,
-                            const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                            void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadBGR5A1ToBGRA8(size_t width, size_t height, size_t depth,
+                       const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                       uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGBAFloatDataToRGBA(int width, int height, int depth,
-                             const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                             void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadRGB10A2ToRGBA8(size_t width, size_t height, size_t depth,
+                        const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                        uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGBAHalfFloatDataToRGBA(int width, int height, int depth,
-                                 const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                 void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadRGB16FToRGB9E5(size_t width, size_t height, size_t depth,
+                          const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                          uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadBGRADataToBGRA(int width, int height, int depth,
-                        const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                        void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadRGB32FToRGB9E5(size_t width, size_t height, size_t depth,
+                        const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                        uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGBA2101010ToNative(int width, int height, int depth,
-                             const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                             void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadRGB16FToRG11B10F(size_t width, size_t height, size_t depth,
+                          const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                          uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGBA2101010ToRGBA(int width, int height, int depth,
-                           const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                           void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadRGB32FToRG11B10F(size_t width, size_t height, size_t depth,
+                          const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                          uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGBHalfFloatDataTo999E5(int width, int height, int depth,
-                                 const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                 void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadG8R24ToR24G8(size_t width, size_t height, size_t depth,
+                      const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                      uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGBFloatDataTo999E5(int width, int height, int depth,
-                             const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                             void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+template <typename type, size_t componentCount>
+inline void LoadToNative(size_t width, size_t height, size_t depth,
+                         const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                         uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
+
+template <typename type, uint32_t fourthComponentBits>
+inline void LoadToNative3To4(size_t width, size_t height, size_t depth,
+                             const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                             uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGBHalfFloatDataTo111110Float(int width, int height, int depth,
-                                       const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                       void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+template <size_t componentCount>
+inline void Load32FTo16F(size_t width, size_t height, size_t depth,
+                         const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                         uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadRGBFloatDataTo111110Float(int width, int height, int depth,
-                                   const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                   void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadRGB32FToRGBA16F(size_t width, size_t height, size_t depth,
+                         const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                         uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadG8R24DataToR24G8(int width, int height, int depth,
-                        const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                        void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+template <size_t blockWidth, size_t blockHeight, size_t blockSize>
+inline void LoadCompressedToNative(size_t width, size_t height, size_t depth,
+                                   const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                                   uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-template <typename type, unsigned int componentCount>
-void loadToNative(int width, int height, int depth,
-                  const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                  void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
-{
-    const unsigned int rowSize = width * sizeof(type) * componentCount;
-    const unsigned int layerSize = rowSize * height;
-    const unsigned int imageSize = layerSize * depth;
-
-    if (layerSize == inputDepthPitch && layerSize == outputDepthPitch)
-    {
-        ASSERT(rowSize == inputRowPitch && rowSize == outputRowPitch);
-        memcpy(output, input, imageSize);
-    }
-    else if (rowSize == inputRowPitch && rowSize == outputRowPitch)
-    {
-        for (int z = 0; z < depth; z++)
-        {
-            const type *source = offsetDataPointer<type>(input, 0, z, inputRowPitch, inputDepthPitch);
-            type *dest = offsetDataPointer<type>(output, 0, z, outputRowPitch, outputDepthPitch);
-
-            memcpy(dest, source, layerSize);
-        }
-    }
-    else
-    {
-        for (int z = 0; z < depth; z++)
-        {
-            for (int y = 0; y < height; y++)
-            {
-                const type *source = offsetDataPointer<type>(input, y, z, inputRowPitch, inputDepthPitch);
-                type *dest = offsetDataPointer<type>(output, y, z, outputRowPitch, outputDepthPitch);
-                memcpy(dest, source, width * sizeof(type) * componentCount);
-            }
-        }
-    }
-}
+void LoadR32ToR16(size_t width, size_t height, size_t depth,
+                  const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                  uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-template <typename type, unsigned int fourthComponentBits>
-void loadToNative3To4(int width, int height, int depth,
-                      const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                      void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
-{
-    const type *source = NULL;
-    type *dest = NULL;
-
-    const unsigned int fourthBits = fourthComponentBits;
-    const type fourthValue = *reinterpret_cast<const type*>(&fourthBits);
-
-    for (int z = 0; z < depth; z++)
-    {
-        for (int y = 0; y < height; y++)
-        {
-            source = offsetDataPointer<type>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<type>(output, y, z, outputRowPitch, outputDepthPitch);
-
-            for (int x = 0; x < width; x++)
-            {
-                dest[x * 4 + 0] = source[x * 3 + 0];
-                dest[x * 4 + 1] = source[x * 3 + 1];
-                dest[x * 4 + 2] = source[x * 3 + 2];
-                dest[x * 4 + 3] = fourthValue;
-            }
-        }
-    }
-}
-
-template <unsigned int componentCount>
-void loadFloatDataToHalfFloat(int width, int height, int depth,
-                              const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                              void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
-{
-    const float *source = NULL;
-    unsigned short *dest = NULL;
-
-    const int elementWidth = componentCount * width;
-
-    for (int z = 0; z < depth; z++)
-    {
-        for (int y = 0; y < height; y++)
-        {
-            source = offsetDataPointer<float>(input, y, z, inputRowPitch, inputDepthPitch);
-            dest = offsetDataPointer<unsigned short>(output, y, z, outputRowPitch, outputDepthPitch);
-
-            for (int x = 0; x < elementWidth; x++)
-            {
-                dest[x] = gl::float32ToFloat16(source[x]);
-            }
-        }
-    }
-}
+template <typename type, uint32_t firstBits, uint32_t secondBits, uint32_t thirdBits, uint32_t fourthBits>
+inline void Initialize4ComponentData(size_t width, size_t height, size_t depth,
+                                     uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-void loadFloatRGBDataToHalfFloatRGBA(int width, int height, int depth,
-                                     const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                     void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+void LoadR32ToR24G8(size_t width, size_t height, size_t depth,
+                    const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                    uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch);
 
-template <unsigned int blockWidth, unsigned int blockHeight, unsigned int blockSize>
-void loadCompressedBlockDataToNative(int width, int height, int depth,
-                                     const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                                     void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
-{
-    int columns = (width + (blockWidth - 1)) / blockWidth;
-    int rows = (height + (blockHeight - 1)) / blockHeight;
-
-    for (int z = 0; z < depth; ++z)
-    {
-        for (int y = 0; y < rows; ++y)
-        {
-            void *source = (void*)((char*)input + y * inputRowPitch + z * inputDepthPitch);
-            void *dest = (void*)((char*)output + y * outputRowPitch + z * outputDepthPitch);
-
-            memcpy(dest, source, columns * blockSize);
-        }
-    }
-}
+template <typename T>
+inline T *OffsetDataPointer(uint8_t *data, size_t y, size_t z, size_t rowPitch, size_t depthPitch);
 
-void loadUintDataToUshort(int width, int height, int depth,
-                          const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                          void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
+template <typename T>
+inline const T *OffsetDataPointer(const uint8_t *data, size_t y, size_t z, size_t rowPitch, size_t depthPitch);
 
-template <typename type, unsigned int firstBits, unsigned int secondBits, unsigned int thirdBits, unsigned int fourthBits>
-void initialize4ComponentData(int width, int height, int depth,
-                              void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
-{
-    unsigned int writeBits[4] = { firstBits, secondBits, thirdBits, fourthBits };
-    type writeValues[4] = { *reinterpret_cast<const type*>(&writeBits[0]),
-                            *reinterpret_cast<const type*>(&writeBits[1]),
-                            *reinterpret_cast<const type*>(&writeBits[2]),
-                            *reinterpret_cast<const type*>(&writeBits[3]) };
-
-    for (int z = 0; z < depth; z++)
-    {
-        for (int y = 0; y < height; y++)
-        {
-            type* destRow = offsetDataPointer<type>(output, y, z, outputRowPitch, outputDepthPitch);
-
-            for (int x = 0; x < width; x++)
-            {
-                type* destPixel = destRow + x * 4;
-
-                // This could potentially be optimized by generating an entire row of initialization
-                // data and copying row by row instead of pixel by pixel.
-                memcpy(destPixel, writeValues, sizeof(type) * 4);
-            }
-        }
-    }
 }
 
-void loadUintDataToUint24X8(int width, int height, int depth,
-                            const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-                            void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch);
-
-}
+#include "loadimage.inl"
 
 #endif // LIBGLESV2_RENDERER_LOADIMAGE_H_

src/libGLESv2/renderer/loadimage.inl

+//
+// Copyright (c) 2014 The ANGLE Project 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 "common/mathutil.h"
+
+namespace rx
+{
+
+template <typename T>
+inline T *OffsetDataPointer(uint8_t *data, size_t y, size_t z, size_t rowPitch, size_t depthPitch)
+{
+    return reinterpret_cast<T*>(data + (y * rowPitch) + (z * depthPitch));
+}
+
+template <typename T>
+inline const T *OffsetDataPointer(const uint8_t *data, size_t y, size_t z, size_t rowPitch, size_t depthPitch)
+{
+    return reinterpret_cast<const T*>(data + (y * rowPitch) + (z * depthPitch));
+}
+
+template <typename type, size_t componentCount>
+inline void LoadToNative(size_t width, size_t height, size_t depth,
+                         const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                         uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
+{
+    const size_t rowSize = width * sizeof(type) * componentCount;
+    const size_t layerSize = rowSize * height;
+    const size_t imageSize = layerSize * depth;
+
+    if (layerSize == inputDepthPitch && layerSize == outputDepthPitch)
+    {
+        ASSERT(rowSize == inputRowPitch && rowSize == outputRowPitch);
+        memcpy(output, input, imageSize);
+    }
+    else if (rowSize == inputRowPitch && rowSize == outputRowPitch)
+    {
+        for (size_t z = 0; z < depth; z++)
+        {
+            const type *source = OffsetDataPointer<type>(input, 0, z, inputRowPitch, inputDepthPitch);
+            type *dest = OffsetDataPointer<type>(output, 0, z, outputRowPitch, outputDepthPitch);
+
+            memcpy(dest, source, layerSize);
+        }
+    }
+    else
+    {
+        for (size_t z = 0; z < depth; z++)
+        {
+            for (size_t y = 0; y < height; y++)
+            {
+                const type *source = OffsetDataPointer<type>(input, y, z, inputRowPitch, inputDepthPitch);
+                type *dest = OffsetDataPointer<type>(output, y, z, outputRowPitch, outputDepthPitch);
+                memcpy(dest, source, width * sizeof(type) * componentCount);
+            }
+        }
+    }
+}
+
+template <typename type, uint32_t fourthComponentBits>
+inline void LoadToNative3To4(size_t width, size_t height, size_t depth,
+                             const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                             uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
+{
+    const type fourthValue = gl::bitCast<type>(fourthComponentBits);
+
+    for (size_t z = 0; z < depth; z++)
+    {
+        for (size_t y = 0; y < height; y++)
+        {
+            const type *source = OffsetDataPointer<type>(input, y, z, inputRowPitch, inputDepthPitch);
+            type *dest = OffsetDataPointer<type>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
+            {
+                dest[x * 4 + 0] = source[x * 3 + 0];
+                dest[x * 4 + 1] = source[x * 3 + 1];
+                dest[x * 4 + 2] = source[x * 3 + 2];
+                dest[x * 4 + 3] = fourthValue;
+            }
+        }
+    }
+}
+
+template <size_t componentCount>
+inline void Load32FTo16F(size_t width, size_t height, size_t depth,
+                         const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                         uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
+{
+    const size_t elementWidth = componentCount * width;
+
+    for (size_t z = 0; z < depth; z++)
+    {
+        for (size_t y = 0; y < height; y++)
+        {
+            const float *source = OffsetDataPointer<float>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint16_t *dest = OffsetDataPointer<uint16_t>(output, y, z, outputRowPitch, outputDepthPitch);
+
+            for (size_t x = 0; x < elementWidth; x++)
+            {
+                dest[x] = gl::float32ToFloat16(source[x]);
+            }
+        }
+    }
+}
+
+template <size_t blockWidth, size_t blockHeight, size_t blockSize>
+inline void LoadCompressedToNative(size_t width, size_t height, size_t depth,
+                                   const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                                   uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
+{
+    const size_t columns = (width + (blockWidth - 1)) / blockWidth;
+    const size_t rows = (height + (blockHeight - 1)) / blockHeight;
+
+    for (size_t z = 0; z < depth; ++z)
+    {
+        for (size_t y = 0; y < rows; ++y)
+        {
+            const uint8_t *source = OffsetDataPointer<uint8_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint8_t *dest = OffsetDataPointer<uint8_t>(output, y, z, outputRowPitch, outputDepthPitch);
+            memcpy(dest, source, columns * blockSize);
+        }
+    }
+}
+
+template <typename type, uint32_t firstBits, uint32_t secondBits, uint32_t thirdBits, uint32_t fourthBits>
+inline void Initialize4ComponentData(size_t width, size_t height, size_t depth,
+                                     uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
+{
+    type writeValues[4] =
+    {
+        gl::bitCast<type>(firstBits),
+        gl::bitCast<type>(secondBits),
+        gl::bitCast<type>(thirdBits),
+        gl::bitCast<type>(fourthBits),
+    };
+
+    for (size_t z = 0; z < depth; z++)
+    {
+        for (size_t y = 0; y < height; y++)
+        {
+            type *destRow = OffsetDataPointer<type>(output, y, z, outputRowPitch, outputDepthPitch);
+            for (size_t x = 0; x < width; x++)
+            {
+                type* destPixel = destRow + x * 4;
+
+                // This could potentially be optimized by generating an entire row of initialization
+                // data and copying row by row instead of pixel by pixel.
+                memcpy(destPixel, writeValues, sizeof(type) * 4);
+            }
+        }
+    }
+}
+
+}

src/libGLESv2/renderer/loadimageSSE2.cpp

 #include "precompiled.h"
 //
-// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2014 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 
-// loadimage.cpp: Defines image loading functions. It's
+// loadimageSSE2.cpp: Defines image loading functions. It's
 // in a separated file for GCC, which can enable SSE usage only per-file,
 // not for code blocks that use SSE2 explicitly.
 
@@ -14,94 +14,92 @@
 namespace rx
 {
 
-    void loadAlphaDataToBGRASSE2(int width, int height, int depth,
-        const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-        void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
-    {
-        const unsigned char *source = NULL;
-        unsigned int *dest = NULL;
-        __m128i zeroWide = _mm_setzero_si128();
+void LoadA8ToBGRA8_SSE2(size_t width, size_t height, size_t depth,
+                        const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                        uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
+{
+    __m128i zeroWide = _mm_setzero_si128();
 
-        for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
+    {
+        for (size_t y = 0; y < height; y++)
         {
-            for (int y = 0; y < height; y++)
+            const uint8_t *source = OffsetDataPointer<uint8_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint32_t *dest = OffsetDataPointer<uint32_t>(output, y, z, outputRowPitch, outputDepthPitch);
+
+            size_t x = 0;
+
+            // Make output writes aligned
+            for (; ((reinterpret_cast<intptr_t>(&dest[x]) & 0xF) != 0 && x < width); x++)
             {
-                source = static_cast<const unsigned char*>(input) + y * inputRowPitch + z * inputDepthPitch;
-                dest = reinterpret_cast<unsigned int*>(static_cast<unsigned char*>(output) + y * outputRowPitch + z * outputDepthPitch);
-
-                int x;
-                // Make output writes aligned
-                for (x = 0; ((reinterpret_cast<intptr_t>(&dest[x]) & 0xF) != 0 && x < width); x++)
-                {
-                    dest[x] = static_cast<unsigned int>(source[x]) << 24;
-                }
-
-                for (; x + 7 < width; x += 8)
-                {
-                    __m128i sourceData = _mm_loadl_epi64(reinterpret_cast<const __m128i*>(&source[x]));
-                    // Interleave each byte to 16bit, make the lower byte to zero
-                    sourceData = _mm_unpacklo_epi8(zeroWide, sourceData);
-                    // Interleave each 16bit to 32bit, make the lower 16bit to zero
-                    __m128i lo = _mm_unpacklo_epi16(zeroWide, sourceData);
-                    __m128i hi = _mm_unpackhi_epi16(zeroWide, sourceData);
-
-                    _mm_store_si128(reinterpret_cast<__m128i*>(&dest[x]), lo);
-                    _mm_store_si128(reinterpret_cast<__m128i*>(&dest[x + 4]), hi);
-                }
-
-                // Handle the remainder
-                for (; x < width; x++)
-                {
-                    dest[x] = static_cast<unsigned int>(source[x]) << 24;
-                }
+                dest[x] = static_cast<uint32_t>(source[x]) << 24;
+            }
+
+            for (; x + 7 < width; x += 8)
+            {
+                __m128i sourceData = _mm_loadl_epi64(reinterpret_cast<const __m128i*>(&source[x]));
+                // Interleave each byte to 16bit, make the lower byte to zero
+                sourceData = _mm_unpacklo_epi8(zeroWide, sourceData);
+                // Interleave each 16bit to 32bit, make the lower 16bit to zero
+                __m128i lo = _mm_unpacklo_epi16(zeroWide, sourceData);
+                __m128i hi = _mm_unpackhi_epi16(zeroWide, sourceData);
+
+                _mm_store_si128(reinterpret_cast<__m128i*>(&dest[x]), lo);
+                _mm_store_si128(reinterpret_cast<__m128i*>(&dest[x + 4]), hi);
+            }
+
+            // Handle the remainder
+            for (; x < width; x++)
+            {
+                dest[x] = static_cast<uint32_t>(source[x]) << 24;
             }
         }
     }
+}
 
-    void loadRGBAUByteDataToBGRASSE2(int width, int height, int depth,
-        const void *input, unsigned int inputRowPitch, unsigned int inputDepthPitch,
-        void *output, unsigned int outputRowPitch, unsigned int outputDepthPitch)
-    {
-        const unsigned int *source = NULL;
-        unsigned int *dest = NULL;
-        __m128i brMask = _mm_set1_epi32(0x00ff00ff);
+void LoadRGBA8ToBGRA8_SSE2(size_t width, size_t height, size_t depth,
+                           const uint8_t *input, size_t inputRowPitch, size_t inputDepthPitch,
+                           uint8_t *output, size_t outputRowPitch, size_t outputDepthPitch)
+{
+    __m128i brMask = _mm_set1_epi32(0x00ff00ff);
 
-        for (int z = 0; z < depth; z++)
+    for (size_t z = 0; z < depth; z++)
+    {
+        for (size_t y = 0; y < height; y++)
         {
-            for (int y = 0; y < height; y++)
+            const uint32_t *source = OffsetDataPointer<uint32_t>(input, y, z, inputRowPitch, inputDepthPitch);
+            uint32_t *dest = OffsetDataPointer<uint32_t>(output, y, z, outputRowPitch, outputDepthPitch);
+
+            size_t x = 0;
+
+            // Make output writes aligned
+            for (; ((reinterpret_cast<intptr_t>(&dest[x]) & 15) != 0) && x < width; x++)
+            {
+                uint32_t rgba = source[x];
+                dest[x] = (_rotl(rgba, 16) & 0x00ff00ff) | (rgba & 0xff00ff00);
+            }
+
+            for (; x + 3 < width; x += 4)
+            {
+                __m128i sourceData = _mm_loadu_si128(reinterpret_cast<const __m128i*>(&source[x]));
+                // Mask out g and a, which don't change
+                __m128i gaComponents = _mm_andnot_si128(brMask, sourceData);
+                // Mask out b and r
+                __m128i brComponents = _mm_and_si128(sourceData, brMask);
+                // Swap b and r
+                __m128i brSwapped = _mm_shufflehi_epi16(_mm_shufflelo_epi16(brComponents, _MM_SHUFFLE(2, 3, 0, 1)), _MM_SHUFFLE(2, 3, 0, 1));
+                __m128i result = _mm_or_si128(gaComponents, brSwapped);
+                _mm_store_si128(reinterpret_cast<__m128i*>(&dest[x]), result);
+            }
+
+            // Perform leftover writes
+            for (; x < width; x++)
             {
-                source = reinterpret_cast<const unsigned int*>(static_cast<const unsigned char*>(input) + y * inputRowPitch + z * inputDepthPitch);
-                dest = reinterpret_cast<unsigned int*>(static_cast<unsigned char*>(output) + y * outputRowPitch + z * outputDepthPitch);
-                int x = 0;
-
-                // Make output writes aligned
-                for (x = 0; ((reinterpret_cast<intptr_t>(&dest[x]) & 15) != 0) && x < width; x++)
-                {
-                    unsigned int rgba = source[x];
-                    dest[x] = (_rotl(rgba, 16) & 0x00ff00ff) | (rgba & 0xff00ff00);
-                }
-
-                for (; x + 3 < width; x += 4)
-                {
-                    __m128i sourceData = _mm_loadu_si128(reinterpret_cast<const __m128i*>(&source[x]));
-                    // Mask out g and a, which don't change
-                    __m128i gaComponents = _mm_andnot_si128(brMask, sourceData);
-                    // Mask out b and r
-                    __m128i brComponents = _mm_and_si128(sourceData, brMask);
-                    // Swap b and r
-                    __m128i brSwapped = _mm_shufflehi_epi16(_mm_shufflelo_epi16(brComponents, _MM_SHUFFLE(2, 3, 0, 1)), _MM_SHUFFLE(2, 3, 0, 1));
-                    __m128i result = _mm_or_si128(gaComponents, brSwapped);
-                    _mm_store_si128(reinterpret_cast<__m128i*>(&dest[x]), result);
-                }
-
-                // Perform leftover writes
-                for (; x < width; x++)
-                {
-                    unsigned int rgba = source[x];
-                    dest[x] = (_rotl(rgba, 16) & 0x00ff00ff) | (rgba & 0xff00ff00);
-                }
+                uint32_t rgba = source[x];
+                dest[x] = (_rotl(rgba, 16) & 0x00ff00ff) | (rgba & 0xff00ff00);
             }
         }
     }
+}
 
 }