733 lines
31 KiB
C++
733 lines
31 KiB
C++
/* -*- tab-width: 4; -*- */
|
|
/* vi: set sw=2 ts=4 expandtab: */
|
|
|
|
/*
|
|
* Copyright 2019-2020 The Khronos Group Inc.
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
/**
|
|
* @internal
|
|
* @file basis_transcode.cpp
|
|
* @~English
|
|
*
|
|
* @brief Functions for transcoding Basis Universal BasisLZ/ETC1S and UASTC textures.
|
|
*
|
|
* Two worlds collide here too. More uglyness!
|
|
*
|
|
* @author Mark Callow, www.edgewise-consulting.com
|
|
*/
|
|
|
|
#include <inttypes.h>
|
|
#include <stdio.h>
|
|
#include <KHR/khr_df.h>
|
|
|
|
#include "dfdutils/dfd.h"
|
|
#include "ktx.h"
|
|
#include "ktxint.h"
|
|
#include "texture2.h"
|
|
#include "vkformat_enum.h"
|
|
#include "vk_format.h"
|
|
#include "basis_sgd.h"
|
|
#include "transcoder/basisu_file_headers.h"
|
|
#include "transcoder/basisu_transcoder.h"
|
|
#include "transcoder/basisu_transcoder_internal.h"
|
|
|
|
#undef DECLARE_PRIVATE
|
|
#undef DECLARE_PROTECTED
|
|
#define DECLARE_PRIVATE(n,t2) ktxTexture2_private& n = *(t2->_private)
|
|
#define DECLARE_PROTECTED(n,t2) ktxTexture_protected& n = *(t2->_protected)
|
|
|
|
using namespace basisu;
|
|
using namespace basist;
|
|
|
|
inline bool isPow2(uint32_t x) { return x && ((x & (x - 1U)) == 0U); }
|
|
|
|
inline bool isPow2(uint64_t x) { return x && ((x & (x - 1U)) == 0U); }
|
|
|
|
KTX_error_code
|
|
ktxTexture2_transcodeLzEtc1s(ktxTexture2* This,
|
|
alpha_content_e alphaContent,
|
|
ktxTexture2* prototype,
|
|
ktx_transcode_fmt_e outputFormat,
|
|
ktx_transcode_flags transcodeFlags);
|
|
KTX_error_code
|
|
ktxTexture2_transcodeUastc(ktxTexture2* This,
|
|
alpha_content_e alphaContent,
|
|
ktxTexture2* prototype,
|
|
ktx_transcode_fmt_e outputFormat,
|
|
ktx_transcode_flags transcodeFlags);
|
|
|
|
/**
|
|
* @memberof ktxTexture2
|
|
* @ingroup reader
|
|
* @~English
|
|
* @brief Transcode a KTX2 texture with BasisLZ/ETC1S or UASTC images.
|
|
*
|
|
* If the texture contains BasisLZ supercompressed images, Inflates them from
|
|
* back to ETC1S then transcodes them to the specified block-compressed
|
|
* format. If the texture contains UASTC images, inflates them, if they have been
|
|
* supercompressed with zstd, then transcodes then to the specified format, The
|
|
* transcoded images replace the original images and the texture's fields including
|
|
* the DFD are modified to reflect the new format.
|
|
*
|
|
* These types of textures must be transcoded to a desired target
|
|
* block-compressed format before they can be uploaded to a GPU via a
|
|
* graphics API.
|
|
*
|
|
* The following block compressed transcode targets are available: @c KTX_TTF_ETC1_RGB,
|
|
* @c KTX_TTF_ETC2_RGBA, @c KTX_TTF_BC1_RGB, @c KTX_TTF_BC3_RGBA,
|
|
* @c KTX_TTF_BC4_R, @c KTX_TTF_BC5_RG, @c KTX_TTF_BC7_RGBA,
|
|
* @c @c KTX_TTF_PVRTC1_4_RGB, @c KTX_TTF_PVRTC1_4_RGBA,
|
|
* @c KTX_TTF_PVRTC2_4_RGB, @c KTX_TTF_PVRTC2_4_RGBA, @c KTX_TTF_ASTC_4x4_RGBA,
|
|
* @c KTX_TTF_ETC2_EAC_R11, @c KTX_TTF_ETC2_EAC_RG11, @c KTX_TTF_ETC and
|
|
* @c KTX_TTF_BC1_OR_3.
|
|
*
|
|
* @c KTX_TTF_ETC automatically selects between @c KTX_TTF_ETC1_RGB and
|
|
* @c KTX_TTF_ETC2_RGBA according to whether an alpha channel is available. @c KTX_TTF_BC1_OR_3
|
|
* does likewise between @c KTX_TTF_BC1_RGB and @c KTX_TTF_BC3_RGBA. Note that if
|
|
* @c KTX_TTF_PVRTC1_4_RGBA or @c KTX_TTF_PVRTC2_4_RGBA is specified and there is no alpha
|
|
* channel @c KTX_TTF_PVRTC1_4_RGB or @c KTX_TTF_PVRTC2_4_RGB respectively will be selected.
|
|
*
|
|
* Transcoding to ATC & FXT1 formats is not supported by libktx as there
|
|
* are no equivalent Vulkan formats.
|
|
*
|
|
* The following uncompressed transcode targets are also available: @c KTX_TTF_RGBA32,
|
|
* @c KTX_TTF_RGB565, KTX_TTF_BGR565 and KTX_TTF_RGBA4444.
|
|
*
|
|
* The following @p transcodeFlags are available.
|
|
*
|
|
* @sa ktxtexture2_CompressBasis().
|
|
*
|
|
* @param[in] This pointer to the ktxTexture2 object of interest.
|
|
* @param[in] outputFormat a value from the ktx_texture_transcode_fmt_e enum
|
|
* specifying the target format.
|
|
* @param[in] transcodeFlags bitfield of flags modifying the transcode
|
|
* operation. @sa ktx_texture_decode_flags_e.
|
|
*
|
|
* @return KTX_SUCCESS on success, other KTX_* enum values on error.
|
|
*
|
|
* @exception KTX_FILE_DATA_ERROR
|
|
* Supercompression global data is corrupted.
|
|
* @exception KTX_INVALID_OPERATION
|
|
* The texture's format is not transcodable (not
|
|
* ETC1S/BasisLZ or UASTC).
|
|
* @exception KTX_INVALID_OPERATION
|
|
* Supercompression global data is missing, i.e.,
|
|
* the texture object is invalid.
|
|
* @exception KTX_INVALID_OPERATION
|
|
* Image data is missing, i.e., the texture object
|
|
* is invalid.
|
|
* @exception KTX_INVALID_OPERATION
|
|
* @p outputFormat is PVRTC1 but the texture does
|
|
* does not have power-of-two dimensions.
|
|
* @exception KTX_INVALID_VALUE @p outputFormat is invalid.
|
|
* @exception KTX_TRANSCODE_FAILED
|
|
* Something went wrong during transcoding.
|
|
* @exception KTX_UNSUPPORTED_FEATURE
|
|
* KTX_TF_PVRTC_DECODE_TO_NEXT_POW2 was requested
|
|
* or the specified transcode target has not been
|
|
* included in the library being used.
|
|
* @exception KTX_OUT_OF_MEMORY Not enough memory to carry out transcoding.
|
|
*/
|
|
KTX_error_code
|
|
ktxTexture2_TranscodeBasis(ktxTexture2* This,
|
|
ktx_transcode_fmt_e outputFormat,
|
|
ktx_transcode_flags transcodeFlags)
|
|
{
|
|
uint32_t* BDB = This->pDfd + 1;
|
|
khr_df_model_e colorModel = (khr_df_model_e)KHR_DFDVAL(BDB, MODEL);
|
|
if (colorModel != KHR_DF_MODEL_UASTC
|
|
// Constructor has checked color model matches BASIS_LZ.
|
|
&& This->supercompressionScheme != KTX_SS_BASIS_LZ)
|
|
{
|
|
return KTX_INVALID_OPERATION; // Not in a transcodable format.
|
|
}
|
|
|
|
DECLARE_PRIVATE(priv, This);
|
|
if (This->supercompressionScheme == KTX_SS_BASIS_LZ) {
|
|
if (!priv._supercompressionGlobalData || priv._sgdByteLength == 0)
|
|
return KTX_INVALID_OPERATION;
|
|
}
|
|
|
|
if (transcodeFlags & KTX_TF_PVRTC_DECODE_TO_NEXT_POW2) {
|
|
debug_printf("ktxTexture_TranscodeBasis: KTX_TF_PVRTC_DECODE_TO_NEXT_POW2 currently unsupported\n");
|
|
return KTX_UNSUPPORTED_FEATURE;
|
|
}
|
|
|
|
if (outputFormat == KTX_TTF_PVRTC1_4_RGB
|
|
|| outputFormat == KTX_TTF_PVRTC1_4_RGBA) {
|
|
if ((!isPow2(This->baseWidth)) || (!isPow2(This->baseHeight))) {
|
|
debug_printf("ktxTexture_TranscodeBasis: PVRTC1 only supports power of 2 dimensions\n");
|
|
return KTX_INVALID_OPERATION;
|
|
}
|
|
}
|
|
|
|
const bool srgb = (KHR_DFDVAL(BDB, TRANSFER) == KHR_DF_TRANSFER_SRGB);
|
|
alpha_content_e alphaContent = eNone;
|
|
if (colorModel == KHR_DF_MODEL_ETC1S) {
|
|
if (KHR_DFDSAMPLECOUNT(BDB) == 2) {
|
|
uint32_t channelId = KHR_DFDSVAL(BDB, 1, CHANNELID);
|
|
if (channelId == KHR_DF_CHANNEL_ETC1S_AAA) {
|
|
alphaContent = eAlpha;
|
|
} else if (channelId == KHR_DF_CHANNEL_ETC1S_GGG){
|
|
alphaContent = eGreen;
|
|
} else {
|
|
return KTX_FILE_DATA_ERROR;
|
|
}
|
|
}
|
|
} else {
|
|
uint32_t channelId = KHR_DFDSVAL(BDB, 0, CHANNELID);
|
|
if (channelId == KHR_DF_CHANNEL_UASTC_RGBA)
|
|
alphaContent = eAlpha;
|
|
else if (channelId == KHR_DF_CHANNEL_UASTC_RRRG)
|
|
alphaContent = eGreen;
|
|
}
|
|
|
|
VkFormat vkFormat;
|
|
|
|
// Do some format mapping.
|
|
switch (outputFormat) {
|
|
case KTX_TTF_BC1_OR_3:
|
|
outputFormat = alphaContent != eNone ? KTX_TTF_BC3_RGBA
|
|
: KTX_TTF_BC1_RGB;
|
|
break;
|
|
case KTX_TTF_ETC:
|
|
outputFormat = alphaContent != eNone ? KTX_TTF_ETC2_RGBA
|
|
: KTX_TTF_ETC1_RGB;
|
|
break;
|
|
case KTX_TTF_PVRTC1_4_RGBA:
|
|
// This transcoder does not write opaque alpha blocks.
|
|
outputFormat = alphaContent != eNone ? KTX_TTF_PVRTC1_4_RGBA
|
|
: KTX_TTF_PVRTC1_4_RGB;
|
|
break;
|
|
case KTX_TTF_PVRTC2_4_RGBA:
|
|
// This transcoder does not write opaque alpha blocks.
|
|
outputFormat = alphaContent != eNone ? KTX_TTF_PVRTC2_4_RGBA
|
|
: KTX_TTF_PVRTC2_4_RGB;
|
|
break;
|
|
default:
|
|
/*NOP*/;
|
|
}
|
|
|
|
switch (outputFormat) {
|
|
case KTX_TTF_ETC1_RGB:
|
|
vkFormat = srgb ? VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK
|
|
: VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
|
|
break;
|
|
case KTX_TTF_ETC2_RGBA:
|
|
vkFormat = srgb ? VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK
|
|
: VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
|
|
break;
|
|
case KTX_TTF_ETC2_EAC_R11:
|
|
vkFormat = VK_FORMAT_EAC_R11_UNORM_BLOCK;
|
|
break;
|
|
case KTX_TTF_ETC2_EAC_RG11:
|
|
vkFormat = VK_FORMAT_EAC_R11G11_UNORM_BLOCK;
|
|
break;
|
|
case KTX_TTF_BC1_RGB:
|
|
// Transcoding doesn't support BC1 alpha.
|
|
vkFormat = srgb ? VK_FORMAT_BC1_RGB_SRGB_BLOCK
|
|
: VK_FORMAT_BC1_RGB_UNORM_BLOCK;
|
|
break;
|
|
case KTX_TTF_BC3_RGBA:
|
|
vkFormat = srgb ? VK_FORMAT_BC3_SRGB_BLOCK
|
|
: VK_FORMAT_BC3_UNORM_BLOCK;
|
|
break;
|
|
case KTX_TTF_BC4_R:
|
|
vkFormat = VK_FORMAT_BC4_UNORM_BLOCK;
|
|
break;
|
|
case KTX_TTF_BC5_RG:
|
|
vkFormat = VK_FORMAT_BC5_UNORM_BLOCK;
|
|
break;
|
|
case KTX_TTF_PVRTC1_4_RGB:
|
|
case KTX_TTF_PVRTC1_4_RGBA:
|
|
vkFormat = srgb ? VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG
|
|
: VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG;
|
|
break;
|
|
case KTX_TTF_PVRTC2_4_RGB:
|
|
case KTX_TTF_PVRTC2_4_RGBA:
|
|
vkFormat = srgb ? VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG
|
|
: VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG;
|
|
break;
|
|
case KTX_TTF_BC7_RGBA:
|
|
vkFormat = srgb ? VK_FORMAT_BC7_SRGB_BLOCK
|
|
: VK_FORMAT_BC7_UNORM_BLOCK;
|
|
break;
|
|
case KTX_TTF_ASTC_4x4_RGBA:
|
|
vkFormat = srgb ? VK_FORMAT_ASTC_4x4_SRGB_BLOCK
|
|
: VK_FORMAT_ASTC_4x4_UNORM_BLOCK;
|
|
break;
|
|
case KTX_TTF_RGB565:
|
|
vkFormat = VK_FORMAT_R5G6B5_UNORM_PACK16;
|
|
break;
|
|
case KTX_TTF_BGR565:
|
|
vkFormat = VK_FORMAT_B5G6R5_UNORM_PACK16;
|
|
break;
|
|
case KTX_TTF_RGBA4444:
|
|
vkFormat = VK_FORMAT_R4G4B4A4_UNORM_PACK16;
|
|
break;
|
|
case KTX_TTF_RGBA32:
|
|
vkFormat = srgb ? VK_FORMAT_R8G8B8A8_SRGB
|
|
: VK_FORMAT_R8G8B8A8_UNORM;
|
|
break;
|
|
default:
|
|
return KTX_INVALID_VALUE;
|
|
}
|
|
|
|
basis_tex_format textureFormat;
|
|
if (colorModel == KHR_DF_MODEL_UASTC)
|
|
textureFormat = basis_tex_format::cUASTC4x4;
|
|
else
|
|
textureFormat = basis_tex_format::cETC1S;
|
|
|
|
if (!basis_is_format_supported((transcoder_texture_format)outputFormat,
|
|
textureFormat)) {
|
|
return KTX_UNSUPPORTED_FEATURE;
|
|
}
|
|
|
|
|
|
// Create a prototype texture to use for calculating sizes in the target
|
|
// format and, as useful side effects, provide us with a properly sized
|
|
// data allocation and the DFD for the target format.
|
|
ktxTextureCreateInfo createInfo;
|
|
createInfo.glInternalformat = 0;
|
|
createInfo.vkFormat = vkFormat;
|
|
createInfo.baseWidth = This->baseWidth;
|
|
createInfo.baseHeight = This->baseHeight;
|
|
createInfo.baseDepth = This->baseDepth;
|
|
createInfo.generateMipmaps = This->generateMipmaps;
|
|
createInfo.isArray = This->isArray;
|
|
createInfo.numDimensions = This->numDimensions;
|
|
createInfo.numFaces = This->numFaces;
|
|
createInfo.numLayers = This->numLayers;
|
|
createInfo.numLevels = This->numLevels;
|
|
createInfo.pDfd = nullptr;
|
|
|
|
KTX_error_code result;
|
|
ktxTexture2* prototype;
|
|
result = ktxTexture2_Create(&createInfo, KTX_TEXTURE_CREATE_ALLOC_STORAGE,
|
|
&prototype);
|
|
|
|
if (result != KTX_SUCCESS) {
|
|
assert(result == KTX_OUT_OF_MEMORY); // The only run time error
|
|
return result;
|
|
}
|
|
|
|
if (!This->pData) {
|
|
if (ktxTexture_isActiveStream((ktxTexture*)This)) {
|
|
// Load pending. Complete it.
|
|
result = ktxTexture2_LoadImageData(This, NULL, 0);
|
|
if (result != KTX_SUCCESS)
|
|
{
|
|
ktxTexture2_Destroy(prototype);
|
|
return result;
|
|
}
|
|
} else {
|
|
// No data to transcode.
|
|
ktxTexture2_Destroy(prototype);
|
|
return KTX_INVALID_OPERATION;
|
|
}
|
|
}
|
|
|
|
// Transcoder global initialization. Requires ~9 milliseconds when compiled
|
|
// and executed natively on a Core i7 2.2 GHz. If this is too slow, the
|
|
// tables it computes can easily be moved to be compiled in.
|
|
static bool transcoderInitialized;
|
|
if (!transcoderInitialized) {
|
|
basisu_transcoder_init();
|
|
transcoderInitialized = true;
|
|
}
|
|
|
|
if (textureFormat == basis_tex_format::cETC1S) {
|
|
result = ktxTexture2_transcodeLzEtc1s(This, alphaContent,
|
|
prototype, outputFormat,
|
|
transcodeFlags);
|
|
} else {
|
|
result = ktxTexture2_transcodeUastc(This, alphaContent,
|
|
prototype, outputFormat,
|
|
transcodeFlags);
|
|
}
|
|
|
|
if (result == KTX_SUCCESS) {
|
|
// Fix up the current texture
|
|
DECLARE_PROTECTED(thisPrtctd, This);
|
|
DECLARE_PRIVATE(protoPriv, prototype);
|
|
DECLARE_PROTECTED(protoPrtctd, prototype);
|
|
memcpy(&thisPrtctd._formatSize, &protoPrtctd._formatSize,
|
|
sizeof(ktxFormatSize));
|
|
This->vkFormat = vkFormat;
|
|
This->isCompressed = prototype->isCompressed;
|
|
This->supercompressionScheme = KTX_SS_NONE;
|
|
priv._requiredLevelAlignment = protoPriv._requiredLevelAlignment;
|
|
// Copy the levelIndex from the prototype to This.
|
|
memcpy(priv._levelIndex, protoPriv._levelIndex,
|
|
This->numLevels * sizeof(ktxLevelIndexEntry));
|
|
// Move the DFD and data from the prototype to This.
|
|
free(This->pDfd);
|
|
This->pDfd = prototype->pDfd;
|
|
prototype->pDfd = 0;
|
|
free(This->pData);
|
|
This->pData = prototype->pData;
|
|
This->dataSize = prototype->dataSize;
|
|
prototype->pData = 0;
|
|
prototype->dataSize = 0;
|
|
}
|
|
ktxTexture2_Destroy(prototype);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @memberof ktxTexture2 @private
|
|
* @ingroup reader
|
|
* @~English
|
|
* @brief Transcode a KTX2 texture with BasisLZ supercompressed ETC1S images.
|
|
*
|
|
* Inflates the images from BasisLZ supercompression back to ETC1S
|
|
* then transcodes them to the specified block-compressed format. The
|
|
* transcoded images replace the original images and the texture's fields
|
|
* including the DFD are modified to reflect the new format.
|
|
*
|
|
* BasisLZ supercompressed textures must be transcoded to a desired target
|
|
* block-compressed format before they can be uploaded to a GPU via a graphics
|
|
* API.
|
|
*
|
|
* The following block compressed transcode targets are available: @c KTX_TTF_ETC1_RGB,
|
|
* @c KTX_TTF_ETC2_RGBA, @c KTX_TTF_BC1_RGB, @c KTX_TTF_BC3_RGBA,
|
|
* @c KTX_TTF_BC4_R, @c KTX_TTF_BC5_RG, @c KTX_TTF_BC7_RGBA,
|
|
* @c @c KTX_TTF_PVRTC1_4_RGB, @c KTX_TTF_PVRTC1_4_RGBA,
|
|
* @c KTX_TTF_PVRTC2_4_RGB, @c KTX_TTF_PVRTC2_4_RGBA, @c KTX_TTF_ASTC_4x4_RGBA,
|
|
* @c KTX_TTF_ETC2_EAC_R11, @c KTX_TTF_ETC2_EAC_RG11, @c KTX_TTF_ETC and
|
|
* @c KTX_TTF_BC1_OR_3.
|
|
*
|
|
* @c KTX_TTF_ETC automatically selects between @c KTX_TTF_ETC1_RGB and
|
|
* @c KTX_TTF_ETC2_RGBA according to whether an alpha channel is available. @c KTX_TTF_BC1_OR_3
|
|
* does likewise between @c KTX_TTF_BC1_RGB and @c KTX_TTF_BC3_RGBA. Note that if
|
|
* @c KTX_TTF_PVRTC1_4_RGBA or @c KTX_TTF_PVRTC2_4_RGBA is specified and there is no alpha
|
|
* channel @c KTX_TTF_PVRTC1_4_RGB or @c KTX_TTF_PVRTC2_4_RGB respectively will be selected.
|
|
*
|
|
* ATC & FXT1 formats are not supported by KTX2 & libktx as there are no equivalent Vulkan formats.
|
|
*
|
|
* The following uncompressed transcode targets are also available: @c KTX_TTF_RGBA32,
|
|
* @c KTX_TTF_RGB565, KTX_TTF_BGR565 and KTX_TTF_RGBA4444.
|
|
*
|
|
* The following @p transcodeFlags are available.
|
|
*
|
|
* @sa ktxtexture2_CompressBasis().
|
|
*
|
|
* @param[in] This pointer to the ktxTexture2 object of interest.
|
|
* @param[in] outputFormat a value from the ktx_texture_transcode_fmt_e enum
|
|
* specifying the target format.
|
|
* @param[in] transcodeFlags bitfield of flags modifying the transcode
|
|
* operation. @sa ktx_texture_decode_flags_e.
|
|
*
|
|
* @return KTX_SUCCESS on success, other KTX_* enum values on error.
|
|
*
|
|
* @exception KTX_FILE_DATA_ERROR
|
|
* Supercompression global data is corrupted.
|
|
* @exception KTX_INVALID_OPERATION
|
|
* The texture's format is not transcodable (not
|
|
* ETC1S/BasisLZ or UASTC).
|
|
* @exception KTX_INVALID_OPERATION
|
|
* Supercompression global data is missing, i.e.,
|
|
* the texture object is invalid.
|
|
* @exception KTX_INVALID_OPERATION
|
|
* Image data is missing, i.e., the texture object
|
|
* is invalid.
|
|
* @exception KTX_INVALID_OPERATION
|
|
* @p outputFormat is PVRTC1 but the texture does
|
|
* does not have power-of-two dimensions.
|
|
* @exception KTX_INVALID_VALUE @p outputFormat is invalid.
|
|
* @exception KTX_TRANSCODE_FAILED
|
|
* Something went wrong during transcoding. The
|
|
* texture object will be corrupted.
|
|
* @exception KTX_UNSUPPORTED_FEATURE
|
|
* KTX_TF_PVRTC_DECODE_TO_NEXT_POW2 was requested
|
|
* or the specified transcode target has not been
|
|
* included in the library being used.
|
|
* @exception KTX_OUT_OF_MEMORY Not enough memory to carry out transcoding.
|
|
*/
|
|
KTX_error_code
|
|
ktxTexture2_transcodeLzEtc1s(ktxTexture2* This,
|
|
alpha_content_e alphaContent,
|
|
ktxTexture2* prototype,
|
|
ktx_transcode_fmt_e outputFormat,
|
|
ktx_transcode_flags transcodeFlags)
|
|
{
|
|
DECLARE_PRIVATE(priv, This);
|
|
DECLARE_PRIVATE(protoPriv, prototype);
|
|
KTX_error_code result = KTX_SUCCESS;
|
|
|
|
assert(This->supercompressionScheme == KTX_SS_BASIS_LZ);
|
|
|
|
uint8_t* bgd = priv._supercompressionGlobalData;
|
|
ktxBasisLzGlobalHeader& bgdh = *reinterpret_cast<ktxBasisLzGlobalHeader*>(bgd);
|
|
if (!(bgdh.endpointsByteLength && bgdh.selectorsByteLength && bgdh.tablesByteLength)) {
|
|
debug_printf("ktxTexture_TranscodeBasis: missing endpoints, selectors or tables");
|
|
return KTX_FILE_DATA_ERROR;
|
|
}
|
|
|
|
// Compute some helpful numbers.
|
|
//
|
|
// firstImages contains the indices of the first images for each level to
|
|
// ease finding the correct slice description when iterating from smallest
|
|
// level to largest or when randomly accessing them (t.b.c). The last array
|
|
// entry contains the total number of images, for calculating the offsets
|
|
// of the endpoints, etc.
|
|
uint32_t* firstImages = new uint32_t[This->numLevels+1];
|
|
|
|
// Temporary invariant value
|
|
uint32_t layersFaces = This->numLayers * This->numFaces;
|
|
firstImages[0] = 0;
|
|
for (uint32_t level = 1; level <= This->numLevels; level++) {
|
|
// NOTA BENE: numFaces * depth is only reasonable because they can't
|
|
// both be > 1. I.e there are no 3d cubemaps.
|
|
firstImages[level] = firstImages[level - 1]
|
|
+ layersFaces * MAX(This->baseDepth >> (level - 1), 1);
|
|
}
|
|
uint32_t& imageCount = firstImages[This->numLevels];
|
|
|
|
if (BGD_TABLES_ADDR(0, bgdh, imageCount) + bgdh.tablesByteLength > priv._sgdByteLength) {
|
|
return KTX_FILE_DATA_ERROR;
|
|
}
|
|
// FIXME: Do more validation.
|
|
|
|
// Prepare low-level transcoder for transcoding slices.
|
|
basist::basisu_lowlevel_etc1s_transcoder bit;
|
|
|
|
// basisu_transcoder_state is used to find the previous frame when
|
|
// decoding a video P-Frame. It tracks the previous frame for each mip
|
|
// level. For cube map array textures we need to find the previous frame
|
|
// for each face so we a state per face. Although providing this is only
|
|
// needed for video, it is easier to always pass our own.
|
|
std::vector<basisu_transcoder_state> xcoderStates;
|
|
xcoderStates.resize(This->isVideo ? This->numFaces : 1);
|
|
|
|
bit.decode_palettes(bgdh.endpointCount, BGD_ENDPOINTS_ADDR(bgd, imageCount),
|
|
bgdh.endpointsByteLength,
|
|
bgdh.selectorCount, BGD_SELECTORS_ADDR(bgd, bgdh, imageCount),
|
|
bgdh.selectorsByteLength);
|
|
|
|
bit.decode_tables(BGD_TABLES_ADDR(bgd, bgdh, imageCount),
|
|
bgdh.tablesByteLength);
|
|
|
|
// Find matching VkFormat and calculate output sizes.
|
|
|
|
const bool isVideo = This->isVideo;
|
|
|
|
ktx_uint8_t* pXcodedData = prototype->pData;
|
|
// Inconveniently, the output buffer size parameter of transcode_image
|
|
// has to be in pixels for uncompressed output and in blocks for
|
|
// compressed output. The only reason for humouring the API is so
|
|
// its buffer size tests provide a real check. An alternative is to
|
|
// always provide the size in bytes which will always pass.
|
|
ktx_uint32_t outputBlockByteLength
|
|
= prototype->_protected->_formatSize.blockSizeInBits / 8;
|
|
ktx_size_t xcodedDataLength
|
|
= prototype->dataSize / outputBlockByteLength;
|
|
ktxLevelIndexEntry* protoLevelIndex;
|
|
uint64_t levelOffsetWrite;
|
|
const ktxBasisLzEtc1sImageDesc* imageDescs = BGD_ETC1S_IMAGE_DESCS(bgd);
|
|
|
|
// Finally we're ready to transcode the slices.
|
|
|
|
// FIXME: Iframe flag needs to be queryable by the application. In Basis
|
|
// the app can query file_info and image_info from the transcoder which
|
|
// returns a structure with lots of info about the image.
|
|
|
|
protoLevelIndex = protoPriv._levelIndex;
|
|
levelOffsetWrite = 0;
|
|
for (int32_t level = This->numLevels - 1; level >= 0; level--) {
|
|
uint64_t levelOffset = ktxTexture2_levelDataOffset(This, level);
|
|
uint64_t writeOffset = levelOffsetWrite;
|
|
uint64_t writeOffsetBlocks = levelOffsetWrite / outputBlockByteLength;
|
|
uint32_t levelWidth = MAX(1, This->baseWidth >> level);
|
|
uint32_t levelHeight = MAX(1, This->baseHeight >> level);
|
|
// ETC1S texel block dimensions
|
|
const uint32_t bw = 4, bh = 4;
|
|
uint32_t levelBlocksX = (levelWidth + (bw - 1)) / bw;
|
|
uint32_t levelBlocksY = (levelHeight + (bh - 1)) / bh;
|
|
uint32_t depth = MAX(1, This->baseDepth >> level);
|
|
//uint32_t faceSlices = This->numFaces == 1 ? depth : This->numFaces;
|
|
uint32_t faceSlices = This->numFaces * depth;
|
|
uint32_t numImages = This->numLayers * faceSlices;
|
|
uint32_t image = firstImages[level];
|
|
uint32_t endImage = image + numImages;
|
|
ktx_size_t levelImageSizeOut, levelSizeOut;
|
|
uint32_t stateIndex = 0;
|
|
|
|
levelSizeOut = 0;
|
|
// FIXME: Figure out a way to get the size out of the transcoder.
|
|
levelImageSizeOut = ktxTexture2_GetImageSize(prototype, level);
|
|
for (; image < endImage; image++) {
|
|
const ktxBasisLzEtc1sImageDesc& imageDesc = imageDescs[image];
|
|
|
|
basisu_transcoder_state& xcoderState = xcoderStates[stateIndex];
|
|
// We have face0 [face1 ...] within each layer. Use `stateIndex`
|
|
// rather than a double loop of layers and faceSlices as this
|
|
// works for 3d texture and non-array cube maps as well as
|
|
// cube map arrays without special casing.
|
|
if (++stateIndex == xcoderStates.size())
|
|
stateIndex = 0;
|
|
|
|
if (alphaContent != eNone)
|
|
{
|
|
// The slice descriptions should have alpha information.
|
|
if (imageDesc.alphaSliceByteOffset == 0
|
|
|| imageDesc.alphaSliceByteLength == 0)
|
|
return KTX_FILE_DATA_ERROR;
|
|
}
|
|
|
|
bool status;
|
|
status = bit.transcode_image(
|
|
(transcoder_texture_format)outputFormat,
|
|
pXcodedData + writeOffset,
|
|
(uint32_t)(xcodedDataLength - writeOffsetBlocks),
|
|
This->pData,
|
|
(uint32_t)This->dataSize,
|
|
levelBlocksX,
|
|
levelBlocksY,
|
|
levelWidth,
|
|
levelHeight,
|
|
level,
|
|
(uint32_t)(levelOffset + imageDesc.rgbSliceByteOffset),
|
|
imageDesc.rgbSliceByteLength,
|
|
(uint32_t)(levelOffset + imageDesc.alphaSliceByteOffset),
|
|
imageDesc.alphaSliceByteLength,
|
|
transcodeFlags,
|
|
alphaContent != eNone,
|
|
isVideo,
|
|
// Our P-Frame flag is in the same bit as
|
|
// cSliceDescFlagsFrameIsIFrame. We have to
|
|
// invert it to make it an I-Frame flag.
|
|
//
|
|
// API currently doesn't have any way to pass
|
|
// the I-Frame flag.
|
|
//imageDesc.imageFlags ^ cSliceDescFlagsFrameIsIFrame,
|
|
0, // output_row_pitch_in_blocks_or_pixels
|
|
&xcoderState,
|
|
0 // output_rows_in_pixels
|
|
);
|
|
if (!status) {
|
|
result = KTX_TRANSCODE_FAILED;
|
|
goto cleanup;
|
|
}
|
|
|
|
writeOffset += levelImageSizeOut;
|
|
levelSizeOut += levelImageSizeOut;
|
|
} // end images loop
|
|
protoLevelIndex[level].byteOffset = levelOffsetWrite;
|
|
protoLevelIndex[level].byteLength = levelSizeOut;
|
|
protoLevelIndex[level].uncompressedByteLength = levelSizeOut;
|
|
levelOffsetWrite += levelSizeOut;
|
|
assert(levelOffsetWrite == writeOffset);
|
|
// In case of transcoding to uncompressed.
|
|
levelOffsetWrite = _KTX_PADN(protoPriv._requiredLevelAlignment,
|
|
levelOffsetWrite);
|
|
} // level loop
|
|
|
|
result = KTX_SUCCESS;
|
|
|
|
cleanup:
|
|
delete[] firstImages;
|
|
return result;
|
|
}
|
|
|
|
|
|
KTX_error_code
|
|
ktxTexture2_transcodeUastc(ktxTexture2* This,
|
|
alpha_content_e alphaContent,
|
|
ktxTexture2* prototype,
|
|
ktx_transcode_fmt_e outputFormat,
|
|
ktx_transcode_flags transcodeFlags)
|
|
{
|
|
assert(This->supercompressionScheme != KTX_SS_BASIS_LZ);
|
|
|
|
ktx_uint8_t* pXcodedData = prototype->pData;
|
|
ktx_uint32_t outputBlockByteLength
|
|
= prototype->_protected->_formatSize.blockSizeInBits / 8;
|
|
ktx_size_t xcodedDataLength
|
|
= prototype->dataSize / outputBlockByteLength;
|
|
DECLARE_PRIVATE(protoPriv, prototype);
|
|
ktxLevelIndexEntry* protoLevelIndex = protoPriv._levelIndex;
|
|
ktx_size_t levelOffsetWrite = 0;
|
|
|
|
basisu_lowlevel_uastc_transcoder uit;
|
|
// See comment on same declaration in transcodeEtc1s.
|
|
std::vector<basisu_transcoder_state> xcoderStates;
|
|
xcoderStates.resize(This->isVideo ? This->numFaces : 1);
|
|
|
|
for (ktx_int32_t level = This->numLevels - 1; level >= 0; level--)
|
|
{
|
|
ktx_uint32_t depth;
|
|
uint64_t writeOffset = levelOffsetWrite;
|
|
uint64_t writeOffsetBlocks = levelOffsetWrite / outputBlockByteLength;
|
|
ktx_size_t levelImageSizeIn, levelImageOffsetIn;
|
|
ktx_size_t levelImageSizeOut, levelSizeOut;
|
|
ktx_uint32_t levelImageCount;
|
|
uint32_t levelWidth = MAX(1, This->baseWidth >> level);
|
|
uint32_t levelHeight = MAX(1, This->baseHeight >> level);
|
|
// UASTC texel block dimensions
|
|
const uint32_t bw = 4, bh = 4;
|
|
uint32_t levelBlocksX = (levelWidth + (bw - 1)) / bw;
|
|
uint32_t levelBlocksY = (levelHeight + (bh - 1)) / bh;
|
|
uint32_t stateIndex = 0;
|
|
|
|
depth = MAX(1, This->baseDepth >> level);
|
|
|
|
levelImageCount = This->numLayers * This->numFaces * depth;
|
|
levelImageSizeIn = ktxTexture_calcImageSize(ktxTexture(This), level,
|
|
KTX_FORMAT_VERSION_TWO);
|
|
levelImageSizeOut = ktxTexture_calcImageSize(ktxTexture(prototype),
|
|
level,
|
|
KTX_FORMAT_VERSION_TWO);
|
|
|
|
levelImageOffsetIn = ktxTexture2_levelDataOffset(This, level);
|
|
levelSizeOut = 0;
|
|
bool status;
|
|
for (uint32_t image = 0; image < levelImageCount; image++) {
|
|
basisu_transcoder_state& xcoderState = xcoderStates[stateIndex];
|
|
// See comment before same lines in transcodeEtc1s.
|
|
if (++stateIndex == xcoderStates.size())
|
|
stateIndex = 0;
|
|
|
|
status = uit.transcode_image(
|
|
(transcoder_texture_format)outputFormat,
|
|
pXcodedData + writeOffset,
|
|
(uint32_t)(xcodedDataLength - writeOffsetBlocks),
|
|
This->pData,
|
|
(uint32_t)This->dataSize,
|
|
levelBlocksX,
|
|
levelBlocksY,
|
|
levelWidth,
|
|
levelHeight,
|
|
level,
|
|
(uint32_t)levelImageOffsetIn,
|
|
(uint32_t)levelImageSizeIn,
|
|
transcodeFlags,
|
|
alphaContent != eNone,
|
|
This->isVideo, // is_video
|
|
//imageDesc.imageFlags ^ cSliceDescFlagsFrameIsIFrame,
|
|
0, // output_row_pitch_in_blocks_or_pixels
|
|
&xcoderState, // pState
|
|
0, // output_rows_in_pixels,
|
|
-1, // channel0
|
|
-1 // channel1
|
|
);
|
|
if (!status)
|
|
return KTX_TRANSCODE_FAILED;
|
|
writeOffset += levelImageSizeOut;
|
|
levelSizeOut += levelImageSizeOut;
|
|
levelImageOffsetIn += levelImageSizeIn;
|
|
}
|
|
protoLevelIndex[level].byteOffset = levelOffsetWrite;
|
|
// writeOffset will be equal to total size of the images in the level.
|
|
protoLevelIndex[level].byteLength = levelSizeOut;
|
|
protoLevelIndex[level].uncompressedByteLength = levelSizeOut;
|
|
levelOffsetWrite += levelSizeOut;
|
|
}
|
|
// In case of transcoding to uncompressed.
|
|
levelOffsetWrite = _KTX_PADN(protoPriv._requiredLevelAlignment,
|
|
levelOffsetWrite);
|
|
return KTX_SUCCESS;
|
|
}
|