kc3-lang/angle/src/libANGLE/renderer/renderer_utils.h

• Show log

  Commit

• Hash : d93cd6c2
  Author :
  Date : 2017-08-11T16:32:41
  

  Refactor the CPU copy texture code into a function in renderer utils.
  
  BUG=angleproject:1932
  
  Change-Id: Iab79f2a09c2d8a85d2a9dde34acf4d2151072c2b
  Reviewed-on: https://chromium-review.googlesource.com/612561
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Commit-Queue: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/renderer/renderer_utils.h

• //
  // Copyright 2016 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.
  //
  // renderer_utils:
  //   Helper methods pertaining to most or all back-ends.
  //
  
  #ifndef LIBANGLE_RENDERER_RENDERER_UTILS_H_
  #define LIBANGLE_RENDERER_RENDERER_UTILS_H_
  
  #include <cstdint>
  
  #include <limits>
  #include <map>
  
  #include "common/angleutils.h"
  #include "libANGLE/angletypes.h"
  
  namespace angle
  {
  struct Format;
  }  // namespace angle
  
  namespace gl
  {
  struct FormatType;
  struct InternalFormat;
  }  // namespace gl
  
  namespace egl
  {
  class AttributeMap;
  }  // namespace egl
  
  namespace rx
  {
  
  class ResourceSerial
  {
    public:
      constexpr ResourceSerial() : mValue(kDirty) {}
      constexpr ResourceSerial(uintptr_t value) : mValue(value) {}
      constexpr bool operator==(ResourceSerial other) const { return mValue == other.mValue; }
      constexpr bool operator!=(ResourceSerial other) const { return mValue != other.mValue; }
  
      void dirty() { mValue = kDirty; }
  
    private:
      constexpr static uintptr_t kDirty = std::numeric_limits<uintptr_t>::max();
  
      uintptr_t mValue;
  };
  
  class SerialFactory;
  
  class Serial final
  {
    public:
      constexpr Serial() : mValue(0) {}
      constexpr Serial(const Serial &other) = default;
      Serial &operator=(const Serial &other) = default;
  
      constexpr bool operator==(const Serial &other) const { return mValue == other.mValue; }
      constexpr bool operator!=(const Serial &other) const { return mValue != other.mValue; }
      constexpr bool operator>(const Serial &other) const { return mValue > other.mValue; }
      constexpr bool operator>=(const Serial &other) const { return mValue >= other.mValue; }
      constexpr bool operator<(const Serial &other) const { return mValue < other.mValue; }
      constexpr bool operator<=(const Serial &other) const { return mValue <= other.mValue; }
  
    private:
      friend class SerialFactory;
      constexpr explicit Serial(uint64_t value) : mValue(value) {}
      uint64_t mValue;
  };
  
  class SerialFactory final : angle::NonCopyable
  {
    public:
      SerialFactory() : mSerial(1) {}
  
      Serial generate()
      {
          ASSERT(mSerial != std::numeric_limits<uint64_t>::max());
          return Serial(mSerial++);
      }
  
    private:
      uint64_t mSerial;
  };
  
  using MipGenerationFunction = void (*)(size_t sourceWidth,
                                         size_t sourceHeight,
                                         size_t sourceDepth,
                                         const uint8_t *sourceData,
                                         size_t sourceRowPitch,
                                         size_t sourceDepthPitch,
                                         uint8_t *destData,
                                         size_t destRowPitch,
                                         size_t destDepthPitch);
  
  typedef void (*ColorReadFunction)(const uint8_t *source, uint8_t *dest);
  typedef void (*ColorWriteFunction)(const uint8_t *source, uint8_t *dest);
  typedef void (*ColorCopyFunction)(const uint8_t *source, uint8_t *dest);
  
  class FastCopyFunctionMap
  {
    public:
      struct Entry
      {
          GLenum format;
          GLenum type;
          ColorCopyFunction func;
      };
  
      constexpr FastCopyFunctionMap() : FastCopyFunctionMap(nullptr, 0) {}
  
      constexpr FastCopyFunctionMap(const Entry *data, size_t size) : mSize(size), mData(data) {}
  
      bool has(const gl::FormatType &formatType) const;
      ColorCopyFunction get(const gl::FormatType &formatType) const;
  
    private:
      size_t mSize;
      const Entry *mData;
  };
  
  struct PackPixelsParams : private angle::NonCopyable
  {
      PackPixelsParams();
      PackPixelsParams(const gl::Rectangle &area,
                       GLenum format,
                       GLenum type,
                       GLuint outputPitch,
                       const gl::PixelPackState &pack,
                       ptrdiff_t offset);
      PackPixelsParams(const gl::Context *context, const PackPixelsParams &other);
  
      gl::Rectangle area;
      GLenum format;
      GLenum type;
      GLuint outputPitch;
      gl::Buffer *packBuffer;
      gl::PixelPackState pack;
      ptrdiff_t offset;
  };
  
  void PackPixels(const PackPixelsParams &params,
                  const angle::Format &sourceFormat,
                  int inputPitch,
                  const uint8_t *source,
                  uint8_t *destination);
  
  ColorWriteFunction GetColorWriteFunction(const gl::FormatType &formatType);
  ColorCopyFunction GetFastCopyFunction(const FastCopyFunctionMap &fastCopyFunctions,
                                        const gl::FormatType &formatType);
  
  using InitializeTextureDataFunction = void (*)(size_t width,
                                                 size_t height,
                                                 size_t depth,
                                                 uint8_t *output,
                                                 size_t outputRowPitch,
                                                 size_t outputDepthPitch);
  
  using LoadImageFunction = void (*)(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);
  
  struct LoadImageFunctionInfo
  {
      LoadImageFunctionInfo() : loadFunction(nullptr), requiresConversion(false) {}
      LoadImageFunctionInfo(LoadImageFunction loadFunction, bool requiresConversion)
          : loadFunction(loadFunction), requiresConversion(requiresConversion)
      {
      }
  
      LoadImageFunction loadFunction;
      bool requiresConversion;
  };
  
  using LoadFunctionMap = LoadImageFunctionInfo (*)(GLenum);
  
  bool ShouldUseDebugLayers(const egl::AttributeMap &attribs);
  
  void CopyImageCHROMIUM(const uint8_t *sourceData,
                         size_t sourceRowPitch,
                         size_t sourcePixelBytes,
                         ColorReadFunction readFunction,
                         uint8_t *destData,
                         size_t destRowPitch,
                         size_t destPixelBytes,
                         ColorWriteFunction colorWriteFunction,
                         GLenum destUnsizedFormat,
                         GLenum destComponentType,
                         size_t width,
                         size_t height,
                         bool unpackFlipY,
                         bool unpackPremultiplyAlpha,
                         bool unpackUnmultiplyAlpha);
  
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_RENDERER_UTILS_H_
  

Download