inksoul
/
plumageRender
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity
plumageRender/external/ktx/lib/writer_v1.c

709 lines
26 KiB
C
Raw Normal View History

init
2023-05-17 14:49:05 +08:00
/* -*- tab-width: 4; -*- */
/* vi: set sw=2 ts=4 expandtab: */
/* $Id: 687889ad2b1bee58a6d439ef4d6c10830a733418 $ */
/*
* ©2010-2018 Mark Callow.
*
* 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.
*/
/**
* @internal
* @file writer.c
* @~English
*
* @brief V1 API functions for creating KTX-format files from a set of images.
*
* Keep the v1 API implementation as is because reimplementing it in terms
* of the v2 API would use too much memory. This is because this API expects
* all the images to already be loaded in memory and the v2 api would load
* them into another memory buffer prior to writing the file.
*
* @author Mark Callow, when at HI Corporation
*/
#ifdef _WIN32
#define _CRT_SECURE_NO_WARNINGS
#endif
#include <assert.h>
#include <limits.h>
#include "GL/glcorearb.h"
#include "ktx.h"
#include "ktxint.h"
#include "stream.h"
#include "filestream.h"
#include "memstream.h"
#include "gl_format.h"
static GLenum getFormatFromInternalFormatLegacy(GLenum internalFormat);
static GLenum getTypeFromInternalFormatLegacy(GLenum internalFormat);
static void getFormatSizeLegacy(GLenum internalFormat,
GlFormatSize* formatSize);
/**
* @internal
* @ingroup writer
* @~English
* @deprecated Use ktxTexture_writeToStream().
* @brief Write image(s) in a KTX-format to a ktxStream.
*
* @param [in] stream pointer to the ktxStream from which to load.
* @param [in] textureInfo pointer to a KTX_texture_info structure providing
* information about the images to be included in
* the KTX file.
* @param [in] bytesOfKeyValueData
* specifies the number of bytes of key-value data.
* @param [in] keyValueData a pointer to the keyValue data.
* @param [in] numImages number of images in the following array
* @param [in] images array of KTX_image_info providing image size and
* data.
*
* @return KTX_SUCCESS on success, other KTX_* enum values on error.
*
* @exception KTX_INVALID_VALUE @c glTypeSize in @p textureInfo is not 1, 2, or
* 4 or is different from the size of the type
* specified in @c glType.
* @exception KTX_INVALID_VALUE @c pixelWidth in @p textureInfo is 0 or
* pixelDepth != 0 && pixelHeight == 0.
* @exception KTX_INVALID_VALUE In @p textureInfo, @c numberOfFaces != 1 or
* numberOfFaces != 6 or numberOfArrayElements
* or numberOfMipmapLevels are < 0.
* @exception KTX_INVALID_VALUE @c glType in @p textureInfo is an unrecognized
* type.
* @exception KTX_INVALID_OPERATION
* In @p textureInfo, numberOfFaces == 6 and
* images are either not 2D or are not square.
* @exception KTX_INVALID_OPERATION
* @p numImages is insufficient for the specified
* number of mipmap levels and faces.
* @exception KTX_INVALID_OPERATION
* The size of a provided image is different than
* that required for the specified width, height
* or depth or for the mipmap level being
* processed.
* @exception KTX_INVALID_OPERATION
* @c glType and @c glFormat in @p textureInfo are
* mismatched. See OpenGL 4.4 specification
* section 8.4.4 and table 8.5.
* @exception KTX_FILE_WRITE_ERROR
* A system error occurred while writing the file.
* @exception KTX_OUT_OF_MEMORY System failed to allocate sufficient memory.
*/
static
KTX_error_code
ktxWriteKTXS(struct ktxStream *stream, const KTX_texture_info* textureInfo,
GLsizei bytesOfKeyValueData, const void* keyValueData,
GLuint numImages, KTX_image_info images[])
{
KTX_header header = KTX_IDENTIFIER_REF;
GLuint i, level, dimension, cubemap = 0;
GLuint numMipmapLevels, numArrayElements;
GLbyte pad[4] = { 0, 0, 0, 0 };
KTX_error_code result = KTX_SUCCESS;
GLboolean compressed = GL_FALSE;
GLuint groupBytes;
if (!stream) {
return KTX_INVALID_VALUE;
}
/* endianess int.. if this comes out reversed, all of the other ints will
* too.
*/
header.endianness = KTX_ENDIAN_REF;
header.glType = textureInfo->glType;
header.glTypeSize = textureInfo->glTypeSize;
header.glFormat = textureInfo->glFormat;
header.glInternalformat = textureInfo->glInternalFormat;
header.glBaseInternalformat = textureInfo->glBaseInternalFormat;
header.pixelWidth = textureInfo->pixelWidth;
header.pixelHeight = textureInfo->pixelHeight;
header.pixelDepth = textureInfo->pixelDepth;
header.numberOfArrayElements = textureInfo->numberOfArrayElements;
header.numberOfFaces = textureInfo->numberOfFaces;
header.numberOfMipmapLevels = textureInfo->numberOfMipmapLevels;
header.bytesOfKeyValueData = bytesOfKeyValueData;
/* Do some sanity checking */
if (header.glTypeSize != 1 &&
header.glTypeSize != 2 &&
header.glTypeSize != 4)
{
/* Only 8, 16, and 32-bit types are supported for byte-swapping.
* See UNPACK_SWAP_BYTES & table 8.4 in the OpenGL 4.4 spec.
*/
return KTX_INVALID_VALUE;
}
if (header.glType == 0 || header.glFormat == 0)
{
if (header.glType + header.glFormat != 0) {
/* either both or neither of glType & glFormat must be zero */
return KTX_INVALID_VALUE;
} else
compressed = GL_TRUE;
}
else
{
GlFormatSize formatInfo;
GLenum expectedFormat, expectedType;
expectedFormat = getFormatFromInternalFormatLegacy(header.glInternalformat);
if (expectedFormat == GL_INVALID_VALUE
|| expectedFormat != header.glFormat)
return KTX_INVALID_OPERATION;
expectedType = getTypeFromInternalFormatLegacy(header.glInternalformat);
if (expectedType == GL_INVALID_VALUE
|| expectedType != header.glType)
return KTX_INVALID_OPERATION;
getFormatSizeLegacy(header.glInternalformat, &formatInfo);
groupBytes = formatInfo.blockSizeInBits / CHAR_BIT;
}
/* Check texture dimensions. KTX files can store 8 types of textures:
* 1D, 2D, 3D, cube, and array variants of these. There is currently
* no GL extension that would accept 3D array array textures but we'll
* let such files be created.
*/
if ((header.pixelWidth == 0) ||
(header.pixelDepth > 0 && header.pixelHeight == 0))
{
/* texture must have width */
/* texture must have height if it has depth */
return KTX_INVALID_VALUE;
}
if (header.pixelHeight > 0 && header.pixelDepth > 0)
dimension = 3;
else if (header.pixelHeight > 0)
dimension = 2;
else
dimension = 1;
if (header.numberOfFaces != 1 && header.pixelDepth != 0)
{
/* No 3D cubemaps so either faces or depth must be 1. */
return KTX_INVALID_OPERATION;
}
if (header.numberOfFaces == 6)
{
if (dimension != 2)
{
/* cube map needs 2D faces */
return KTX_INVALID_OPERATION;
}
if (header.pixelWidth != header.pixelHeight)
{
/* cube maps require square images */
return KTX_INVALID_OPERATION;
}
}
else if (header.numberOfFaces != 1)
{
/* numberOfFaces must be either 1 or 6 */
return KTX_INVALID_VALUE;
}
if (header.numberOfArrayElements == 0)
numArrayElements = 1;
else
numArrayElements = header.numberOfArrayElements;
if (header.numberOfFaces == 6)
cubemap = 1;
/* Check number of mipmap levels */
if (header.numberOfMipmapLevels == 0)
{
numMipmapLevels = 1;
}
else
numMipmapLevels = header.numberOfMipmapLevels;
if (numMipmapLevels > 1) {
GLuint max_dim = MAX(MAX(header.pixelWidth, header.pixelHeight), header.pixelDepth);
if (max_dim < ((GLuint)1 << (header.numberOfMipmapLevels - 1)))
{
/* Can't have more mip levels than 1 + log2(max(width, height, depth)) */
return KTX_INVALID_VALUE;
}
}
if (numImages < numMipmapLevels * header.numberOfFaces)
{
/* Not enough images */
return KTX_INVALID_OPERATION;
}
//write header
result = stream->write(stream, &header, sizeof(KTX_header), 1);
if (result != KTX_SUCCESS)
return result;
//write keyValueData
if (bytesOfKeyValueData != 0) {
if (keyValueData == NULL)
return KTX_INVALID_OPERATION;
result = stream->write(stream, keyValueData, 1, bytesOfKeyValueData);
if (result != KTX_SUCCESS)
return result;
}
/* Write the image data */
for (level = 0, i = 0; level < numMipmapLevels; ++level)
{
GLuint faceSlice, faceLodSize;
#if (KTX_GL_UNPACK_ALIGNMENT != 4)
GLuint faceLodPadding;
#endif
GLuint pixelWidth, pixelHeight, pixelDepth;
GLsizei imageBytes, packedImageBytes;
GLsizei packedRowBytes, rowBytes, rowPadding;
GLuint numImages;
pixelWidth = MAX(1, header.pixelWidth >> level);
pixelHeight = MAX(1, header.pixelHeight >> level);
pixelDepth = MAX(1, header.pixelDepth >> level);
/* Calculate face sizes for this LoD based on glType, glFormat, width & height */
packedImageBytes = groupBytes
* pixelWidth
* pixelHeight;
rowPadding = 0;
packedRowBytes = groupBytes * pixelWidth;
/* KTX format specifies UNPACK_ALIGNMENT==4 */
/* GL spec: rows are not to be padded when elementBytes != 1, 2, 4 or 8.
* As GL currently has no such elements, no test is necessary.
*/
if (!compressed) {
rowBytes = _KTX_PAD_UNPACK_ALIGN(packedRowBytes);
rowPadding = rowBytes - packedRowBytes;
}
if (rowPadding == 0) {
imageBytes = packedImageBytes;
} else {
/* Need to pad the rows to meet the required UNPACK_ALIGNMENT */
imageBytes = rowBytes * pixelHeight;
}
if (textureInfo->numberOfArrayElements == 0 && cubemap) {
/* Non-array cubemap. */
numImages = 6;
faceLodSize = imageBytes;
} else {
numImages = cubemap ? 6 : pixelDepth;
numImages *= numArrayElements;
faceLodSize = imageBytes * numImages;
}
#if (KTX_GL_UNPACK_ALIGNMENT != 4)
faceLodPadding = _KTX_PAD4_LEN(faceLodSize);
#endif
result = stream->write(stream, &faceLodSize, sizeof(faceLodSize), 1);
if (result != KTX_SUCCESS)
goto cleanup;
for (faceSlice = 0; faceSlice < numImages; ++faceSlice, ++i) {
if (!compressed) {
/* Sanity check. */
if (images[i].size != packedImageBytes) {
result = KTX_INVALID_OPERATION;
goto cleanup;
}
}
if (rowPadding == 0) {
/* Can write whole face at once */
result = stream->write(stream, images[i].data, images[i].size,
1);
if (result != KTX_SUCCESS)
goto cleanup;
} else {
/* Write the rows individually, padding each one */
GLuint row;
GLuint numRows = pixelHeight;
for (row = 0; row < numRows; row++) {
result = stream->write(stream,
&images[i].data[row*packedRowBytes],
packedRowBytes, 1);
if (result != KTX_SUCCESS)
goto cleanup;
result = stream->write(stream, pad, sizeof(GLbyte),
rowPadding);
if (result != KTX_SUCCESS)
goto cleanup;
}
}
#if (KTX_GL_UNPACK_ALIGNMENT != 4)
/*
* When KTX_GL_UNPACK_ALIGNMENT == 4, rows, and therefore everything
* else, are always 4-byte aligned and faceLodPadding is always 0.
* It is always 0 for compressed formats too because they all have
* multiple-of-4 block sizes.
*/
if (faceLodPadding) {
result = stream->write(stream, pad, sizeof(GLbyte),
faceLodPadding);
if (result != KTX_SUCCESS)
goto cleanup;
}
#endif
}
}
cleanup:
return result;
}
/**
* @~English
* @ingroup writer
* @deprecated Use ktxTexture_WriteToStdioStream().
* @brief Write image(s) in KTX format to a stdio FILE stream.
*
* @note textureInfo directly reflects what is written to the KTX file
* header. That is @c numberOfArrayElements should be 0 for non arrays;
* @c numMipmapLevels should be 0 to request generateMipmaps and @c type,
* @c format & @c typesize should be 0 for compressed textures.
*
* @param[in] file pointer to the FILE stream to write to.
* @param[in] textureInfo pointer to a KTX_texture_info structure providing
* information about the images to be included in
* the KTX file.
* @param[in] bytesOfKeyValueData
* specifies the number of bytes of key-value data.
* @param[in] keyValueData a pointer to the keyValue data.
* @param[in] numImages number of images in the following array
* @param[in] images array of KTX_image_info providing image size and
* data.
*
* @return KTX_SUCCESS on success, other KTX_* enum values on error.
*
* @exception KTX_INVALID_VALUE @c glTypeSize in @p textureInfo is not 1, 2, or
* 4 or is different from the size of the type
* specified in @c glType.
* @exception KTX_INVALID_VALUE @c pixelWidth in @p textureInfo is 0 or
* pixelDepth != 0 && pixelHeight == 0.
* @exception KTX_INVALID_VALUE In @p textureInfo, @c numberOfFaces != 1 or
* numberOfFaces != 6 or numberOfArrayElements
* or numberOfMipmapLevels are < 0.
* @exception KTX_INVALID_VALUE @c glType in @p textureInfo is an unrecognized
* type.
* @exception KTX_INVALID_OPERATION
* In @p textureInfo, numberOfFaces == 6 and
* images are either not 2D or are not square.
* @exception KTX_INVALID_OPERATION
* @p numImages is insufficient for the specified
* number of mipmap levels and faces.
* @exception KTX_INVALID_OPERATION
* The size of a provided image is different than
* that required for the specified width, height
* or depth or for the mipmap level being
* processed.
* @exception KTX_INVALID_OPERATION
* @c glType and @c glFormat in @p textureInfo are
* mismatched. See OpenGL 4.4 specification
* section 8.4.4 and table 8.5.
* @exception KTX_FILE_WRITE_ERROR
* A system error occurred while writing the file.
* @exception KTX_OUT_OF_MEMORY System failed to allocate sufficient memory.
*/
KTX_error_code
ktxWriteKTXF(FILE *file, const KTX_texture_info* textureInfo,
GLsizei bytesOfKeyValueData, const void* keyValueData,
GLuint numImages, KTX_image_info images[])
{
struct ktxStream stream;
KTX_error_code result;
result = ktxFileStream_construct(&stream, file, KTX_FALSE);
if (result != KTX_SUCCESS)
return result;
result = ktxWriteKTXS(&stream, textureInfo, bytesOfKeyValueData, keyValueData,
numImages, images);
stream.destruct(&stream);
return result;
}
/**
* @~English
* @ingroup writer
* @deprecated Use ktxTexture_WriteToNamedFile().
* @brief Write image(s) in KTX format to a file on disk.
*
* @note textureInfo directly reflects what is written to the KTX file
* header. That is @c numberOfArrayElements should be 0 for non arrays;
* @c numMipmapLevels should be 0 to request generateMipmaps and @c type,
* @c format & @c typesize should be 0 for compressed textures.
*
* @param[in] dstname pointer to a C string that contains the path of
* the file to load.
* @param[in] textureInfo pointer to a KTX_texture_info structure providing
* information about the images to be included in
* the KTX file.
* @param[in] bytesOfKeyValueData
* specifies the number of bytes of key-value data.
* @param[in] keyValueData a pointer to the keyValue data.
* @param[in] numImages number of images in the following array.
* @param[in] images array of KTX_image_info providing image size and
* data.
*
* @return KTX_SUCCESS on success, other KTX_* enum values on error.
*
* @exception KTX_FILE_OPEN_FAILED Unable to open the specified file for
* writing.
*
* For other exceptions, see ktxWriteKTXF().
*/
KTX_error_code
ktxWriteKTXN(const char* dstname, const KTX_texture_info* textureInfo,
GLsizei bytesOfKeyValueData, const void* keyValueData,
GLuint numImages, KTX_image_info images[])
{
struct ktxStream stream;
KTX_error_code result;
FILE* dst = fopen(dstname, "wb");
if (dst) {
result = ktxWriteKTXS(&stream, textureInfo, bytesOfKeyValueData,
keyValueData, numImages, images);
fclose(dst);
} else
result = KTX_FILE_OPEN_FAILED;
return result;
}
/**
* @~English
* @ingroup writer
* @deprecated Use ktxTexture_WriteToMemory().
* @brief Write image(s) in KTX format to memory.
*
* Memory is allocated by the function and the caller is responsible for
* freeing it.
*
* @note textureInfo directly reflects what is written to the KTX file
* header. That is @c numberOfArrayElements should be 0 for non arrays;
* @c numMipmapLevels should be 0 to request generateMipmaps and @c type,
* @c format & @c typesize should be 0 for compressed textures.
*
* @param[out] ppDstBytes pointer to location to write the address of
* the destination memory. The Application is
responsible for freeing this memory.
* @param[out] pSize pointer to location to write the size in bytes of
* the KTX data.
* @param[in] textureInfo pointer to a KTX_texture_info structure providing
* information about the images to be included in
* the KTX file.
* @param[in] bytesOfKeyValueData
* specifies the number of bytes of key-value data.
* @param[in] keyValueData a pointer to the keyValue data.
* @param[in] numImages number of images in the following array.
* @param[in] images array of KTX_image_info providing image size and
* data.
*
* @return KTX_SUCCESS on success, other KTX_* enum values on error.
*
* @exception KTX_INVALID_VALUE @p dst or @p size is NULL.
* @exception KTX_INVALID_VALUE @c glTypeSize in @p textureInfo is not 1, 2, or
* 4 or is different from the size of the type
* specified in @c glType.
* @exception KTX_INVALID_VALUE @c pixelWidth in @p textureInfo is 0 or
* pixelDepth != 0 && pixelHeight == 0.
* @exception KTX_INVALID_VALUE In @p textureInfo, @c numberOfFaces != 1 or
* numberOfFaces != 6 or numberOfArrayElements
* or numberOfMipmapLevels are < 0.
* @exception KTX_INVALID_VALUE @c glType in @p textureInfo is an unrecognized
* type.
* @exception KTX_INVALID_OPERATION
* In @p textureInfo, numberOfFaces == 6 and
* images are either not 2D or are not square.
* @exception KTX_INVALID_OPERATION
* @p numImages is insufficient for the specified
* number of mipmap levels and faces.
* @exception KTX_INVALID_OPERATION
* The size of a provided image is different than
* that required for the specified width, height
* or depth or for the mipmap level being
* processed.
* @exception KTX_INVALID_OPERATION
* @c glType and @c glFormat in @p textureInfo are
* mismatched. See OpenGL 4.4 specification
* section 8.4.4 and table 8.5.
* @exception KTX_FILE_WRITE_ERROR
* A system error occurred while writing the file.
* @exception KTX_OUT_OF_MEMORY System failed to allocate sufficient memory.
*/
KTX_error_code
ktxWriteKTXM(unsigned char** ppDstBytes, GLsizei* pSize,
const KTX_texture_info* textureInfo,
GLsizei bytesOfKeyValueData, const void* keyValueData,
GLuint numImages, KTX_image_info images[])
{
struct ktxStream stream;
KTX_error_code rc;
ktx_size_t strSize;
if (ppDstBytes == NULL || pSize == NULL)
return KTX_INVALID_VALUE;
*ppDstBytes = NULL;
rc = ktxMemStream_construct(&stream, KTX_FALSE);
if (rc != KTX_SUCCESS)
return rc;
rc = ktxWriteKTXS(&stream, textureInfo, bytesOfKeyValueData, keyValueData,
numImages, images);
if(rc != KTX_SUCCESS)
{
ktxMemStream_destruct(&stream);
return rc;
}
ktxMemStream_getdata(&stream, ppDstBytes);
stream.getsize(&stream, &strSize);
*pSize = (GLsizei)strSize;
/* This function does not free the memory pointed at by the
* value obtained from ktxMemStream_getdata().
*/
stream.destruct(&stream);
return KTX_SUCCESS;
}
/**
* @internal
* @~English
* @brief Get the matching format for an internalformat.
*
* Adds support for deprecated legacy formats needed to create textures for
* use with OpenGL ES 1 & 2 to glGetFormatFromInternalFormat.
*
* @param[in] internalFormat the internal format of the image data
*
* @return the matching glFormat enum or GL_INVALID_VALUE if format is
* unrecognized.
*/
GLenum
getFormatFromInternalFormatLegacy(GLenum internalFormat)
{
switch (internalFormat) {
case GL_LUMINANCE8:
case GL_LUMINANCE16:
return GL_LUMINANCE;
case GL_ALPHA8:
case GL_ALPHA16:
return GL_ALPHA;
case GL_LUMINANCE8_ALPHA8:
case GL_LUMINANCE16_ALPHA16:
return GL_LUMINANCE_ALPHA;
default:
return glGetFormatFromInternalFormat(internalFormat);
}
}
/**
* @internal
* @~English
* @brief Get the GL data type for an internalformat.
*
* Adds support for deprecated legacy formats needed to create textures for
* use with OpenGL ES 1 & 2 to glGetTypeFromInternalFormat.
*
* @param[in] internalFormat the internal format of the image data
*
* @return the matching glFormat enum or GL_INVALID_VALUE if format is
* unrecognized.
*/
GLenum
getTypeFromInternalFormatLegacy(GLenum internalFormat)
{
switch (internalFormat) {
case GL_LUMINANCE8:
case GL_ALPHA8:
return GL_UNSIGNED_BYTE;
case GL_LUMINANCE16:
case GL_ALPHA16:
case GL_LUMINANCE8_ALPHA8:
return GL_UNSIGNED_SHORT;
case GL_LUMINANCE16_ALPHA16:
return GL_UNSIGNED_INT;
default:
return glGetTypeFromInternalFormat(internalFormat);
}
}
/**
* @internal
* @~English
* @brief Get size information for an internalformat.
*
* Adds support for deprecated legacy formats needed to create textures for
* use with OpenGL ES 1 & 2 to glGetTypeFromInternalFormat.
*
* @param[in] internalFormat the internal format of the image data
* @param[in,out] formatSize pointer to a formatSize struct in which the
* information is returned.
*/
void
getFormatSizeLegacy(GLenum internalFormat, GlFormatSize* pFormatSize)
{
switch (internalFormat) {
case GL_LUMINANCE8:
case GL_ALPHA8:
pFormatSize->flags = 0;
pFormatSize->paletteSizeInBits = 0;
pFormatSize->blockSizeInBits = 1 * 8;
pFormatSize->blockWidth = 1;
pFormatSize->blockHeight = 1;
pFormatSize->blockDepth = 1;
break;
case GL_LUMINANCE16:
case GL_ALPHA16:
case GL_LUMINANCE8_ALPHA8:
pFormatSize->flags = 0;
pFormatSize->paletteSizeInBits = 0;
pFormatSize->blockSizeInBits = 2 * 8;
pFormatSize->blockWidth = 1;
pFormatSize->blockHeight = 1;
pFormatSize->blockDepth = 1;
break;
case GL_LUMINANCE16_ALPHA16:
pFormatSize->flags = 0;
pFormatSize->paletteSizeInBits = 0;
pFormatSize->blockSizeInBits = 4 * 8;
pFormatSize->blockWidth = 1;
pFormatSize->blockHeight = 1;
pFormatSize->blockDepth = 1;
break;
default:
glGetFormatSize(internalFormat, pFormatSize);
}
}