Edit

kc3-lang/angle/src/libGLESv2/renderer/loadimage.cpp

Branch :

  • Show log

    Commit

  • Author : Geoff Lang
    Date : 2014-05-06 11:49:22
    Hash : b69d39ba
    Message : Add a DXGI format for GL_LUMINANCE16F_EXT in ES3. BUG=angle:642 Change-Id: I41eb64b8e9963cfe33e4c127f84a16eef9b118d3 Reviewed-on: https://chromium-review.googlesource.com/198379 Reviewed-by: Nicolas Capens <nicolascapens@chromium.org> Reviewed-by: Shannon Woods <shannonwoods@chromium.org> Tested-by: Geoff Lang <geofflang@chromium.org>

  • src/libGLESv2/renderer/loadimage.cpp
  • #include "precompiled.h"
    //
    // Copyright (c) 0013 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.
    
    #include "libGLESv2/renderer/loadimage.h"
    
    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)
    {
        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] = 0;
                    dest[4 * x + 1] = 0;
                    dest[4 * x + 2] = 0;
                    dest[4 * x + 3] = source[x];
                }
            }
        }
    }
    
    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)
    {
        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);
            }
        }
    }
    
    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)
    {
        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[4 * x + 0] = 0;
                    dest[4 * x + 1] = 0;
                    dest[4 * x + 2] = 0;
                    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)
    {
        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] = 0;
                    dest[4 * x + 1] = 0;
                    dest[4 * x + 2] = 0;
                    dest[4 * x + 3] = source[x];
                }
            }
        }
    }
    
    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)
    {
        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);
            }
        }
    }
    
    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++)
                {
                    dest[4 * x + 0] = source[x];
                    dest[4 * x + 1] = source[x];
                    dest[4 * x + 2] = source[x];
                    dest[4 * x + 3] = 0xFF;
                }
            }
        }
    }
    
    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)
    {
        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[4 * x + 0] = source[x];
                    dest[4 * x + 1] = source[x];
                    dest[4 * x + 2] = source[x];
                    dest[4 * x + 3] = 1.0f;
                }
            }
        }
    }
    
    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)
    {
        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];
                    dest[4 * x + 1] = source[x];
                    dest[4 * x + 2] = source[x];
                    dest[4 * x + 3] = gl::Float16One;
                }
            }
        }
    }
    
    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)
    {
        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 * 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++)
                {
                    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)
    {
        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[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)
    {
        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[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)
    {
        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 + 2];
                    dest[4 * x + 1] = source[x * 3 + 1];
                    dest[4 * x + 2] = source[x * 3 + 0];
                    dest[4 * x + 3] = 0xFF;
                }
            }
        }
    }
    
    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)
    {
        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] = 0x00;
                    dest[4 * x + 1] = source[x * 2 + 1];
                    dest[4 * x + 2] = source[x * 2 + 0];
                    dest[4 * x + 3] = 0xFF;
                }
            }
        }
    }
    
    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)
    {
        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] = 0x00;
                    dest[4 * x + 1] = 0x00;
                    dest[4 * x + 2] = source[x];
                    dest[4 * x + 3] = 0xFF;
                }
            }
        }
    }
    
    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)
    {
        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++)
                {
                    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);
                    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)
    {
        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++)
                {
                    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);
                    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)
    {
        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[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
                }
            }
        }
    }
    
    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)
    {
        const unsigned int *source = NULL;
        unsigned int *dest = NULL;
    
        for (int z = 0; z < depth; z++)
        {
            for (int 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++)
                {
                    unsigned int rgba = source[x];
                    dest[x] = (_rotl(rgba, 16) & 0x00ff00ff) | (rgba & 0xff00ff00);
                }
            }
        }
    }
    
    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)
    {
        const unsigned int *source = NULL;
        unsigned int *dest = NULL;
    
        for (int z = 0; z < depth; z++)
        {
            for (int 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++)
                {
                    unsigned short 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 loadRGBA4444DataToRGBA(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++)
                {
                    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);
                }
            }
        }
    }
    
    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)
    {
        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++)
                {
                    unsigned short 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);
                    dest[4 * x + 3] = (rgba & 0x0001) ? 0xFF : 0;
                }
            }
        }
    }
    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++)
        {
            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++)
                {
                    unsigned short 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);
                    dest[4 * x + 3] = (rgba & 0x0001) ? 0xFF : 0;
                }
            }
        }
    }
    
    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)
    {
        const unsigned int *source = NULL;
        unsigned int *dest = NULL;
    
        for (int z = 0; z < depth; z++)
        {
            for (int 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));
            }
        }
    }
    
    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)
    {
        const unsigned int *source = NULL;
        unsigned char *dest = NULL;
    
        for (int z = 0; z < depth; z++)
        {
            for (int 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++)
                {
                    unsigned int rgba = source[x];
                    dest[4 * x + 0] = (rgba & 0x000003FF) >>  2;
                    dest[4 * x + 1] = (rgba & 0x000FFC00) >> 12;
                    dest[4 * x + 2] = (rgba & 0x3FF00000) >> 22;
                    dest[4 * x + 3] = ((rgba & 0xC0000000) >> 30) * 0x55;
                }
            }
        }
    }
    
    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)
    {
        const unsigned short *source = NULL;
        unsigned int *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 int>(output, y, z, outputRowPitch, outputDepthPitch);
    
                for (int x = 0; x < width; x++)
                {
                    dest[x] = gl::convertRGBFloatsTo999E5(gl::float16ToFloat32(source[x * 3 + 0]),
                                                          gl::float16ToFloat32(source[x * 3 + 1]),
                                                          gl::float16ToFloat32(source[x * 3 + 2]));
                }
            }
        }
    }
    
    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)
    {
        const float *source = NULL;
        unsigned int *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<unsigned int>(output, y, z, outputRowPitch, outputDepthPitch);
    
                for (int x = 0; x < width; x++)
                {
                    dest[x] = gl::convertRGBFloatsTo999E5(source[x * 3 + 0], source[x * 3 + 1], source[x * 3 + 2]);
                }
            }
        }
    }
    
    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)
    {
        const unsigned short *source = NULL;
        unsigned int *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 int>(output, y, z, outputRowPitch, outputDepthPitch);
    
                for (int 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) |
                              (gl::float32ToFloat10(gl::float16ToFloat32(source[x * 3 + 2])) << 22);
                }
            }
        }
    }
    
    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)
    {
        const float *source = NULL;
        unsigned int *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<unsigned int>(output, y, z, outputRowPitch, outputDepthPitch);
    
                for (int x = 0; x < width; x++)
                {
                    dest[x] = (gl::float32ToFloat11(source[x * 3 + 0]) <<  0) |
                              (gl::float32ToFloat11(source[x * 3 + 1]) << 11) |
                              (gl::float32ToFloat10(source[x * 3 + 2]) << 22);
                }
            }
        }
    }
    
    
    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)
    {
        const unsigned int *source = NULL;
        unsigned int *dest = NULL;
    
        for (int z = 0; z < depth; z++)
        {
            for (int 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++)
                {
                    unsigned int d = source[x] >> 8;
                    unsigned int 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)
    {
        const float *source = NULL;
        unsigned short *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<unsigned short>(output, y, z, outputRowPitch, outputDepthPitch);
    
                for (int 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]);
                    dest[x * 4 + 2] = gl::float32ToFloat16(source[x * 3 + 2]);
                    dest[x * 4 + 3] = gl::Float16One;
                }
            }
        }
    }
    
    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)
    {
        const unsigned int *source = NULL;
        unsigned short *dest = NULL;
    
        for (int z = 0; z < depth; z++)
        {
            for (int 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++)
                {
                    dest[x] = source[x] >> 16;
                }
            }
        }
    }
    
    }