/* -*- tab-width: 4; -*- */ /* vi: set sw=2 ts=4 expandtab: */ /* $Id$ */ /* * Copyright 2010-2020 The Khronos Group Inc. * SPDX-License-Identifier: Apache-2.0 */ /* * Author: Mark Callow from original code by Georg Kolling */ #ifndef KTXINT_H #define KTXINT_H #include /* Define this to include the ETC unpack software in the library. */ #ifndef SUPPORT_SOFTWARE_ETC_UNPACK /* Include for all GL versions because have seen OpenGL ES 3 * implementaions that do not support ETC1 (ARM Mali emulator v1.0)! */ #define SUPPORT_SOFTWARE_ETC_UNPACK 1 #endif #ifndef MAX #define MAX(x, y) (((x) > (y)) ? (x) : (y)) #endif #ifndef MIN #define MIN(x, y) (((x) < (y)) ? (x) : (y)) #endif #define QUOTE(x) #x #define STR(x) QUOTE(x) #define KTX2_IDENTIFIER_REF { 0xAB, 0x4B, 0x54, 0x58, 0x20, 0x32, 0x30, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A } #define KTX2_HEADER_SIZE (80) #ifdef __cplusplus extern "C" { #endif /** * @internal * @brief used to pass GL context capabilites to subroutines. */ #define _KTX_NO_R16_FORMATS 0x0 #define _KTX_R16_FORMATS_NORM 0x1 #define _KTX_R16_FORMATS_SNORM 0x2 #define _KTX_ALL_R16_FORMATS (_KTX_R16_FORMATS_NORM | _KTX_R16_FORMATS_SNORM) extern GLint _ktxR16Formats; extern GLboolean _ktxSupportsSRGB; /** * @internal * @~English * @brief KTX file header. * * See the KTX specification for descriptions. */ typedef struct KTX_header { ktx_uint8_t identifier[12]; ktx_uint32_t endianness; ktx_uint32_t glType; ktx_uint32_t glTypeSize; ktx_uint32_t glFormat; ktx_uint32_t glInternalformat; ktx_uint32_t glBaseInternalformat; ktx_uint32_t pixelWidth; ktx_uint32_t pixelHeight; ktx_uint32_t pixelDepth; ktx_uint32_t numberOfArrayElements; ktx_uint32_t numberOfFaces; ktx_uint32_t numberOfMipLevels; ktx_uint32_t bytesOfKeyValueData; } KTX_header; /* This will cause compilation to fail if the struct size doesn't match */ typedef int KTX_header_SIZE_ASSERT [sizeof(KTX_header) == KTX_HEADER_SIZE]; /** * @internal * @~English * @brief 32-bit KTX 2 index entry. */ typedef struct ktxIndexEntry32 { ktx_uint32_t byteOffset; /*!< Offset of item from start of file. */ ktx_uint32_t byteLength; /*!< Number of bytes of data in the item. */ } ktxIndexEntry32; /** * @internal * @~English * @brief 64-bit KTX 2 index entry. */ typedef struct ktxIndexEntry64 { ktx_uint64_t byteOffset; /*!< Offset of item from start of file. */ ktx_uint64_t byteLength; /*!< Number of bytes of data in the item. */ } ktxIndexEntry64; /** * @internal * @~English * @brief KTX 2 file header. * * See the KTX 2 specification for descriptions. */ typedef struct KTX_header2 { ktx_uint8_t identifier[12]; ktx_uint32_t vkFormat; ktx_uint32_t typeSize; ktx_uint32_t pixelWidth; ktx_uint32_t pixelHeight; ktx_uint32_t pixelDepth; ktx_uint32_t layerCount; ktx_uint32_t faceCount; ktx_uint32_t levelCount; ktx_uint32_t supercompressionScheme; ktxIndexEntry32 dataFormatDescriptor; ktxIndexEntry32 keyValueData; ktxIndexEntry64 supercompressionGlobalData; } KTX_header2; /* This will cause compilation to fail if the struct size doesn't match */ typedef int KTX_header2_SIZE_ASSERT [sizeof(KTX_header2) == KTX2_HEADER_SIZE]; /** * @internal * @~English * @brief KTX 2 level index entry. */ typedef struct ktxLevelIndexEntry { ktx_uint64_t byteOffset; /*!< Offset of level from start of file. */ ktx_uint64_t byteLength; /*!< Number of bytes of compressed image data in the level. */ ktx_uint64_t uncompressedByteLength; /*!< Number of bytes of uncompressed image data in the level. */ } ktxLevelIndexEntry; /** * @internal * @~English * @brief Structure for supplemental information about the texture. * * _ktxCheckHeader returns supplemental information about the texture in this * structure that is derived during checking of the file header. */ typedef struct KTX_supplemental_info { ktx_uint8_t compressed; ktx_uint8_t generateMipmaps; ktx_uint16_t textureDimension; } KTX_supplemental_info; /** * @internal * @var ktx_uint8_t KTX_supplemental_info::compressed * @~English * @brief KTX_TRUE, if this a compressed texture, KTX_FALSE otherwise? */ /** * @internal * @var ktx_uint8_t KTX_supplemental_info::generateMipmaps * @~English * @brief KTX_TRUE, if mipmap generation is required, KTX_FALSE otherwise. */ /** * @internal * @var ktx_uint16_t KTX_supplemental_info::textureDimension * @~English * @brief The number of dimensions, 1, 2 or 3, of data in the texture image. */ /* * @internal * CheckHeader1 * * Reads the KTX file header and performs some sanity checking on the values */ KTX_error_code ktxCheckHeader1_(KTX_header* pHeader, KTX_supplemental_info* pSuppInfo); /* * @internal * CheckHeader2 * * Reads the KTX 2 file header and performs some sanity checking on the values */ KTX_error_code ktxCheckHeader2_(KTX_header2* pHeader, KTX_supplemental_info* pSuppInfo); /* * SwapEndian16: Swaps endianness in an array of 16-bit values */ void _ktxSwapEndian16(ktx_uint16_t* pData16, ktx_size_t count); /* * SwapEndian32: Swaps endianness in an array of 32-bit values */ void _ktxSwapEndian32(ktx_uint32_t* pData32, ktx_size_t count); /* * SwapEndian32: Swaps endianness in an array of 64-bit values */ void _ktxSwapEndian64(ktx_uint64_t* pData64, ktx_size_t count); /* * UnpackETC: uncompresses an ETC compressed texture image */ KTX_error_code _ktxUnpackETC(const GLubyte* srcETC, const GLenum srcFormat, ktx_uint32_t active_width, ktx_uint32_t active_height, GLubyte** dstImage, GLenum* format, GLenum* internalFormat, GLenum* type, GLint R16Formats, GLboolean supportsSRGB); /* * @internal * ktxCompressZLIBBounds * * Returns upper bound for compresses data using miniz (ZLIB) */ ktx_size_t ktxCompressZLIBBounds(ktx_size_t srcLength); /* * @internal * ktxCompressZLIBInt * * Compresses data using miniz (ZLIB) */ KTX_error_code ktxCompressZLIBInt(unsigned char* pDest, ktx_size_t* pDestLength, const unsigned char* pSrc, ktx_size_t srcLength, ktx_uint32_t level); /* * @internal * ktxUncompressZLIBInt * * Uncompresses data using miniz (ZLIB) */ KTX_error_code ktxUncompressZLIBInt(unsigned char* pDest, ktx_size_t* pDestLength, const unsigned char* pSrc, ktx_size_t srcLength); /* * Pad nbytes to next multiple of n */ #define _KTX_PADN(n, nbytes) (ktx_uint32_t)(n * ceilf((float)(nbytes) / n)) /* * Calculate bytes of of padding needed to reach next multiple of n. */ /* Equivalent to (n * ceil(nbytes / n)) - nbytes */ #define _KTX_PADN_LEN(n, nbytes) \ (ktx_uint32_t)((n * ceilf((float)(nbytes) / n)) - (nbytes)) /* * Pad nbytes to next multiple of 4 */ #define _KTX_PAD4(nbytes) _KTX_PADN(4, nbytes) /* * Calculate bytes of of padding needed to reach next multiple of 4. */ #define _KTX_PAD4_LEN(nbytes) _KTX_PADN_LEN(4, nbytes) /* * Pad nbytes to next multiple of 8 */ #define _KTX_PAD8(nbytes) _KTX_PADN(8, nbytes) /* * Calculate bytes of of padding needed to reach next multiple of 8. */ #define _KTX_PAD8_LEN(nbytes) _KTX_PADN_LEN(8, nbytes) /* * Pad nbytes to KTX_GL_UNPACK_ALIGNMENT */ #define _KTX_PAD_UNPACK_ALIGN(nbytes) \ _KTX_PADN(KTX_GL_UNPACK_ALIGNMENT, nbytes) /* * Calculate bytes of of padding needed to reach KTX_GL_UNPACK_ALIGNMENT. */ #define _KTX_PAD_UNPACK_ALIGN_LEN(nbytes) \ _KTX_PADN_LEN(KTX_GL_UNPACK_ALIGNMENT, nbytes) /* ====================================== Internal utility functions ====================================== */ KTX_error_code printKTX2Info2(ktxStream* src, KTX_header2* header); /* * fopen a file identified by a UTF-8 path. */ #if defined(_WIN32) #ifndef WIN32_LEAN_AND_MEAN #define WIN32_LEAN_AND_MEAN #endif #ifndef NOMINMAX #define NOMINMAX #endif #include #include #include #include // For Windows, we convert the UTF-8 path and mode to UTF-16 path and use // _wfopen which correctly handles unicode characters. static inline FILE* ktxFOpenUTF8(char const* path, char const* mode) { int wpLen = MultiByteToWideChar(CP_UTF8, 0, path, -1, NULL, 0); int wmLen = MultiByteToWideChar(CP_UTF8, 0, mode, -1, NULL, 0); FILE* fp = NULL; if (wpLen > 0 && wmLen > 0) { wchar_t* wpath = (wchar_t*)malloc(wpLen * sizeof(wchar_t)); wchar_t* wmode = (wchar_t*)malloc(wmLen * sizeof(wchar_t)); MultiByteToWideChar(CP_UTF8, 0, path, -1, wpath, wpLen); MultiByteToWideChar(CP_UTF8, 0, mode, -1, wmode, wmLen); // Returned errno_t value is also set in the global errno. // Apps use that for error detail as libktx only returns // KTX_FILE_OPEN_FAILED. (void)_wfopen_s(&fp, wpath, wmode); free(wpath); free(wmode); return fp; } else { assert(KTX_FALSE && "ktxFOpenUTF8 called with zero length path or mode."); return NULL; } } #else // For other platforms there is no need for any conversion, they // support UTF-8 natively. static inline FILE* ktxFOpenUTF8(char const* path, char const* mode) { return fopen(path, mode); } #endif #ifdef __cplusplus } #endif #endif /* KTXINT_H */