| /* |
| * Copyright 2017 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #ifndef GrBackendSurface_DEFINED |
| #define GrBackendSurface_DEFINED |
| |
| // This include of GrBackendSurfaceMutableState is not needed here, but some clients were depending |
| // on the include here instead of including it themselves. Adding this back here until we can fix |
| // up clients so it can be removed. |
| #include "include/gpu/GrBackendSurfaceMutableState.h" |
| |
| #include "include/gpu/GrSurfaceInfo.h" |
| #include "include/gpu/GrTypes.h" |
| #include "include/gpu/MutableTextureState.h" |
| #ifdef SK_GL |
| #include "include/gpu/gl/GrGLTypes.h" |
| #include "include/private/gpu/ganesh/GrGLTypesPriv.h" |
| #endif |
| #include "include/gpu/mock/GrMockTypes.h" |
| #ifdef SK_VULKAN |
| #include "include/gpu/vk/GrVkTypes.h" |
| #include "include/private/gpu/ganesh/GrVkTypesPriv.h" |
| #endif |
| |
| #ifdef SK_DAWN |
| #include "include/gpu/dawn/GrDawnTypes.h" |
| #endif |
| |
| #include <string> |
| |
| class GrVkImageLayout; |
| class GrGLTextureParameters; |
| class GrColorFormatDesc; |
| |
| namespace skgpu { |
| class MutableTextureStateRef; |
| } |
| |
| #ifdef SK_DAWN |
| #include "webgpu/webgpu_cpp.h" |
| #endif |
| |
| #ifdef SK_METAL |
| #include "include/gpu/mtl/GrMtlTypes.h" |
| #endif |
| |
| #ifdef SK_DIRECT3D |
| #include "include/private/gpu/ganesh/GrD3DTypesMinimal.h" |
| class GrD3DResourceState; |
| #endif |
| |
| #if defined(SK_DEBUG) || GR_TEST_UTILS |
| class SkString; |
| #endif |
| |
| #if !SK_SUPPORT_GPU |
| |
| // SkSurfaceCharacterization always needs a minimal version of this |
| class SK_API GrBackendFormat { |
| public: |
| bool isValid() const { return false; } |
| }; |
| |
| // SkSurface and SkImage rely on a minimal version of these always being available |
| class SK_API GrBackendTexture { |
| public: |
| GrBackendTexture() {} |
| |
| bool isValid() const { return false; } |
| }; |
| |
| class SK_API GrBackendRenderTarget { |
| public: |
| GrBackendRenderTarget() {} |
| |
| bool isValid() const { return false; } |
| bool isFramebufferOnly() const { return false; } |
| }; |
| #else |
| |
| enum class GrGLFormat; |
| |
| class SK_API GrBackendFormat { |
| public: |
| // Creates an invalid backend format. |
| GrBackendFormat() {} |
| GrBackendFormat(const GrBackendFormat&); |
| GrBackendFormat& operator=(const GrBackendFormat&); |
| |
| #ifdef SK_GL |
| static GrBackendFormat MakeGL(GrGLenum format, GrGLenum target) { |
| return GrBackendFormat(format, target); |
| } |
| #endif |
| |
| #ifdef SK_VULKAN |
| static GrBackendFormat MakeVk(VkFormat format, bool willUseDRMFormatModifiers = false) { |
| return GrBackendFormat(format, GrVkYcbcrConversionInfo(), willUseDRMFormatModifiers); |
| } |
| |
| static GrBackendFormat MakeVk(const GrVkYcbcrConversionInfo& ycbcrInfo, |
| bool willUseDRMFormatModifiers = false); |
| #endif |
| |
| #ifdef SK_DAWN |
| static GrBackendFormat MakeDawn(wgpu::TextureFormat format) { |
| return GrBackendFormat(format); |
| } |
| #endif |
| |
| #ifdef SK_METAL |
| static GrBackendFormat MakeMtl(GrMTLPixelFormat format) { |
| return GrBackendFormat(format); |
| } |
| #endif |
| |
| #ifdef SK_DIRECT3D |
| static GrBackendFormat MakeDxgi(DXGI_FORMAT format) { |
| return GrBackendFormat(format); |
| } |
| #endif |
| |
| static GrBackendFormat MakeMock(GrColorType colorType, SkImage::CompressionType compression, |
| bool isStencilFormat = false); |
| |
| bool operator==(const GrBackendFormat& that) const; |
| bool operator!=(const GrBackendFormat& that) const { return !(*this == that); } |
| |
| GrBackendApi backend() const { return fBackend; } |
| GrTextureType textureType() const { return fTextureType; } |
| |
| /** |
| * Gets the channels present in the format as a bitfield of SkColorChannelFlag values. |
| * Luminance channels are reported as kGray_SkColorChannelFlag. |
| */ |
| uint32_t channelMask() const; |
| |
| GrColorFormatDesc desc() const; |
| |
| #ifdef SK_GL |
| /** |
| * If the backend API is GL this gets the format as a GrGLFormat. Otherwise, returns |
| * GrGLFormat::kUnknown. |
| */ |
| GrGLFormat asGLFormat() const; |
| |
| GrGLenum asGLFormatEnum() const; |
| #endif |
| |
| #ifdef SK_VULKAN |
| /** |
| * If the backend API is Vulkan this gets the format as a VkFormat and returns true. Otherwise, |
| * returns false. |
| */ |
| bool asVkFormat(VkFormat*) const; |
| |
| const GrVkYcbcrConversionInfo* getVkYcbcrConversionInfo() const; |
| #endif |
| |
| #ifdef SK_DAWN |
| /** |
| * If the backend API is Dawn this gets the format as a wgpu::TextureFormat and returns true. |
| * Otherwise, returns false. |
| */ |
| bool asDawnFormat(wgpu::TextureFormat*) const; |
| #endif |
| |
| #ifdef SK_METAL |
| /** |
| * If the backend API is Metal this gets the format as a GrMtlPixelFormat. Otherwise, |
| * Otherwise, returns MTLPixelFormatInvalid. |
| */ |
| GrMTLPixelFormat asMtlFormat() const; |
| #endif |
| |
| #ifdef SK_DIRECT3D |
| /** |
| * If the backend API is Direct3D this gets the format as a DXGI_FORMAT and returns true. |
| * Otherwise, returns false. |
| */ |
| bool asDxgiFormat(DXGI_FORMAT*) const; |
| #endif |
| |
| /** |
| * If the backend API is not Mock these three calls will return kUnknown, kNone or false, |
| * respectively. Otherwise, only one of the following can be true. The GrColorType is not |
| * kUnknown, the compression type is not kNone, or this is a mock stencil format. |
| */ |
| GrColorType asMockColorType() const; |
| SkImage::CompressionType asMockCompressionType() const; |
| bool isMockStencilFormat() const; |
| |
| // If possible, copies the GrBackendFormat and forces the texture type to be Texture2D. If the |
| // GrBackendFormat was for Vulkan and it originally had a GrVkYcbcrConversionInfo, we will |
| // remove the conversion and set the format to be VK_FORMAT_R8G8B8A8_UNORM. |
| GrBackendFormat makeTexture2D() const; |
| |
| // Returns true if the backend format has been initialized. |
| bool isValid() const { return fValid; } |
| |
| #if defined(SK_DEBUG) || GR_TEST_UTILS |
| SkString toStr() const; |
| #endif |
| |
| private: |
| #ifdef SK_GL |
| GrBackendFormat(GrGLenum format, GrGLenum target); |
| #endif |
| |
| #ifdef SK_VULKAN |
| GrBackendFormat(const VkFormat vkFormat, const GrVkYcbcrConversionInfo&, |
| bool willUseDRMFormatModifiers); |
| #endif |
| |
| #ifdef SK_DAWN |
| GrBackendFormat(wgpu::TextureFormat format); |
| #endif |
| |
| #ifdef SK_METAL |
| GrBackendFormat(const GrMTLPixelFormat mtlFormat); |
| #endif |
| |
| #ifdef SK_DIRECT3D |
| GrBackendFormat(DXGI_FORMAT dxgiFormat); |
| #endif |
| |
| GrBackendFormat(GrColorType, SkImage::CompressionType, bool isStencilFormat); |
| |
| #ifdef SK_DEBUG |
| bool validateMock() const; |
| #endif |
| |
| GrBackendApi fBackend = GrBackendApi::kMock; |
| bool fValid = false; |
| |
| union { |
| #ifdef SK_GL |
| GrGLenum fGLFormat; // the sized, internal format of the GL resource |
| #endif |
| #ifdef SK_VULKAN |
| struct { |
| VkFormat fFormat; |
| GrVkYcbcrConversionInfo fYcbcrConversionInfo; |
| } fVk; |
| #endif |
| #ifdef SK_DAWN |
| wgpu::TextureFormat fDawnFormat; |
| #endif |
| |
| #ifdef SK_METAL |
| GrMTLPixelFormat fMtlFormat; |
| #endif |
| |
| #ifdef SK_DIRECT3D |
| DXGI_FORMAT fDxgiFormat; |
| #endif |
| struct { |
| GrColorType fColorType; |
| SkImage::CompressionType fCompressionType; |
| bool fIsStencilFormat; |
| } fMock; |
| }; |
| GrTextureType fTextureType = GrTextureType::kNone; |
| }; |
| |
| class SK_API GrBackendTexture { |
| public: |
| // Creates an invalid backend texture. |
| GrBackendTexture(); |
| |
| #ifdef SK_GL |
| // The GrGLTextureInfo must have a valid fFormat. |
| GrBackendTexture(int width, |
| int height, |
| GrMipmapped, |
| const GrGLTextureInfo& glInfo, |
| std::string_view label = {}); |
| #endif |
| |
| #ifdef SK_VULKAN |
| GrBackendTexture(int width, |
| int height, |
| const GrVkImageInfo& vkInfo, |
| std::string_view label = {}); |
| #endif |
| |
| #ifdef SK_METAL |
| GrBackendTexture(int width, |
| int height, |
| GrMipmapped, |
| const GrMtlTextureInfo& mtlInfo, |
| std::string_view label = {}); |
| #endif |
| |
| #ifdef SK_DIRECT3D |
| GrBackendTexture(int width, |
| int height, |
| const GrD3DTextureResourceInfo& d3dInfo, |
| std::string_view label = {}); |
| #endif |
| |
| #ifdef SK_DAWN |
| GrBackendTexture(int width, |
| int height, |
| const GrDawnTextureInfo& dawnInfo, |
| std::string_view label = {}); |
| #endif |
| |
| GrBackendTexture(int width, |
| int height, |
| GrMipmapped, |
| const GrMockTextureInfo& mockInfo, |
| std::string_view label = {}); |
| |
| GrBackendTexture(const GrBackendTexture& that); |
| |
| ~GrBackendTexture(); |
| |
| GrBackendTexture& operator=(const GrBackendTexture& that); |
| |
| SkISize dimensions() const { return {fWidth, fHeight}; } |
| int width() const { return fWidth; } |
| int height() const { return fHeight; } |
| std::string_view getLabel() const { return fLabel; } |
| GrMipmapped mipmapped() const { return fMipmapped; } |
| bool hasMipmaps() const { return fMipmapped == GrMipmapped::kYes; } |
| /** deprecated alias of hasMipmaps(). */ |
| bool hasMipMaps() const { return this->hasMipmaps(); } |
| GrBackendApi backend() const {return fBackend; } |
| GrTextureType textureType() const { return fTextureType; } |
| |
| #ifdef SK_GL |
| // If the backend API is GL, copies a snapshot of the GrGLTextureInfo struct into the passed in |
| // pointer and returns true. Otherwise returns false if the backend API is not GL. |
| bool getGLTextureInfo(GrGLTextureInfo*) const; |
| |
| // Call this to indicate that the texture parameters have been modified in the GL context |
| // externally to GrContext. |
| void glTextureParametersModified(); |
| #endif |
| |
| #ifdef SK_DAWN |
| // If the backend API is Dawn, copies a snapshot of the GrDawnTextureInfo struct into the passed |
| // in pointer and returns true. Otherwise returns false if the backend API is not Dawn. |
| bool getDawnTextureInfo(GrDawnTextureInfo*) const; |
| #endif |
| |
| #ifdef SK_VULKAN |
| // If the backend API is Vulkan, copies a snapshot of the GrVkImageInfo struct into the passed |
| // in pointer and returns true. This snapshot will set the fImageLayout to the current layout |
| // state. Otherwise returns false if the backend API is not Vulkan. |
| bool getVkImageInfo(GrVkImageInfo*) const; |
| |
| // Anytime the client changes the VkImageLayout of the VkImage captured by this |
| // GrBackendTexture, they must call this function to notify Skia of the changed layout. |
| void setVkImageLayout(VkImageLayout); |
| #endif |
| |
| #ifdef SK_METAL |
| // If the backend API is Metal, copies a snapshot of the GrMtlTextureInfo struct into the passed |
| // in pointer and returns true. Otherwise returns false if the backend API is not Metal. |
| bool getMtlTextureInfo(GrMtlTextureInfo*) const; |
| #endif |
| |
| #ifdef SK_DIRECT3D |
| // If the backend API is Direct3D, copies a snapshot of the GrD3DTextureResourceInfo struct into |
| // the passed in pointer and returns true. This snapshot will set the fResourceState to the |
| // current resource state. Otherwise returns false if the backend API is not D3D. |
| bool getD3DTextureResourceInfo(GrD3DTextureResourceInfo*) const; |
| |
| // Anytime the client changes the D3D12_RESOURCE_STATES of the D3D12_RESOURCE captured by this |
| // GrBackendTexture, they must call this function to notify Skia of the changed layout. |
| void setD3DResourceState(GrD3DResourceStateEnum); |
| #endif |
| |
| // Get the GrBackendFormat for this texture (or an invalid format if this is not valid). |
| GrBackendFormat getBackendFormat() const; |
| |
| // If the backend API is Mock, copies a snapshot of the GrMockTextureInfo struct into the passed |
| // in pointer and returns true. Otherwise returns false if the backend API is not Mock. |
| bool getMockTextureInfo(GrMockTextureInfo*) const; |
| |
| // If the client changes any of the mutable backend of the GrBackendTexture they should call |
| // this function to inform Skia that those values have changed. The backend API specific state |
| // that can be set from this function are: |
| // |
| // Vulkan: VkImageLayout and QueueFamilyIndex |
| void setMutableState(const skgpu::MutableTextureState&); |
| |
| // Returns true if we are working with protected content. |
| bool isProtected() const; |
| |
| // Returns true if the backend texture has been initialized. |
| bool isValid() const { return fIsValid; } |
| |
| // Returns true if both textures are valid and refer to the same API texture. |
| bool isSameTexture(const GrBackendTexture&); |
| |
| #if GR_TEST_UTILS |
| static bool TestingOnly_Equals(const GrBackendTexture& , const GrBackendTexture&); |
| #endif |
| |
| private: |
| friend class GrVkGpu; // for getMutableState |
| sk_sp<skgpu::MutableTextureStateRef> getMutableState() const; |
| |
| #ifdef SK_GL |
| friend class GrGLTexture; |
| friend class GrGLGpu; // for getGLTextureParams |
| GrBackendTexture(int width, |
| int height, |
| GrMipmapped, |
| const GrGLTextureInfo, |
| sk_sp<GrGLTextureParameters>, |
| std::string_view label = {}); |
| sk_sp<GrGLTextureParameters> getGLTextureParams() const; |
| #endif |
| |
| #ifdef SK_VULKAN |
| friend class GrVkTexture; |
| GrBackendTexture(int width, |
| int height, |
| const GrVkImageInfo& vkInfo, |
| sk_sp<skgpu::MutableTextureStateRef> mutableState, |
| std::string_view label = {}); |
| #endif |
| |
| #ifdef SK_DIRECT3D |
| friend class GrD3DTexture; |
| friend class GrD3DGpu; // for getGrD3DResourceState |
| GrBackendTexture(int width, |
| int height, |
| const GrD3DTextureResourceInfo& vkInfo, |
| sk_sp<GrD3DResourceState> state, |
| std::string_view label = {}); |
| sk_sp<GrD3DResourceState> getGrD3DResourceState() const; |
| #endif |
| |
| // Free and release and resources being held by the GrBackendTexture. |
| void cleanup(); |
| |
| bool fIsValid; |
| int fWidth; //<! width in pixels |
| int fHeight; //<! height in pixels |
| const std::string fLabel; |
| GrMipmapped fMipmapped; |
| GrBackendApi fBackend; |
| GrTextureType fTextureType; |
| |
| union { |
| #ifdef SK_GL |
| GrGLBackendTextureInfo fGLInfo; |
| #endif |
| #ifdef SK_VULKAN |
| GrVkBackendSurfaceInfo fVkInfo; |
| #endif |
| GrMockTextureInfo fMockInfo; |
| #ifdef SK_DIRECT3D |
| GrD3DBackendSurfaceInfo fD3DInfo; |
| #endif |
| }; |
| #ifdef SK_METAL |
| GrMtlTextureInfo fMtlInfo; |
| #endif |
| #ifdef SK_DAWN |
| GrDawnTextureInfo fDawnInfo; |
| #endif |
| |
| sk_sp<skgpu::MutableTextureStateRef> fMutableState; |
| }; |
| |
| class SK_API GrBackendRenderTarget { |
| public: |
| // Creates an invalid backend texture. |
| GrBackendRenderTarget(); |
| |
| #ifdef SK_GL |
| // The GrGLTextureInfo must have a valid fFormat. If wrapping in an SkSurface we require the |
| // stencil bits to be either 0, 8 or 16. |
| GrBackendRenderTarget(int width, |
| int height, |
| int sampleCnt, |
| int stencilBits, |
| const GrGLFramebufferInfo& glInfo); |
| #endif |
| |
| #ifdef SK_DAWN |
| // If wrapping in an SkSurface we require the stencil bits to be either 0, 8 or 16. |
| GrBackendRenderTarget(int width, |
| int height, |
| int sampleCnt, |
| int stencilBits, |
| const GrDawnRenderTargetInfo& dawnInfo); |
| #endif |
| |
| #ifdef SK_VULKAN |
| /** Deprecated. Sample count is now part of GrVkImageInfo. */ |
| GrBackendRenderTarget(int width, int height, int sampleCnt, const GrVkImageInfo& vkInfo); |
| |
| GrBackendRenderTarget(int width, int height, const GrVkImageInfo& vkInfo); |
| #endif |
| |
| #ifdef SK_METAL |
| GrBackendRenderTarget(int width, |
| int height, |
| const GrMtlTextureInfo& mtlInfo); |
| /** Deprecated. Sample count is ignored and is instead retrieved from the MtlTexture. */ |
| GrBackendRenderTarget(int width, |
| int height, |
| int sampleCnt, |
| const GrMtlTextureInfo& mtlInfo); |
| #endif |
| |
| #ifdef SK_DIRECT3D |
| GrBackendRenderTarget(int width, |
| int height, |
| const GrD3DTextureResourceInfo& d3dInfo); |
| #endif |
| |
| GrBackendRenderTarget(int width, |
| int height, |
| int sampleCnt, |
| int stencilBits, |
| const GrMockRenderTargetInfo& mockInfo); |
| |
| ~GrBackendRenderTarget(); |
| |
| GrBackendRenderTarget(const GrBackendRenderTarget& that); |
| GrBackendRenderTarget& operator=(const GrBackendRenderTarget&); |
| |
| SkISize dimensions() const { return {fWidth, fHeight}; } |
| int width() const { return fWidth; } |
| int height() const { return fHeight; } |
| int sampleCnt() const { return fSampleCnt; } |
| int stencilBits() const { return fStencilBits; } |
| GrBackendApi backend() const {return fBackend; } |
| bool isFramebufferOnly() const { return fFramebufferOnly; } |
| |
| #ifdef SK_GL |
| // If the backend API is GL, copies a snapshot of the GrGLFramebufferInfo struct into the passed |
| // in pointer and returns true. Otherwise returns false if the backend API is not GL. |
| bool getGLFramebufferInfo(GrGLFramebufferInfo*) const; |
| #endif |
| |
| #ifdef SK_DAWN |
| // If the backend API is Dawn, copies a snapshot of the GrDawnRenderTargetInfo struct into the |
| // passed-in pointer and returns true. Otherwise returns false if the backend API is not Dawn. |
| bool getDawnRenderTargetInfo(GrDawnRenderTargetInfo*) const; |
| #endif |
| |
| #ifdef SK_VULKAN |
| // If the backend API is Vulkan, copies a snapshot of the GrVkImageInfo struct into the passed |
| // in pointer and returns true. This snapshot will set the fImageLayout to the current layout |
| // state. Otherwise returns false if the backend API is not Vulkan. |
| bool getVkImageInfo(GrVkImageInfo*) const; |
| |
| // Anytime the client changes the VkImageLayout of the VkImage captured by this |
| // GrBackendRenderTarget, they must call this function to notify Skia of the changed layout. |
| void setVkImageLayout(VkImageLayout); |
| #endif |
| |
| #ifdef SK_METAL |
| // If the backend API is Metal, copies a snapshot of the GrMtlTextureInfo struct into the passed |
| // in pointer and returns true. Otherwise returns false if the backend API is not Metal. |
| bool getMtlTextureInfo(GrMtlTextureInfo*) const; |
| #endif |
| |
| #ifdef SK_DIRECT3D |
| // If the backend API is Direct3D, copies a snapshot of the GrMtlTextureInfo struct into the |
| // passed in pointer and returns true. Otherwise returns false if the backend API is not D3D. |
| bool getD3DTextureResourceInfo(GrD3DTextureResourceInfo*) const; |
| |
| // Anytime the client changes the D3D12_RESOURCE_STATES of the D3D12_RESOURCE captured by this |
| // GrBackendTexture, they must call this function to notify Skia of the changed layout. |
| void setD3DResourceState(GrD3DResourceStateEnum); |
| #endif |
| |
| // Get the GrBackendFormat for this render target (or an invalid format if this is not valid). |
| GrBackendFormat getBackendFormat() const; |
| |
| // If the backend API is Mock, copies a snapshot of the GrMockTextureInfo struct into the passed |
| // in pointer and returns true. Otherwise returns false if the backend API is not Mock. |
| bool getMockRenderTargetInfo(GrMockRenderTargetInfo*) const; |
| |
| // If the client changes any of the mutable backend of the GrBackendTexture they should call |
| // this function to inform Skia that those values have changed. The backend API specific state |
| // that can be set from this function are: |
| // |
| // Vulkan: VkImageLayout and QueueFamilyIndex |
| void setMutableState(const skgpu::MutableTextureState&); |
| |
| // Returns true if we are working with protected content. |
| bool isProtected() const; |
| |
| // Returns true if the backend texture has been initialized. |
| bool isValid() const { return fIsValid; } |
| |
| |
| #if GR_TEST_UTILS |
| static bool TestingOnly_Equals(const GrBackendRenderTarget&, const GrBackendRenderTarget&); |
| #endif |
| |
| private: |
| friend class GrVkGpu; // for getMutableState |
| sk_sp<skgpu::MutableTextureStateRef> getMutableState() const; |
| |
| #ifdef SK_VULKAN |
| friend class GrVkRenderTarget; |
| GrBackendRenderTarget(int width, |
| int height, |
| const GrVkImageInfo& vkInfo, |
| sk_sp<skgpu::MutableTextureStateRef> mutableState); |
| #endif |
| |
| #ifdef SK_DIRECT3D |
| friend class GrD3DGpu; |
| friend class GrD3DRenderTarget; |
| GrBackendRenderTarget(int width, |
| int height, |
| const GrD3DTextureResourceInfo& d3dInfo, |
| sk_sp<GrD3DResourceState> state); |
| sk_sp<GrD3DResourceState> getGrD3DResourceState() const; |
| #endif |
| |
| // Free and release and resources being held by the GrBackendTexture. |
| void cleanup(); |
| |
| bool fIsValid; |
| bool fFramebufferOnly = false; |
| int fWidth; //<! width in pixels |
| int fHeight; //<! height in pixels |
| |
| int fSampleCnt; |
| int fStencilBits; |
| |
| GrBackendApi fBackend; |
| |
| union { |
| #ifdef SK_GL |
| GrGLFramebufferInfo fGLInfo; |
| #endif |
| #ifdef SK_VULKAN |
| GrVkBackendSurfaceInfo fVkInfo; |
| #endif |
| GrMockRenderTargetInfo fMockInfo; |
| #ifdef SK_DIRECT3D |
| GrD3DBackendSurfaceInfo fD3DInfo; |
| #endif |
| }; |
| #ifdef SK_METAL |
| GrMtlTextureInfo fMtlInfo; |
| #endif |
| #ifdef SK_DAWN |
| GrDawnRenderTargetInfo fDawnInfo; |
| #endif |
| sk_sp<skgpu::MutableTextureStateRef> fMutableState; |
| }; |
| |
| #endif |
| |
| #endif |