kc3-lang/angle/src/image_util/loadimage.inc

• Show log

  Commit

• Hash : 877cd04c
  Author :
  Date : 2023-03-02T10:24:14
  

  Reland "Add vulkan format image fallback for R16G16B16"
  
  Suppressed misbehaving trace test in https://crrev.com/c/4317088
  
  This is a reland of commit 71f6d54c8d3662693283281651e57c994a10cf08
  
  Original change's description:
  > Add vulkan format image fallback for R16G16B16
  >
  > This change adds a vulkan format image mapping fallback from R16G16B16
  > to R16G16B16A16, R32G32B32_FLOAT and R32G32B32A32_FLOAT for both
  > UNORM and SNORM variants.
  >
  > This is done because in Chrome we want to use R16/RG16 formats which
  > are exposed to Skia over the EXT_texture_norm16. Currently,
  > EXT_texture_norm16 requires RGB16_EXT which if not present is not
  > supported even if R16_EXT and RG16_EXT are supported. This fallback
  > helps us support R16/RG16 as well over RGBA16.
  >
  > It also updates validationES checks for GL_RGBA signed and unsigned
  > normalized checking if type is GL_SHORT or GL_UNSIGNED_SHORT.
  >
  > It adds a method LoadToFloat that allows a type (GLushort or GLshort)
  > to be loaded into float format types. This is then used as part of
  > fallbacks for load_functions_data.json.
  >
  > Bug: None
  > Change-Id: I5c6879cd2ed5dd6e3440877f4891f269d96d88a1
  > Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4294694
  > Reviewed-by: Vasiliy Telezhnikov <vasilyt@chromium.org>
  > Reviewed-by: Geoff Lang <geofflang@chromium.org>
  > Commit-Queue: Geoff Lang <geofflang@chromium.org>
  
  Bug: None
  Change-Id: I101dd9e8c62e6794692c9f89c4944297e195f710
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4317089
  Reviewed-by: Cody Northrop <cnorthrop@google.com>
  Auto-Submit: Roman Lavrov <romanl@google.com>
  Commit-Queue: Cody Northrop <cnorthrop@google.com>
  

Download

• src/image_util/loadimage.inc

