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

Branch : - branch - main - tag -

• Show log

  Commit

• Author : shannonwoods@chromium.org
  Date : 2013-05-30 00:08:00
  Hash : b8490f3c
  Message : Created new helper functions for converting texture formats, loading images and generating mipmaps." TRAC #22972 Signed-off-by: Jamie Madill Signed-off-by: Nicolas Capens Author: Geoff Lang git-svn-id: https://angleproject.googlecode.com/svn/branches/es3proto@2313 736b8ea6-26fd-11df-bfd4-992fa37f6226

• src/libGLESv2/renderer/loadimageSSE2.cpp

• #include "precompiled.h"
  //
  // Copyright (c) 2002-2012 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
  // in a separated file for GCC, which can enable SSE usage only per-file,
  // not for code blocks that use SSE2 explicitly.
  
  #include "libGLESv2/renderer/loadimage.h"
  
  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();
  
          for (int z = 0; z < depth; z++)
          {
              for (int y = 0; y < height; y++)
              {
                  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;
                  }
              }
          }
      }
  
      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);
  
          for (int z = 0; z < depth; z++)
          {
              for (int y = 0; y < height; y++)
              {
                  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);
                  }
              }
          }
      }
  
  }