| /* |
| * Copyright (C) 2011 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| #include <GLcommon/TextureUtils.h> |
| #include <GLcommon/GLESmacros.h> |
| #include <GLcommon/GLDispatch.h> |
| #include <GLcommon/GLESvalidate.h> |
| #include <stdio.h> |
| #include <cmath> |
| #include <memory> |
| |
| #include "aemu/base/AlignedBuf.h" |
| #include "compressedTextureFormats/AstcCpuDecompressor.h" |
| |
| using android::AlignedBuf; |
| using gfxstream::vk::AstcCpuDecompressor; |
| |
| #define GL_R16 0x822A |
| #define GL_RG16 0x822C |
| #define GL_R16_SNORM 0x8F98 |
| #define GL_RG16_SNORM 0x8F99 |
| |
| static constexpr size_t kASTCFormatsCount = 28; |
| |
| #define ASTC_FORMATS_LIST(EXPAND_MACRO) \ |
| EXPAND_MACRO(GL_COMPRESSED_RGBA_ASTC_4x4_KHR, 4, 4, false) \ |
| EXPAND_MACRO(GL_COMPRESSED_RGBA_ASTC_5x4_KHR, 5, 4, false) \ |
| EXPAND_MACRO(GL_COMPRESSED_RGBA_ASTC_5x5_KHR, 5, 5, false) \ |
| EXPAND_MACRO(GL_COMPRESSED_RGBA_ASTC_6x5_KHR, 6, 5, false) \ |
| EXPAND_MACRO(GL_COMPRESSED_RGBA_ASTC_6x6_KHR, 6, 6, false) \ |
| EXPAND_MACRO(GL_COMPRESSED_RGBA_ASTC_8x5_KHR, 8, 5, false) \ |
| EXPAND_MACRO(GL_COMPRESSED_RGBA_ASTC_8x6_KHR, 8, 6, false) \ |
| EXPAND_MACRO(GL_COMPRESSED_RGBA_ASTC_8x8_KHR, 8, 8, false) \ |
| EXPAND_MACRO(GL_COMPRESSED_RGBA_ASTC_10x5_KHR, 10, 5, false) \ |
| EXPAND_MACRO(GL_COMPRESSED_RGBA_ASTC_10x6_KHR, 10, 6, false) \ |
| EXPAND_MACRO(GL_COMPRESSED_RGBA_ASTC_10x8_KHR, 10, 8, false) \ |
| EXPAND_MACRO(GL_COMPRESSED_RGBA_ASTC_10x10_KHR, 10, 10, false) \ |
| EXPAND_MACRO(GL_COMPRESSED_RGBA_ASTC_12x10_KHR, 12, 10, false) \ |
| EXPAND_MACRO(GL_COMPRESSED_RGBA_ASTC_12x12_KHR, 12, 12, false) \ |
| EXPAND_MACRO(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, 4, 4, true) \ |
| EXPAND_MACRO(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, 5, 4, true) \ |
| EXPAND_MACRO(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, 5, 5, true) \ |
| EXPAND_MACRO(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, 6, 5, true) \ |
| EXPAND_MACRO(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, 6, 6, true) \ |
| EXPAND_MACRO(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, 8, 5, true) \ |
| EXPAND_MACRO(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, 8, 6, true) \ |
| EXPAND_MACRO(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, 8, 8, true) \ |
| EXPAND_MACRO(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, 10, 5, true) \ |
| EXPAND_MACRO(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, 10, 6, true) \ |
| EXPAND_MACRO(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, 10, 8, true) \ |
| EXPAND_MACRO(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, 10, 10, true) \ |
| EXPAND_MACRO(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, 12, 10, true) \ |
| EXPAND_MACRO(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, 12, 12, true) \ |
| |
| int getCompressedFormats(int majorVersion, int* formats) { |
| static constexpr size_t kCount = MAX_SUPPORTED_PALETTE + MAX_ETC_SUPPORTED + kASTCFormatsCount; |
| int res = kCount; |
| |
| if (majorVersion > 1) { |
| res -= MAX_SUPPORTED_PALETTE; |
| } |
| |
| if (formats) { |
| size_t i = 0; |
| |
| if (1 == majorVersion) { |
| // Palette |
| formats[i++] = GL_PALETTE4_RGBA8_OES; |
| formats[i++] = GL_PALETTE4_RGBA4_OES; |
| formats[i++] = GL_PALETTE8_RGBA8_OES; |
| formats[i++] = GL_PALETTE8_RGBA4_OES; |
| formats[i++] = GL_PALETTE4_RGB8_OES; |
| formats[i++] = GL_PALETTE8_RGB8_OES; |
| formats[i++] = GL_PALETTE4_RGB5_A1_OES; |
| formats[i++] = GL_PALETTE8_RGB5_A1_OES; |
| formats[i++] = GL_PALETTE4_R5_G6_B5_OES; |
| formats[i++] = GL_PALETTE8_R5_G6_B5_OES; |
| } |
| |
| // ETC |
| formats[i++] = GL_ETC1_RGB8_OES; |
| formats[i++] = GL_COMPRESSED_RGB8_ETC2; |
| formats[i++] = GL_COMPRESSED_SIGNED_R11_EAC; |
| formats[i++] = GL_COMPRESSED_RG11_EAC; |
| formats[i++] = GL_COMPRESSED_SIGNED_RG11_EAC; |
| formats[i++] = GL_COMPRESSED_RGB8_ETC2; |
| formats[i++] = GL_COMPRESSED_SRGB8_ETC2; |
| formats[i++] = GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2; |
| formats[i++] = GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2; |
| formats[i++] = GL_COMPRESSED_RGBA8_ETC2_EAC; |
| formats[i++] = GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC; |
| formats[i++] = GL_COMPRESSED_R11_EAC; |
| |
| // ASTC |
| #define ASTC_FORMAT(typeName, blockWidth, blockHeight, srgbValue) \ |
| formats[i++] = typeName; |
| |
| ASTC_FORMATS_LIST(ASTC_FORMAT) |
| #undef ASTC_FORMAT |
| |
| } |
| |
| return res; |
| } |
| |
| ETC2ImageFormat getEtcFormat(GLenum internalformat) { |
| ETC2ImageFormat etcFormat = EtcRGB8; |
| switch (internalformat) { |
| case GL_COMPRESSED_RGB8_ETC2: |
| case GL_ETC1_RGB8_OES: |
| break; |
| case GL_COMPRESSED_RGBA8_ETC2_EAC: |
| etcFormat = EtcRGBA8; |
| break; |
| case GL_COMPRESSED_SRGB8_ETC2: |
| break; |
| case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: |
| etcFormat = EtcRGBA8; |
| break; |
| case GL_COMPRESSED_R11_EAC: |
| etcFormat = EtcR11; |
| break; |
| case GL_COMPRESSED_SIGNED_R11_EAC: |
| etcFormat = EtcSignedR11; |
| break; |
| case GL_COMPRESSED_RG11_EAC: |
| etcFormat = EtcRG11; |
| break; |
| case GL_COMPRESSED_SIGNED_RG11_EAC: |
| etcFormat = EtcSignedRG11; |
| break; |
| case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: |
| etcFormat = EtcRGB8A1; |
| break; |
| case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: |
| etcFormat = EtcRGB8A1; |
| break; |
| } |
| return etcFormat; |
| } |
| |
| void getAstcFormatInfo(GLenum internalformat, uint32_t* width, uint32_t* height, bool* srgb) { |
| switch (internalformat) { |
| #define ASTC_FORMAT(typeName, blockWidth, blockHeight, srgbValue) \ |
| case typeName: \ |
| *width = blockWidth; *height = blockHeight; *srgb = srgbValue; break; \ |
| |
| ASTC_FORMATS_LIST(ASTC_FORMAT) |
| #undef ASTC_FORMAT |
| default: |
| assert(false && "Invalid ASTC format"); |
| break; |
| } |
| } |
| |
| // Helper function to decompress an ASTC image. |
| bool astcDecompress(const uint8_t* astcData, size_t astcDataSize, uint32_t width, uint32_t height, |
| uint32_t blockWidth, uint32_t blockHeight, uint8_t* outBuffer, |
| size_t outBufferSize) { |
| if (outBufferSize < width * height * 4) { |
| WARN("ASTC output buffer too small: %d bytes for %d x %d", outBufferSize, width, height); |
| return false; |
| } |
| int32_t status = AstcCpuDecompressor::get().decompress(width, height, blockWidth, blockHeight, |
| astcData, astcDataSize, outBuffer); |
| if (status != 0) { |
| WARN("astc decompression failed: %s", AstcCpuDecompressor::get().getStatusString(status)); |
| return false; |
| } |
| return true; |
| } |
| |
| bool isAstcFormat(GLenum internalformat) { |
| switch (internalformat) { |
| #define ASTC_FORMAT(typeName, blockWidth, blockHeight, srgbValue) \ |
| case typeName: |
| |
| ASTC_FORMATS_LIST(ASTC_FORMAT) |
| #undef ASTC_FORMAT |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool isEtcFormat(GLenum internalformat) { |
| switch (internalformat) { |
| case GL_ETC1_RGB8_OES: |
| case GL_COMPRESSED_RGB8_ETC2: |
| case GL_COMPRESSED_SRGB8_ETC2: |
| case GL_COMPRESSED_RGBA8_ETC2_EAC: |
| case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: |
| case GL_COMPRESSED_R11_EAC: |
| case GL_COMPRESSED_SIGNED_R11_EAC: |
| case GL_COMPRESSED_RG11_EAC: |
| case GL_COMPRESSED_SIGNED_RG11_EAC: |
| case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: |
| case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: |
| return true; |
| } |
| return false; |
| } |
| |
| bool isEtc2Format(GLenum internalformat) { |
| switch (internalformat) { |
| case GL_COMPRESSED_RGB8_ETC2: |
| case GL_COMPRESSED_SRGB8_ETC2: |
| case GL_COMPRESSED_RGBA8_ETC2_EAC: |
| case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: |
| case GL_COMPRESSED_R11_EAC: |
| case GL_COMPRESSED_SIGNED_R11_EAC: |
| case GL_COMPRESSED_RG11_EAC: |
| case GL_COMPRESSED_SIGNED_RG11_EAC: |
| case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: |
| case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: |
| return true; |
| } |
| return false; |
| } |
| |
| bool isBptcFormat(GLenum internalformat) { |
| switch (internalformat) { |
| case GL_COMPRESSED_RGBA_BPTC_UNORM_EXT: |
| case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT: |
| case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT: |
| case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT: |
| return true; |
| } |
| return false; |
| } |
| |
| bool isS3tcFormat(GLenum internalformat) { |
| switch (internalformat) { |
| case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: |
| case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: |
| case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: |
| case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: |
| case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT: |
| case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: |
| case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: |
| case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: |
| return true; |
| } |
| return false; |
| } |
| |
| bool isPaletteFormat(GLenum internalformat) { |
| switch (internalformat) { |
| case GL_PALETTE4_RGB8_OES: |
| case GL_PALETTE4_RGBA8_OES: |
| case GL_PALETTE4_R5_G6_B5_OES: |
| case GL_PALETTE4_RGBA4_OES: |
| case GL_PALETTE4_RGB5_A1_OES: |
| case GL_PALETTE8_RGB8_OES: |
| case GL_PALETTE8_RGBA8_OES: |
| case GL_PALETTE8_R5_G6_B5_OES: |
| case GL_PALETTE8_RGBA4_OES: |
| case GL_PALETTE8_RGB5_A1_OES: |
| return true; |
| } |
| return false; |
| } |
| |
| GLenum decompressedInternalFormat(GLEScontext* ctx, GLenum compressedFormat) { |
| bool needSizedInternalFormat = |
| isCoreProfile() || |
| (ctx->getMajorVersion() >= 3); |
| |
| GLenum glrgb = needSizedInternalFormat ? GL_RGB8 : GL_RGB; |
| GLenum glrgba = needSizedInternalFormat ? GL_RGBA8 : GL_RGBA; |
| |
| switch (compressedFormat) { |
| // ETC2 formats |
| case GL_COMPRESSED_RGB8_ETC2: |
| case GL_ETC1_RGB8_OES: |
| return glrgb; |
| case GL_COMPRESSED_RGBA8_ETC2_EAC: |
| case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: |
| return glrgba; |
| case GL_COMPRESSED_SRGB8_ETC2: |
| return GL_SRGB8; |
| case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: |
| return GL_SRGB8_ALPHA8; |
| case GL_COMPRESSED_R11_EAC: |
| case GL_COMPRESSED_SIGNED_R11_EAC: |
| return GL_R32F; |
| case GL_COMPRESSED_RG11_EAC: |
| case GL_COMPRESSED_SIGNED_RG11_EAC: |
| return GL_RG32F; |
| case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: |
| return GL_SRGB8_ALPHA8; |
| // ASTC formats |
| case GL_COMPRESSED_RGBA_ASTC_4x4_KHR: |
| case GL_COMPRESSED_RGBA_ASTC_5x4_KHR: |
| case GL_COMPRESSED_RGBA_ASTC_5x5_KHR: |
| case GL_COMPRESSED_RGBA_ASTC_6x5_KHR: |
| case GL_COMPRESSED_RGBA_ASTC_6x6_KHR: |
| case GL_COMPRESSED_RGBA_ASTC_8x5_KHR: |
| case GL_COMPRESSED_RGBA_ASTC_8x6_KHR: |
| case GL_COMPRESSED_RGBA_ASTC_8x8_KHR: |
| case GL_COMPRESSED_RGBA_ASTC_10x5_KHR: |
| case GL_COMPRESSED_RGBA_ASTC_10x6_KHR: |
| case GL_COMPRESSED_RGBA_ASTC_10x8_KHR: |
| case GL_COMPRESSED_RGBA_ASTC_10x10_KHR: |
| case GL_COMPRESSED_RGBA_ASTC_12x10_KHR: |
| case GL_COMPRESSED_RGBA_ASTC_12x12_KHR: |
| return glrgba; |
| case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: |
| case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: |
| case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: |
| case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: |
| case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: |
| case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: |
| case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: |
| case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: |
| case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: |
| case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: |
| case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: |
| case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: |
| case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: |
| case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: |
| return GL_SRGB8_ALPHA8; |
| // palette formats |
| case GL_PALETTE4_RGB8_OES: |
| case GL_PALETTE4_R5_G6_B5_OES: |
| case GL_PALETTE8_RGB8_OES: |
| case GL_PALETTE8_R5_G6_B5_OES: |
| return glrgb; |
| case GL_PALETTE4_RGBA8_OES: |
| case GL_PALETTE4_RGBA4_OES: |
| case GL_PALETTE4_RGB5_A1_OES: |
| case GL_PALETTE8_RGBA8_OES: |
| case GL_PALETTE8_RGBA4_OES: |
| case GL_PALETTE8_RGB5_A1_OES: |
| return glrgba; |
| case GL_COMPRESSED_RED_RGTC1_EXT: // BC4U |
| return GL_R8; |
| case GL_COMPRESSED_SIGNED_RED_RGTC1_EXT: // BC4S |
| return GL_R8_SNORM; |
| case GL_COMPRESSED_RED_GREEN_RGTC2_EXT: // BC5U |
| return GL_RG8; |
| case GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: // BC5S |
| return GL_RG8_SNORM; |
| default: |
| return compressedFormat; |
| } |
| } |
| |
| class ScopedFetchUnpackData { |
| public: |
| ScopedFetchUnpackData(GLEScontext* ctx, GLintptr offset, |
| GLsizei dataSize) : mCtx(ctx) { |
| mData = ctx->dispatcher().glMapBufferRange( |
| GL_PIXEL_UNPACK_BUFFER, |
| offset, dataSize, GL_MAP_READ_BIT); |
| if (mData) { |
| ctx->dispatcher().glGetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, |
| &mUnpackBuffer); |
| ctx->dispatcher().glBindBuffer(GL_PIXEL_UNPACK_BUFFER, |
| 0); |
| } |
| } |
| ~ScopedFetchUnpackData() { |
| if (mData) { |
| mCtx->dispatcher().glBindBuffer(GL_PIXEL_UNPACK_BUFFER, |
| mUnpackBuffer); |
| mCtx->dispatcher().glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER); |
| } |
| } |
| void* data() { |
| return mData; |
| } |
| private: |
| const GLEScontext* mCtx; |
| void* mData = nullptr; |
| GLint mUnpackBuffer = 0; |
| }; |
| |
| void doCompressedTexImage2D(GLEScontext* ctx, GLenum target, GLint level, |
| GLenum internalformat, GLsizei width, |
| GLsizei height, GLint border, |
| GLsizei imageSize, const GLvoid* data, |
| glTexImage2D_t glTexImage2DPtr) { |
| /* XXX: This is just a hack to fix the resolve of glTexImage2D problem |
| It will be removed when we'll no longer link against ligGL */ |
| /*typedef void (GLAPIENTRY *glTexImage2DPtr_t ) ( |
| GLenum target, GLint level, GLint internalformat, |
| GLsizei width, GLsizei height, GLint border, |
| GLenum format, GLenum type, const GLvoid *pixels); |
| |
| glTexImage2DPtr_t glTexImage2DPtr; |
| glTexImage2DPtr = (glTexImage2DPtr_t)funcPtr;*/ |
| bool needUnpackBuffer = false; |
| if (ctx->getMajorVersion() >= 3) { |
| GLint unpackBuffer = 0; |
| ctx->dispatcher().glGetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, |
| &unpackBuffer); |
| needUnpackBuffer = unpackBuffer; |
| } |
| TextureUnpackReset unpack(ctx); |
| const int32_t unpackAlignment = TextureUnpackReset::kUnpackAlignment; |
| if (isEtcFormat(internalformat)) { |
| GLint format = GL_RGB; |
| GLint type = GL_UNSIGNED_BYTE; |
| GLint convertedInternalFormat = decompressedInternalFormat(ctx, internalformat); |
| ETC2ImageFormat etcFormat = EtcRGB8; |
| switch (internalformat) { |
| case GL_COMPRESSED_RGB8_ETC2: |
| case GL_ETC1_RGB8_OES: |
| break; |
| case GL_COMPRESSED_RGBA8_ETC2_EAC: |
| etcFormat = EtcRGBA8; |
| format = GL_RGBA; |
| break; |
| case GL_COMPRESSED_SRGB8_ETC2: |
| break; |
| case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: |
| etcFormat = EtcRGBA8; |
| format = GL_RGBA; |
| break; |
| case GL_COMPRESSED_R11_EAC: |
| etcFormat = EtcR11; |
| format = GL_RED; |
| type = GL_FLOAT; |
| break; |
| case GL_COMPRESSED_SIGNED_R11_EAC: |
| etcFormat = EtcSignedR11; |
| format = GL_RED; |
| type = GL_FLOAT; |
| break; |
| case GL_COMPRESSED_RG11_EAC: |
| etcFormat = EtcRG11; |
| format = GL_RG; |
| type = GL_FLOAT; |
| break; |
| case GL_COMPRESSED_SIGNED_RG11_EAC: |
| etcFormat = EtcSignedRG11; |
| format = GL_RG; |
| type = GL_FLOAT; |
| break; |
| case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: |
| etcFormat = EtcRGB8A1; |
| format = GL_RGBA; |
| break; |
| case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: |
| etcFormat = EtcRGB8A1; |
| format = GL_RGBA; |
| break; |
| } |
| int pixelSize = etc_get_decoded_pixel_size(etcFormat); |
| GLsizei compressedSize = |
| etc_get_encoded_data_size(etcFormat, width, height); |
| SET_ERROR_IF((compressedSize != imageSize), GL_INVALID_VALUE); |
| std::unique_ptr<ScopedFetchUnpackData> unpackData; |
| std::unique_ptr<char[]> emulatedData; |
| if (needUnpackBuffer) { |
| unpackData.reset(new ScopedFetchUnpackData(ctx, |
| reinterpret_cast<GLintptr>(data), compressedSize)); |
| data = unpackData->data(); |
| SET_ERROR_IF(!data, GL_INVALID_OPERATION); |
| } else { |
| if (!data) { |
| emulatedData.reset(new char[compressedSize]); |
| data = emulatedData.get(); |
| } |
| } |
| |
| const int32_t align = unpackAlignment - 1; |
| const int32_t bpr = ((width * pixelSize) + align) & ~align; |
| const size_t size = bpr * height; |
| std::unique_ptr<etc1_byte[]> pOut(new etc1_byte[size]); |
| |
| int res = |
| etc2_decode_image( |
| (const etc1_byte*)data, etcFormat, pOut.get(), |
| width, height, bpr); |
| SET_ERROR_IF(res!=0, GL_INVALID_VALUE); |
| |
| glTexImage2DPtr(target, level, convertedInternalFormat, |
| width, height, border, format, type, pOut.get()); |
| } else if (isAstcFormat(internalformat)) { |
| std::unique_ptr<ScopedFetchUnpackData> unpackData; |
| std::unique_ptr<char[]> emulatedData; |
| if (needUnpackBuffer) { |
| unpackData.reset( |
| new ScopedFetchUnpackData(ctx, reinterpret_cast<GLintptr>(data), imageSize)); |
| data = unpackData->data(); |
| SET_ERROR_IF(!data, GL_INVALID_OPERATION); |
| } else { |
| if (!data) { |
| emulatedData.reset(new char[imageSize]); |
| data = emulatedData.get(); |
| } |
| } |
| uint32_t blockWidth = 0; |
| uint32_t blockHeight = 0; |
| bool srgb; |
| getAstcFormatInfo(internalformat, &blockWidth, &blockHeight, &srgb); |
| |
| const int32_t align = unpackAlignment - 1; |
| const int32_t stride = ((width * 4) + align) & ~align; |
| const size_t size = stride * height; |
| |
| AlignedBuf<uint8_t, 64> alignedUncompressedData(size); |
| |
| const bool result = astcDecompress( |
| reinterpret_cast<const uint8_t*>(data), imageSize, width, |
| height, blockWidth, blockHeight, alignedUncompressedData.data(), size); |
| SET_ERROR_IF(!result, GL_INVALID_VALUE); |
| |
| glTexImage2DPtr(target, level, srgb ? GL_SRGB8_ALPHA8 : GL_RGBA8, width, |
| height, border, GL_RGBA, GL_UNSIGNED_BYTE, |
| alignedUncompressedData.data()); |
| } else if (isPaletteFormat(internalformat)) { |
| // TODO: fix the case when GL_PIXEL_UNPACK_BUFFER is bound |
| SET_ERROR_IF( |
| level > log2(ctx->getMaxTexSize()) || |
| border !=0 || level > 0 || |
| !GLESvalidate::texImgDim( |
| width, height, ctx->getMaxTexSize() + 2), |
| GL_INVALID_VALUE); |
| SET_ERROR_IF(!data,GL_INVALID_OPERATION); |
| //the decoder fully packed the pixels. |
| ctx->dispatcher().glPixelStorei(GL_UNPACK_ALIGNMENT, 1); |
| int nMipmaps = -level + 1; |
| GLsizei tmpWidth = width; |
| GLsizei tmpHeight = height; |
| |
| for(int i = 0; i < nMipmaps; i++) |
| { |
| GLenum uncompressedFrmt; |
| unsigned char* uncompressed = |
| uncompressTexture(internalformat, uncompressedFrmt, |
| width, height, imageSize, data, i); |
| glTexImage2DPtr(target, i, uncompressedFrmt, |
| tmpWidth, tmpHeight, border, |
| uncompressedFrmt, GL_UNSIGNED_BYTE, uncompressed); |
| tmpWidth /= 2; |
| tmpHeight /= 2; |
| delete [] uncompressed; |
| } |
| } else if (isRgtcFormat(internalformat)) { |
| GLint format, type; |
| GLint convertedInternalFormat = decompressedInternalFormat(ctx, internalformat); |
| RGTCImageFormat rgtcFormat; |
| switch (internalformat) { |
| case GL_COMPRESSED_RED_RGTC1_EXT: // BC4U |
| format = GL_RED; |
| type = GL_UNSIGNED_BYTE; |
| rgtcFormat = BC4_UNORM; |
| break; |
| case GL_COMPRESSED_SIGNED_RED_RGTC1_EXT: // BC4S |
| format = GL_RED; |
| type = GL_BYTE; |
| rgtcFormat = BC4_SNORM; |
| break; |
| case GL_COMPRESSED_RED_GREEN_RGTC2_EXT: // BC5U |
| format = GL_RG; |
| type = GL_UNSIGNED_BYTE; |
| rgtcFormat = BC5_UNORM; |
| break; |
| case GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: // BC5S |
| format = GL_RG; |
| type = GL_BYTE; |
| rgtcFormat = BC5_SNORM; |
| break; |
| } |
| size_t pixelSize = rgtc_get_decoded_pixel_size(rgtcFormat); |
| GLsizei compressedSize = rgtc_get_encoded_image_size(rgtcFormat, width, height); |
| SET_ERROR_IF((compressedSize != imageSize), GL_INVALID_VALUE); |
| std::unique_ptr<ScopedFetchUnpackData> unpackData; |
| std::unique_ptr<char[]> emulatedData; |
| if (needUnpackBuffer) { |
| unpackData.reset( |
| new ScopedFetchUnpackData(ctx, reinterpret_cast<GLintptr>(data), compressedSize)); |
| data = unpackData->data(); |
| SET_ERROR_IF(!data, GL_INVALID_OPERATION); |
| } else { |
| if (!data) { |
| emulatedData.reset(new char[compressedSize]); |
| data = emulatedData.get(); |
| } |
| } |
| const int32_t align = unpackAlignment - 1; |
| const int32_t bpr = ((width * pixelSize) + align) & ~align; |
| const size_t size = bpr * height; |
| std::unique_ptr<uint8_t[]> pOut(new uint8_t[size]); |
| |
| int res = |
| rgtc_decode_image((const uint8_t*)data, rgtcFormat, pOut.get(), width, height, bpr); |
| SET_ERROR_IF(res != 0, GL_INVALID_VALUE); |
| glTexImage2DPtr(target, level, convertedInternalFormat, width, height, border, format, type, |
| pOut.get()); |
| } else { |
| SET_ERROR_IF(1, GL_INVALID_ENUM); |
| } |
| } |
| |
| void deleteRenderbufferGlobal(GLuint rbo) { |
| if (rbo) { |
| GLEScontext::dispatcher().glDeleteRenderbuffers(1, &rbo); |
| } |
| } |
| |
| bool isCubeMapFaceTarget(GLenum target) { |
| switch (target) { |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_X: |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: |
| return true; |
| } |
| return false; |
| } |
| |
| bool isCoreProfileEmulatedFormat(GLenum format) { |
| switch (format) { |
| case GL_ALPHA: |
| case GL_LUMINANCE: |
| case GL_LUMINANCE_ALPHA: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| GLenum getCoreProfileEmulatedFormat(GLenum format) { |
| switch (format) { |
| case GL_ALPHA: |
| case GL_LUMINANCE: |
| return GL_RED; |
| case GL_LUMINANCE_ALPHA: |
| return GL_RG; |
| } |
| return format; |
| } |
| |
| GLint getCoreProfileEmulatedInternalFormat(GLint internalformat, GLenum type) { |
| switch (internalformat) { |
| case GL_ALPHA: |
| case GL_LUMINANCE: |
| switch (type) { |
| case GL_UNSIGNED_BYTE: |
| return GL_R8; |
| case GL_FLOAT: |
| return GL_R32F; |
| case GL_HALF_FLOAT: |
| return GL_R16F; |
| } |
| return GL_R8; |
| case GL_LUMINANCE_ALPHA: |
| switch (type) { |
| case GL_UNSIGNED_BYTE: |
| return GL_RG8; |
| case GL_FLOAT: |
| return GL_RG32F; |
| case GL_HALF_FLOAT: |
| return GL_RG16F; |
| } |
| return GL_RG8; |
| } |
| fprintf(stderr, |
| "%s: warning: unsupported alpha/luminance internal format 0x%x type 0x%x\n", |
| __func__, internalformat, type); |
| return GL_R8; |
| } |
| |
| TextureSwizzle getSwizzleForEmulatedFormat(GLenum format) { |
| TextureSwizzle res; |
| switch (format) { |
| case GL_ALPHA: |
| res.toRed = GL_ZERO; |
| res.toGreen = GL_ZERO; |
| res.toBlue = GL_ZERO; |
| res.toAlpha = GL_RED; |
| break; |
| case GL_LUMINANCE: |
| res.toRed = GL_RED; |
| res.toGreen = GL_RED; |
| res.toBlue = GL_RED; |
| res.toAlpha = GL_ONE; |
| break; |
| case GL_LUMINANCE_ALPHA: |
| res.toRed = GL_RED; |
| res.toGreen = GL_RED; |
| res.toBlue = GL_RED; |
| res.toAlpha = GL_GREEN; |
| break; |
| default: |
| break; |
| } |
| return res; |
| } |
| |
| // Inverse swizzle: if we were writing fragments back to this texture, |
| // how should the components be re-arranged? |
| TextureSwizzle getInverseSwizzleForEmulatedFormat(GLenum format) { |
| TextureSwizzle res; |
| switch (format) { |
| case GL_ALPHA: |
| res.toRed = GL_ALPHA; |
| res.toGreen = GL_ZERO; |
| res.toBlue = GL_ZERO; |
| res.toAlpha = GL_ZERO; |
| break; |
| case GL_LUMINANCE: |
| res.toRed = GL_RED; |
| res.toGreen = GL_ZERO; |
| res.toBlue = GL_ZERO; |
| res.toAlpha = GL_ZERO; |
| break; |
| case GL_LUMINANCE_ALPHA: |
| res.toRed = GL_RED; |
| res.toGreen = GL_ALPHA; |
| res.toBlue = GL_ZERO; |
| res.toAlpha = GL_ZERO; |
| break; |
| default: |
| break; |
| } |
| return res; |
| } |
| |
| GLenum swizzleComponentOf(const TextureSwizzle& s, GLenum component) { |
| switch (component) { |
| case GL_RED: return s.toRed; |
| case GL_GREEN: return s.toGreen; |
| case GL_BLUE: return s.toBlue; |
| case GL_ALPHA: return s.toAlpha; |
| } |
| // Identity map for GL_ZERO / GL_ONE |
| return component; |
| } |
| |
| TextureSwizzle concatSwizzles(const TextureSwizzle& first, |
| const TextureSwizzle& next) { |
| |
| TextureSwizzle result; |
| result.toRed = swizzleComponentOf(first, next.toRed); |
| result.toGreen = swizzleComponentOf(first, next.toGreen); |
| result.toBlue = swizzleComponentOf(first, next.toBlue); |
| result.toAlpha = swizzleComponentOf(first, next.toAlpha); |
| return result; |
| } |
| |
| bool isSwizzleParam(GLenum pname) { |
| switch (pname) { |
| case GL_TEXTURE_SWIZZLE_R: |
| case GL_TEXTURE_SWIZZLE_G: |
| case GL_TEXTURE_SWIZZLE_B: |
| case GL_TEXTURE_SWIZZLE_A: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool isIntegerInternalFormat(GLint internalformat) { |
| switch (internalformat) { |
| case GL_R8I: |
| case GL_R8UI: |
| case GL_R16I: |
| case GL_R16UI: |
| case GL_R32I: |
| case GL_R32UI: |
| case GL_RG8I: |
| case GL_RG8UI: |
| case GL_RG16I: |
| case GL_RG16UI: |
| case GL_RG32I: |
| case GL_RG32UI: |
| case GL_RGB8I: |
| case GL_RGB8UI: |
| case GL_RGB16I: |
| case GL_RGB16UI: |
| case GL_RGB32I: |
| case GL_RGB32UI: |
| case GL_RGBA8I: |
| case GL_RGBA8UI: |
| case GL_RGBA16I: |
| case GL_RGBA16UI: |
| case GL_RGBA32I: |
| case GL_RGBA32UI: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| void doCompressedTexImage2DNative(GLEScontext* ctx, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) { |
| // AlignedBuf<uint8_t, 64> alignedData(imageSize); |
| // memcpy(alignedData.data(), data, imageSize); |
| // GLint err = ctx->dispatcher().glGetError(); |
| ctx->dispatcher().glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data); |
| // fprintf(stderr, "%s: tex %u target 0x%x level 0x%x iformat 0x%x w h b %d %d %d imgSize %d\n", __func__, ctx->getBindedTexture(target), target, level, internalformat, width, height, border, imageSize); |
| // err = ctx->dispatcher().glGetError(); if (err) { |
| // fprintf(stderr, "%s:%d err 0x%x\n", __func__, __LINE__, err); |
| // } |
| } |
| |
| void doCompressedTexSubImage2DNative(GLEScontext* ctx, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) { |
| // AlignedBuf<uint8_t, 64> alignedData(imageSize); |
| // memcpy(alignedData.data(), data, imageSize); |
| // GLint err = ctx->dispatcher().glGetError(); |
| ctx->dispatcher().glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); |
| // fprintf(stderr, "%s: tex %u target 0x%x level 0x%x format 0x%x x y w h %d %d %d %d imgSize %d\n", __func__, ctx->getBindedTexture(target), target, level, format, xoffset, yoffset, width, height, imageSize); |
| // err = ctx->dispatcher().glGetError(); if (err) { |
| // fprintf(stderr, "%s:%d err 0x%x\n", __func__, __LINE__, err); |
| // } |
| } |
| |
| void forEachEtc2Format(std::function<void(GLint format)> f) { |
| f(GL_COMPRESSED_RGB8_ETC2); |
| f(GL_COMPRESSED_SRGB8_ETC2); |
| f(GL_COMPRESSED_RGBA8_ETC2_EAC); |
| f(GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC); |
| f(GL_COMPRESSED_R11_EAC); |
| f(GL_COMPRESSED_SIGNED_R11_EAC); |
| f(GL_COMPRESSED_RG11_EAC); |
| f(GL_COMPRESSED_SIGNED_RG11_EAC); |
| f(GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2); |
| f(GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2); |
| } |
| |
| void forEachAstcFormat(std::function<void(GLint format)> f) { |
| |
| #define CALL_ON_ASTC_FORMAT(typeName, blockWidth, blockHeight, srgbValue) \ |
| f(typeName); |
| |
| ASTC_FORMATS_LIST(CALL_ON_ASTC_FORMAT) |
| } |
| |
| void forEachBptcFormat(std::function<void(GLint format)> f) { |
| f(GL_COMPRESSED_RGBA_BPTC_UNORM_EXT); |
| f(GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT); |
| f(GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT); |
| f(GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT); |
| } |
| |
| void forEachS3tcFormat(std::function<void(GLint format)> f) { |
| f(GL_COMPRESSED_RGB_S3TC_DXT1_EXT); |
| f(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT); |
| f(GL_COMPRESSED_RGBA_S3TC_DXT3_EXT); |
| f(GL_COMPRESSED_RGBA_S3TC_DXT5_EXT); |
| f(GL_COMPRESSED_SRGB_S3TC_DXT1_EXT); |
| f(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT); |
| f(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT); |
| f(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT); |
| } |
| |
| bool isRgtcFormat(GLenum format) { |
| switch (format) { |
| case GL_COMPRESSED_RED_RGTC1_EXT: // BC4U |
| case GL_COMPRESSED_SIGNED_RED_RGTC1_EXT: // BC4S |
| case GL_COMPRESSED_RED_GREEN_RGTC2_EXT: // BC5U |
| case GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: // BC5S |
| return true; |
| default: |
| break; |
| } |
| return false; |
| } |
| |
| bool isEtc2OrAstcFormat(GLenum format) { |
| switch (format) { |
| case GL_COMPRESSED_RGB8_ETC2: |
| case GL_COMPRESSED_SRGB8_ETC2: |
| case GL_COMPRESSED_RGBA8_ETC2_EAC: |
| case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: |
| case GL_COMPRESSED_R11_EAC: |
| case GL_COMPRESSED_SIGNED_R11_EAC: |
| case GL_COMPRESSED_RG11_EAC: |
| case GL_COMPRESSED_SIGNED_RG11_EAC: |
| case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: |
| case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: |
| return true; |
| default: |
| break; |
| } |
| return isAstcFormat(format); |
| } |
| |
| bool shouldPassthroughCompressedFormat(GLEScontext* ctx, GLenum internalformat) { |
| if (isEtc2Format(internalformat)) { |
| return ctx->getCaps()->hasEtc2Support; |
| } else if (isAstcFormat(internalformat)) { |
| return ctx->getCaps()->hasAstcSupport; |
| } else if (isBptcFormat(internalformat)) { |
| return ctx->getCaps()->hasBptcSupport; |
| } else if (isS3tcFormat(internalformat)) { |
| return ctx->getCaps()->hasS3tcSupport; |
| } else if (isRgtcFormat(internalformat)) { |
| return ctx->getCaps()->hasRgtcSupport; |
| } |
| return false; |
| } |
| |
| static uint32_t s_texAlign(uint32_t v, uint32_t align) { |
| uint32_t rem = v % align; |
| return rem ? (v + (align - rem)) : v; |
| } |
| |
| // s_computePixelSize is both in the host and the guest. Consider moving it to |
| // android-emugl/shared |
| |
| static int s_computePixelSize(GLenum format, GLenum type) { |
| #define FORMAT_ERROR(format, type) \ |
| fprintf(stderr, "%s:%d unknown format/type 0x%x 0x%x\n", __FUNCTION__, \ |
| __LINE__, format, type); |
| |
| switch (type) { |
| case GL_BYTE: |
| switch (format) { |
| case GL_R8: |
| case GL_R8I: |
| case GL_R8_SNORM: |
| case GL_RED: |
| return 1; |
| case GL_RED_INTEGER: |
| return 1; |
| case GL_RG8: |
| case GL_RG8I: |
| case GL_RG8_SNORM: |
| case GL_RG: |
| return 1 * 2; |
| case GL_RG_INTEGER: |
| return 1 * 2; |
| case GL_RGB8: |
| case GL_RGB8I: |
| case GL_RGB8_SNORM: |
| case GL_RGB: |
| return 1 * 3; |
| case GL_RGB_INTEGER: |
| return 1 * 3; |
| case GL_RGBA8: |
| case GL_RGBA8I: |
| case GL_RGBA8_SNORM: |
| case GL_RGBA: |
| return 1 * 4; |
| case GL_RGBA_INTEGER: |
| return 1 * 4; |
| default: |
| FORMAT_ERROR(format, type); |
| } |
| break; |
| case GL_UNSIGNED_BYTE: |
| switch (format) { |
| case GL_R8: |
| case GL_R8UI: |
| case GL_RED: |
| return 1; |
| case GL_RED_INTEGER: |
| return 1; |
| case GL_ALPHA8_EXT: |
| case GL_ALPHA: |
| return 1; |
| case GL_LUMINANCE8_EXT: |
| case GL_LUMINANCE: |
| return 1; |
| case GL_LUMINANCE8_ALPHA8_EXT: |
| case GL_LUMINANCE_ALPHA: |
| return 1 * 2; |
| case GL_RG8: |
| case GL_RG8UI: |
| case GL_RG: |
| return 1 * 2; |
| case GL_RG_INTEGER: |
| return 1 * 2; |
| case GL_RGB8: |
| case GL_RGB8UI: |
| case GL_SRGB8: |
| case GL_RGB: |
| return 1 * 3; |
| case GL_RGB_INTEGER: |
| return 1 * 3; |
| case GL_RGBA8: |
| case GL_RGBA8UI: |
| case GL_SRGB8_ALPHA8: |
| case GL_RGBA: |
| return 1 * 4; |
| case GL_RGBA_INTEGER: |
| return 1 * 4; |
| case GL_BGRA_EXT: |
| case GL_BGRA8_EXT: |
| return 1 * 4; |
| default: |
| FORMAT_ERROR(format, type); |
| } |
| break; |
| case GL_SHORT: |
| switch (format) { |
| case GL_R16I: |
| case GL_RED_INTEGER: |
| return 2; |
| case GL_RG16I: |
| case GL_RG_INTEGER: |
| return 2 * 2; |
| case GL_RGB16I: |
| case GL_RGB_INTEGER: |
| return 2 * 3; |
| case GL_RGBA16I: |
| case GL_RGBA_INTEGER: |
| return 2 * 4; |
| default: |
| FORMAT_ERROR(format, type); |
| } |
| break; |
| case GL_UNSIGNED_SHORT: |
| switch (format) { |
| case GL_DEPTH_COMPONENT16: |
| case GL_DEPTH_COMPONENT: |
| return 2; |
| case GL_R16UI: |
| case GL_RED_INTEGER: |
| return 2; |
| case GL_RG16UI: |
| case GL_RG_INTEGER: |
| return 2 * 2; |
| case GL_RGB16UI: |
| case GL_RGB_INTEGER: |
| return 2 * 3; |
| case GL_RGBA16UI: |
| case GL_RGBA_INTEGER: |
| return 2 * 4; |
| default: |
| FORMAT_ERROR(format, type); |
| } |
| break; |
| case GL_INT: |
| switch (format) { |
| case GL_R32I: |
| case GL_RED_INTEGER: |
| return 4; |
| case GL_RG32I: |
| case GL_RG_INTEGER: |
| return 4 * 2; |
| case GL_RGB32I: |
| case GL_RGB_INTEGER: |
| return 4 * 3; |
| case GL_RGBA32I: |
| case GL_RGBA_INTEGER: |
| return 4 * 4; |
| default: |
| FORMAT_ERROR(format, type); |
| } |
| break; |
| case GL_UNSIGNED_INT: |
| switch (format) { |
| case GL_DEPTH_COMPONENT16: |
| case GL_DEPTH_COMPONENT24: |
| case GL_DEPTH_COMPONENT32_OES: |
| case GL_DEPTH_COMPONENT: |
| return 4; |
| case GL_R32UI: |
| case GL_RED_INTEGER: |
| return 4; |
| case GL_RG32UI: |
| case GL_RG_INTEGER: |
| return 4 * 2; |
| case GL_RGB32UI: |
| case GL_RGB_INTEGER: |
| return 4 * 3; |
| case GL_RGBA32UI: |
| case GL_RGBA_INTEGER: |
| return 4 * 4; |
| default: |
| FORMAT_ERROR(format, type); |
| } |
| break; |
| case GL_UNSIGNED_SHORT_4_4_4_4: |
| case GL_UNSIGNED_SHORT_5_5_5_1: |
| case GL_UNSIGNED_SHORT_5_6_5: |
| case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT: |
| case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT: |
| return 2; |
| case GL_UNSIGNED_INT_10F_11F_11F_REV: |
| case GL_UNSIGNED_INT_5_9_9_9_REV: |
| case GL_UNSIGNED_INT_2_10_10_10_REV: |
| case GL_UNSIGNED_INT_24_8_OES: |
| return 4; |
| case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: |
| return 4 + 4; |
| case GL_FLOAT: |
| switch (format) { |
| case GL_DEPTH_COMPONENT32F: |
| case GL_DEPTH_COMPONENT: |
| return 4; |
| case GL_ALPHA32F_EXT: |
| case GL_ALPHA: |
| return 4; |
| case GL_LUMINANCE32F_EXT: |
| case GL_LUMINANCE: |
| return 4; |
| case GL_LUMINANCE_ALPHA32F_EXT: |
| case GL_LUMINANCE_ALPHA: |
| return 4 * 2; |
| case GL_RED: |
| return 4; |
| case GL_R32F: |
| return 4; |
| case GL_RG: |
| return 4 * 2; |
| case GL_RG32F: |
| return 4 * 2; |
| case GL_RGB: |
| return 4 * 3; |
| case GL_RGB32F: |
| return 4 * 3; |
| case GL_RGBA: |
| return 4 * 4; |
| case GL_RGBA32F: |
| return 4 * 4; |
| default: |
| FORMAT_ERROR(format, type); |
| } |
| break; |
| case GL_HALF_FLOAT: |
| case GL_HALF_FLOAT_OES: |
| switch (format) { |
| case GL_ALPHA16F_EXT: |
| case GL_ALPHA: |
| return 2; |
| case GL_LUMINANCE16F_EXT: |
| case GL_LUMINANCE: |
| return 2; |
| case GL_LUMINANCE_ALPHA16F_EXT: |
| case GL_LUMINANCE_ALPHA: |
| return 2 * 2; |
| case GL_RED: |
| return 2; |
| case GL_R16F: |
| return 2; |
| case GL_RG: |
| return 2 * 2; |
| case GL_RG16F: |
| return 2 * 2; |
| case GL_RGB: |
| return 2 * 3; |
| case GL_RGB16F: |
| return 2 * 3; |
| case GL_RGBA: |
| return 2 * 4; |
| case GL_RGBA16F: |
| return 2 * 4; |
| default: |
| FORMAT_ERROR(format, type); |
| } |
| break; |
| default: |
| FORMAT_ERROR(format, type); |
| } |
| |
| return 0; |
| } |
| |
| uint32_t texImageSize(GLenum internalformat, |
| GLenum type, |
| int unpackAlignment, |
| GLsizei width, |
| GLsizei height) { |
| |
| uint32_t alignedWidth = s_texAlign(width, unpackAlignment); |
| uint32_t pixelSize = s_computePixelSize(internalformat, type); |
| uint32_t totalSize = pixelSize * alignedWidth * height; |
| |
| return totalSize; |
| } |
| |
| GLenum getFormatFromInternalFormat(GLint internalFormat) { |
| switch (internalFormat) { |
| case GL_R8: |
| return GL_RED; |
| case GL_RG8: |
| return GL_RG; |
| case GL_RGB8: |
| case GL_RGB565: |
| case GL_RGB16F: |
| return GL_RGB; |
| case GL_RGBA8: |
| case GL_RGB5_A1_OES: |
| case GL_RGBA4_OES: |
| case GL_UNSIGNED_INT_10_10_10_2_OES: |
| case GL_RGB10_A2: |
| case GL_RGBA16F: |
| return GL_RGBA; |
| case GL_BGRA8_EXT: |
| return GL_BGRA_EXT; |
| default: // already unsized |
| return internalFormat; |
| } |
| } |
| |
| GLenum getTypeFromInternalFormat(GLint internalFormat) { |
| switch (internalFormat) { |
| case GL_RGB: |
| case GL_RGB8: |
| return GL_UNSIGNED_BYTE; |
| case GL_RGB565_OES: |
| return GL_UNSIGNED_SHORT_5_6_5; |
| case GL_RGBA: |
| case GL_RGBA8: |
| case GL_RGB5_A1_OES: |
| case GL_RGBA4_OES: |
| return GL_UNSIGNED_BYTE; |
| case GL_UNSIGNED_INT_10_10_10_2_OES: |
| return GL_UNSIGNED_SHORT; |
| case GL_RGB10_A2: |
| return GL_UNSIGNED_INT_2_10_10_10_REV; |
| case GL_RGB16F: |
| return GL_HALF_FLOAT; |
| case GL_RGBA16F: |
| return GL_HALF_FLOAT; |
| case GL_LUMINANCE: |
| return GL_UNSIGNED_SHORT; |
| case GL_BGRA_EXT: |
| return GL_UNSIGNED_BYTE; |
| case GL_R8: |
| case GL_RED: |
| return GL_UNSIGNED_BYTE; |
| case GL_RG8: |
| case GL_RG: |
| return GL_UNSIGNED_BYTE; |
| default: |
| fprintf(stderr, "%s: Unknown format 0x%x\n", __func__, |
| internalFormat); |
| return GL_UNSIGNED_BYTE; |
| } |
| } |
| |
| |
| GLint TextureUnpackReset::unpackCheckAndUpdate(GLenum name, GLint newValue) { |
| GLint curValue; |
| glesContext->dispatcher().glGetIntegerv(name, &curValue); |
| if (curValue != newValue) { |
| glesContext->dispatcher().glPixelStorei(name, newValue); |
| } |
| return curValue; |
| } |
| |
| TextureUnpackReset::TextureUnpackReset(GLEScontext* ctx) : glesContext(ctx) { |
| unpackAlignment = unpackCheckAndUpdate(GL_UNPACK_ALIGNMENT, kUnpackAlignment); |
| if (glesContext->getMajorVersion() >= 3) { |
| unpackRowLength = unpackCheckAndUpdate(GL_UNPACK_ROW_LENGTH, kUnpackRowLength); |
| unpackImageHeight = unpackCheckAndUpdate(GL_UNPACK_IMAGE_HEIGHT, kUnpackImageHeight); |
| unpackSkipRows = unpackCheckAndUpdate(GL_UNPACK_SKIP_ROWS, kUnpackSkipRows); |
| unpackSkipPixels = unpackCheckAndUpdate(GL_UNPACK_SKIP_PIXELS, kUnpackSkipPixels); |
| unpackSkipImages = unpackCheckAndUpdate(GL_UNPACK_SKIP_IMAGES, kUnpackSkipImages); |
| } else { |
| // avoid clang-tidy warnings on uninitialized values |
| unpackRowLength = 0; |
| unpackImageHeight = 0; |
| unpackSkipRows = 0; |
| unpackSkipPixels = 0; |
| unpackSkipImages = 0; |
| } |
| } |
| TextureUnpackReset::~TextureUnpackReset() { |
| unpackCheckAndUpdate(GL_UNPACK_ALIGNMENT, unpackAlignment); |
| if (glesContext->getMajorVersion() >= 3) { |
| unpackCheckAndUpdate(GL_UNPACK_ROW_LENGTH, unpackRowLength); |
| unpackCheckAndUpdate(GL_UNPACK_IMAGE_HEIGHT, unpackImageHeight); |
| unpackCheckAndUpdate(GL_UNPACK_SKIP_ROWS, unpackSkipRows); |
| unpackCheckAndUpdate(GL_UNPACK_SKIP_PIXELS, unpackSkipPixels); |
| unpackCheckAndUpdate(GL_UNPACK_SKIP_IMAGES, unpackSkipImages); |
| } |
| } |
| |