• //
  // Copyright 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"
  
  #include <string.h>
  
  namespace angle
  {
  
  namespace priv
  {
  
  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));
  }
  
  }  // namespace priv
  
  template <typename type, size_t componentCount>
  inline void LoadToNative(const ImageLoadContext &context, 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 = priv::OffsetDataPointer<type>(input, 0, z, inputRowPitch, inputDepthPitch);
              type *dest = priv::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 = priv::OffsetDataPointer<type>(input, y, z, inputRowPitch, inputDepthPitch);
                  type *dest = priv::OffsetDataPointer<type>(output, y, z, outputRowPitch, outputDepthPitch);
                  memcpy(dest, source, width * sizeof(type) * componentCount);
              }
          }
      }
  }
  
  template <typename type, uint32_t fourthComponentBits>
  inline void LoadToNative3To4(const ImageLoadContext &context, 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 = priv::OffsetDataPointer<type>(input, y, z, inputRowPitch, inputDepthPitch);
              type *dest = priv::OffsetDataPointer<type>(output, y, z, outputRowPitch, outputDepthPitch);
              for (size_t x = 0; x < width; x++)
              {
                  memcpy(&dest[x * 4], &source[x * 3], sizeof(type) * 3);
                  dest[x * 4 + 3] = fourthValue;
              }
          }
      }
  }
  
  template <size_t componentCount>
  inline void Load32FTo16F(const ImageLoadContext &context, 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 = priv::OffsetDataPointer<float>(input, y, z, inputRowPitch, inputDepthPitch);
              uint16_t *dest = priv::OffsetDataPointer<uint16_t>(output, y, z, outputRowPitch, outputDepthPitch);
  
              for (size_t x = 0; x < elementWidth; x++)
              {
                  dest[x] = gl::float32ToFloat16(source[x]);
              }
          }
      }
  }
  
  template <typename type,
            size_t inputComponentCount,
            size_t outputComponentCount,
            bool normalized>
  inline void LoadToFloat(const ImageLoadContext &context, 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 std::numeric_limits<type> NL;
  
      for (size_t z = 0; z < depth; z++)
      {
          for (size_t y = 0; y < height; y++)
          {
              const type *source_line = priv::OffsetDataPointer<type>(input, y, z, inputRowPitch, inputDepthPitch);
              float *dest_line = priv::OffsetDataPointer<float>(output, y, z, outputRowPitch, outputDepthPitch);
  
              for (size_t x = 0; x < width; x++)
              {
                  const type *source_pixel = source_line + x * inputComponentCount;
                  float *dest_pixel = dest_line + x * outputComponentCount;
  
                  for (size_t i = 0; i < inputComponentCount; i++)
                  {
                      float result = 0;
                      if (normalized)
                      {
                          if (NL::is_signed)
                          {
                              result = static_cast<float>(source_pixel[i]) / static_cast<float>(NL::max());
                              result = result >= -1.0f ? result : -1.0f;
                          }
                          else
                          {
                              result = static_cast<float>(source_pixel[i]) / static_cast<float>(NL::max());
                          }
                      }
                      else
                      {
                          result = static_cast<float>(source_pixel[i]);
                      }
                      dest_pixel[i] = result;
                  }
  
                  for (size_t j = inputComponentCount; j < outputComponentCount; j++)
                  {
                      dest_pixel[j] = j == 3 ? 1.0f : 0.0f;
                  }
              }
          }
      }
  }
  
  template <size_t blockWidth, size_t blockHeight, size_t blockDepth, size_t blockSize>
  inline void LoadCompressedToNative(const ImageLoadContext &context, 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;
      const size_t layers = (depth + (blockDepth - 1)) / blockDepth;
  
      for (size_t z = 0; z < layers; ++z)
      {
          for (size_t y = 0; y < rows; ++y)
          {
              const uint8_t *source = priv::OffsetDataPointer<uint8_t>(input, y, z, inputRowPitch, inputDepthPitch);
              uint8_t *dest = priv::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 = priv::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);
              }
          }
      }
  }
  
  template <size_t blockWidth, size_t blockHeight>
  inline void LoadASTCToRGBA8(const ImageLoadContext &context,
                              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)
  {
      LoadASTCToRGBA8Inner(context, width, height, depth, blockWidth, blockHeight, input, inputRowPitch,
                           inputDepthPitch, output, outputRowPitch, outputDepthPitch);
  }
  
  template <uint32_t indexBits, uint32_t redBlueBits, uint32_t greenBits, uint32_t alphaBits>
  inline void LoadPalettedToRGBA8(const ImageLoadContext &context,
                                  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)
  {
      static_assert(indexBits == 4 || indexBits == 8);
      static_assert(redBlueBits == 4 || redBlueBits == 5 || redBlueBits == 8);
      static_assert(greenBits == 4 || greenBits == 5 || greenBits == 6 || greenBits == 8);
      static_assert(alphaBits == 0 || alphaBits == 1 || alphaBits == 4 || alphaBits == 8);
      constexpr uint32_t colorBits = 2 * redBlueBits + greenBits + alphaBits;
      static_assert(colorBits == 16 || colorBits == 24 || colorBits == 32);
  
      LoadPalettedToRGBA8Impl(context, width, height, depth,
                              indexBits, redBlueBits, greenBits, alphaBits,
                              input, inputRowPitch, inputDepthPitch,
                              output, outputRowPitch, outputDepthPitch);
  }
  
  // Temporary overload functions; need to have no-context overloads of the following functions used
  // by Chromium.  A Chromium change will switch to the with-context overloads, and then these can be
  // removed.
  inline void LoadEACR11ToR8(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)
  {
      LoadEACR11ToR8({}, width, height, depth, input, inputRowPitch, inputDepthPitch, output,
                     outputRowPitch, outputDepthPitch);
  }
  
  inline void LoadEACR11SToR8(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)
  {
      LoadEACR11SToR8({}, width, height, depth, input, inputRowPitch, inputDepthPitch, output,
                      outputRowPitch, outputDepthPitch);
  }
  
  inline void LoadEACRG11ToRG8(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)
  {
      LoadEACRG11ToRG8({}, width, height, depth, input, inputRowPitch, inputDepthPitch, output,
                       outputRowPitch, outputDepthPitch);
  }
  
  inline void LoadEACRG11SToRG8(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)
  {
      LoadEACRG11SToRG8({}, width, height, depth, input, inputRowPitch, inputDepthPitch, output,
                        outputRowPitch, outputDepthPitch);
  }
  
  inline void LoadETC2RGB8ToRGBA8(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)
  {
      LoadETC2RGB8ToRGBA8({}, width, height, depth, input, inputRowPitch, inputDepthPitch, output,
                          outputRowPitch, outputDepthPitch);
  }
  
  inline void LoadETC2SRGB8ToRGBA8(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)
  {
      LoadETC2SRGB8ToRGBA8({}, width, height, depth, input, inputRowPitch, inputDepthPitch, output,
                           outputRowPitch, outputDepthPitch);
  }
  
  inline void LoadETC2RGBA8ToRGBA8(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)
  {
      LoadETC2RGBA8ToRGBA8({}, width, height, depth, input, inputRowPitch, inputDepthPitch, output,
                           outputRowPitch, outputDepthPitch);
  }
  
  inline void LoadETC2RGB8A1ToRGBA8(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)
  {
      LoadETC2RGB8A1ToRGBA8({}, width, height, depth, input, inputRowPitch, inputDepthPitch, output,
                            outputRowPitch, outputDepthPitch);
  }
  
  inline void LoadETC2SRGBA8ToSRGBA8(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)
  {
      LoadETC2SRGBA8ToSRGBA8({}, width, height, depth, input, inputRowPitch, inputDepthPitch, output,
                             outputRowPitch, outputDepthPitch);
  }
  
  inline void LoadETC2SRGB8A1ToRGBA8(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)
  {
      LoadETC2SRGB8A1ToRGBA8({}, width, height, depth, input, inputRowPitch, inputDepthPitch, output,
                             outputRowPitch, outputDepthPitch);
  }
  
  } // namespace angle
  

Download