348 lines
9.5 KiB
C++
348 lines
9.5 KiB
C++
/* -*- 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 <math.h>
|
|
|
|
/* 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 <assert.h>
|
|
#include <windows.h>
|
|
#include <shellapi.h>
|
|
#include <stdlib.h>
|
|
|
|
// 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 */
|