hyzboy/TexConv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
TexConv/Applications/_Plugins/Common/TextureIO.cpp

887 lines
32 KiB
C++
Raw Blame History

//=====================================================================
// Copyright 2008 (c), ATI Technologies Inc. All rights reserved.
// Copyright 2016 (c), Advanced Micro Devices, Inc. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files(the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions :
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
/// \file TextureIO.cpp
/// \version 2.20
//
//=====================================================================
#include "textureio.h"
#include "compressonator.h"
#include "common.h"
#include "cmp_fileio.h"
#include "pluginmanager.h"
#include "plugininterface.h"
#include <gpu_decode.h>
// #if defined(WIN32) && !defined(NO_LEGACY_BEHAVIOR)
// #define OPTION_CMP_QT
// #endif
#if (OPTION_CMP_QT == 1)
#include <mipstoqimage.h>
#include <QtCore/QCoreApplication>
#include <QtGui/qimage.h>
#include <QtGui/qrgb.h>
#ifdef _DEBUG
#pragma comment(lib, "Qt5Cored.lib")
#pragma comment(lib, "Qt5Guid.lib")
#else
#pragma comment(lib, "Qt5Core.lib")
#pragma comment(lib, "Qt5Gui.lib")
#endif
#endif // CMP_USE_QT
#include <algorithm>
#include <iostream>
#include <string>
#include <locale>
#include <cstdio>
using namespace std;
// Global plugin manager instance
extern PluginManager g_pluginManager;
extern bool g_bAbortCompression;
inline CMP_FLOAT clamp(CMP_FLOAT a, CMP_FLOAT l, CMP_FLOAT h) {
return (a < l) ? l : ((a > h) ? h : a);
}
void astc_find_closest_blockdim_2d(float target_bitrate, int *x, int *y, int consider_illegal) {
int blockdims[6] = { 4, 5, 6, 8, 10, 12 };
float best_error = 1000;
float aspect_of_best = 1;
int i, j;
// Y dimension
for (i = 0; i < 6; i++) {
// X dimension
for (j = i; j < 6; j++) {
// NxN MxN 8x5 10x5 10x6
int is_legal = (j == i) || (j == i + 1) || (j == 3 && j == 1) || (j == 4 && j == 1) || (j == 4 && j == 2);
if (consider_illegal || is_legal) {
float bitrate = 128.0f / (blockdims[i] * blockdims[j]);
float bitrate_error = fabs(bitrate - target_bitrate);
float aspect = (float)blockdims[j] / blockdims[i];
if (bitrate_error < best_error || (bitrate_error == best_error && aspect < aspect_of_best)) {
*x = blockdims[j];
*y = blockdims[i];
best_error = bitrate_error;
aspect_of_best = aspect;
}
}
}
}
}
void astc_find_closest_blockxy_2d(int *x, int *y, int consider_illegal) {
(void)consider_illegal;
int blockdims[6] = { 4, 5, 6, 8, 10, 12 };
bool exists_x = std::find(std::begin(blockdims), std::end(blockdims), (*x)) != std::end(blockdims);
bool exists_y = std::find(std::begin(blockdims), std::end(blockdims), (*y)) != std::end(blockdims);
if (exists_x && exists_y) {
if ((*x) < (*y)) {
int temp = *x;
*x = *y;
*y = temp;
}
float bitrateF = float(128.0f / ((*x)*(*y)));
astc_find_closest_blockdim_2d(bitrateF, x, y, 0);
} else {
float bitrateF = float(128.0f / ((*x)*(*y)));
astc_find_closest_blockdim_2d(bitrateF, x, y, 0);
}
}
bool DeCompressionCallback(float fProgress, CMP_DWORD_PTR pUser1, CMP_DWORD_PTR pUser2) {
UNREFERENCED_PARAMETER(pUser1);
UNREFERENCED_PARAMETER(pUser2);
static float Progress = 0;
if (fProgress > Progress)
Progress = fProgress;
PrintInfo("\rDeCompression progress = %3.0f", Progress);
return g_bAbortCompression;
}
bool IsDestinationUnCompressed(const char *fname) {
bool isuncompressed = true;
std::string file_extension = CMP_GetJustFileExt(fname);
// tolower
for(char& c : file_extension)
c =tolower(c);
if (file_extension.compare(".dds") == 0) {
isuncompressed = false;
}
else if (file_extension.compare(".astc") == 0) {
isuncompressed = false;
}
else if (file_extension.compare(".ktx") == 0) {
isuncompressed = false;
}
else if (file_extension.compare(".ktx2") == 0)
{
isuncompressed = false;
}
else if (file_extension.compare(".raw") == 0)
{
isuncompressed = false;
} else if (file_extension.compare(".basis") == 0) {
isuncompressed = false;
}
#ifdef USE_CRN
else if (file_extension.compare(".crn") == 0) {
isuncompressed = false;
}
#endif
return isuncompressed;
}
CMP_FORMAT FormatByFileExtension(const char *fname, MipSet *pMipSet) {
std::string file_extension = CMP_GetJustFileExt(fname);
// To upper
std::transform(file_extension.begin(), file_extension.end(), file_extension.begin(),
[](unsigned char c) -> unsigned char { return tolower(c); });
pMipSet->m_TextureDataType = TDT_ARGB;
if (file_extension.compare(".exr") == 0) {
pMipSet->m_ChannelFormat = CF_Float16;
return CMP_FORMAT_ARGB_16F;
}
pMipSet->m_ChannelFormat = CF_8bit;
return CMP_FORMAT_ARGB_8888;
}
CMP_FORMAT GetFormat(CMP_DWORD dwFourCC) {
switch(dwFourCC) {
case CMP_FOURCC_ATI1N: return CMP_FORMAT_ATI1N;
case CMP_FOURCC_ATI2N: return CMP_FORMAT_ATI2N;
case CMP_FOURCC_ATI2N_XY: return CMP_FORMAT_ATI2N_XY;
case CMP_FOURCC_ATI2N_DXT5: return CMP_FORMAT_ATI2N_DXT5;
case CMP_FOURCC_DXT1: return CMP_FORMAT_DXT1;
case CMP_FOURCC_DXT3: return CMP_FORMAT_DXT3;
case CMP_FOURCC_DXT5: return CMP_FORMAT_DXT5;
case CMP_FOURCC_DXT5_xGBR: return CMP_FORMAT_DXT5_xGBR;
case CMP_FOURCC_DXT5_RxBG: return CMP_FORMAT_DXT5_RxBG;
case CMP_FOURCC_DXT5_RBxG: return CMP_FORMAT_DXT5_RBxG;
case CMP_FOURCC_DXT5_xRBG: return CMP_FORMAT_DXT5_xRBG;
case CMP_FOURCC_DXT5_RGxB: return CMP_FORMAT_DXT5_RGxB;
case CMP_FOURCC_DXT5_xGxR: return CMP_FORMAT_DXT5_xGxR;
// Deprecated but still supported for decompression
// Some definition are not valid FOURCC values nut are used as Custom formats
// so that DDS files can be used for storage
case CMP_FOURCC_DXT5_GXRB: return CMP_FORMAT_DXT5_xRBG;
case CMP_FOURCC_DXT5_GRXB: return CMP_FORMAT_DXT5_RxBG;
case CMP_FOURCC_DXT5_RXGB: return CMP_FORMAT_DXT5_xGBR;
case CMP_FOURCC_DXT5_BRGX: return CMP_FORMAT_DXT5_RGxB;
case CMP_FOURCC_ATC_RGB: return CMP_FORMAT_ATC_RGB;
case CMP_FOURCC_ATC_RGBA_EXPLICIT: return CMP_FORMAT_ATC_RGBA_Explicit;
case CMP_FOURCC_ATC_RGBA_INTERP: return CMP_FORMAT_ATC_RGBA_Interpolated;
case CMP_FOURCC_ETC_RGB: return CMP_FORMAT_ETC_RGB;
case CMP_FOURCC_ETC2_RGB: return CMP_FORMAT_ETC2_RGB;
case CMP_FOURCC_ETC2_SRGB: return CMP_FORMAT_ETC2_SRGB;
case CMP_FOURCC_ETC2_RGBA: return CMP_FORMAT_ETC2_RGBA;
case CMP_FOURCC_ETC2_RGBA1: return CMP_FORMAT_ETC2_RGBA1;
case CMP_FOURCC_ETC2_SRGBA: return CMP_FORMAT_ETC2_SRGBA;
case CMP_FOURCC_ETC2_SRGBA1: return CMP_FORMAT_ETC2_SRGBA1;
case CMP_FOURCC_BC4S: return CMP_FORMAT_BC4_S;
case CMP_FOURCC_BC4:
case CMP_FOURCC_BC4U: return CMP_FORMAT_ATI1N;
case CMP_FOURCC_BC5: return CMP_FORMAT_BC5;
case CMP_FOURCC_BC5S: return CMP_FORMAT_BC5_S;
case CMP_FOURCC_BC6H: return CMP_FORMAT_BC6H;
case CMP_FOURCC_BC7: return CMP_FORMAT_BC7;
case CMP_FOURCC_ASTC: return CMP_FORMAT_ASTC;
#ifdef USE_APC
case CMP_FOURCC_APC: return CMP_FORMAT_APC;
#endif
#ifdef USE_GTC
case CMP_FOURCC_GTC: return CMP_FORMAT_GTC;
#endif
#ifdef USE_BASIS
case CMP_FOURCC_BASIS: return CMP_FORMAT_BASIS;
#endif
default:
return CMP_FORMAT_Unknown;
}
}
CMP_FORMAT GetFormat(MipSet* pMipSet) {
assert(pMipSet);
if(pMipSet == NULL)
return CMP_FORMAT_Unknown;
switch(pMipSet->m_ChannelFormat) {
case CF_8bit:
switch(pMipSet->m_TextureDataType) {
case TDT_R:
return CMP_FORMAT_R_8;
case TDT_RG:
return CMP_FORMAT_RG_8;
default:
return CMP_FORMAT_ARGB_8888;
}
case CF_Float16:
switch(pMipSet->m_TextureDataType) {
case TDT_R:
return CMP_FORMAT_R_16F;
case TDT_RG:
return CMP_FORMAT_RG_16F;
default:
return CMP_FORMAT_ARGB_16F;
}
case CF_Float32:
switch(pMipSet->m_TextureDataType) {
case TDT_R:
return CMP_FORMAT_R_32F;
case TDT_RG:
return CMP_FORMAT_RG_32F;
default:
return CMP_FORMAT_ARGB_32F;
}
case CF_Float9995E:
return CMP_FORMAT_RGBE_32F;
case CF_Compressed:
return GetFormat(pMipSet->m_dwFourCC2 ? pMipSet->m_dwFourCC2 : pMipSet->m_dwFourCC);
case CF_16bit:
switch(pMipSet->m_TextureDataType) {
case TDT_R:
return CMP_FORMAT_R_16;
case TDT_RG:
return CMP_FORMAT_RG_16;
default:
return CMP_FORMAT_ARGB_16;
}
case CF_2101010:
return CMP_FORMAT_ARGB_2101010;
#ifdef ARGB_32_SUPPORT
case CF_32bit:
switch(pMipSet->m_TextureDataType) {
case TDT_R:
return CMP_FORMAT_R_32;
case TDT_RG:
return CMP_FORMAT_RG_32;
default:
return CMP_FORMAT_ARGB_32;
}
#endif // ARGB_32_SUPPORT
default:
return CMP_FORMAT_Unknown;
}
}
bool FloatFormat(CMP_FORMAT InFormat) {
switch (InFormat) {
case CMP_FORMAT_ARGB_16F:
case CMP_FORMAT_ABGR_16F:
case CMP_FORMAT_RGBA_16F:
case CMP_FORMAT_BGRA_16F:
case CMP_FORMAT_RG_16F:
case CMP_FORMAT_R_16F:
case CMP_FORMAT_ARGB_32F:
case CMP_FORMAT_ABGR_32F:
case CMP_FORMAT_RGBA_32F:
case CMP_FORMAT_BGRA_32F:
case CMP_FORMAT_RGB_32F:
case CMP_FORMAT_BGR_32F:
case CMP_FORMAT_RG_32F:
case CMP_FORMAT_R_32F:
case CMP_FORMAT_BC6H:
case CMP_FORMAT_BC6H_SF:
case CMP_FORMAT_RGBE_32F: {
return true;
}
break;
default:
break;
}
return false;
}
bool CompressedFileFormat(std::string file) {
std::string file_extension = CMP_GetJustFileExt(file);
// To upper
std::transform(file_extension.begin(), file_extension.end(), file_extension.begin(),
[](unsigned char c) -> unsigned char { return toupper(c); });
file_extension.erase(std::remove(file_extension.begin(), file_extension.end(), '.'), file_extension.end());
if (file_extension == "BMP")
return false;
else
return true;
}
//
// Used exclusively by the GUI app: when using CPU/GPU based decode
// ToDo : Remove this code and try to use ProcessCMDLine
MipSet* DecompressMIPSet(MipSet *MipSetIn, CMP_GPUDecode decodeWith, Config *configSetting, CMP_Feedback_Proc pFeedbackProc) {
// validate MipSet is Compressed
if (!MipSetIn->m_compressed) return NULL;
if ((MipSetIn->m_TextureType == TT_CubeMap) && !(configSetting->useCPU)) {
configSetting->errMessage = "GPU based cubemap decode is currently not supported in this version.Please view decode images using CPU (under Settings->Application Options)";
PrintInfo("GPU based cubemap decode is currently not supported in this version. Please view decode images using CPU (under Settings->Application Options)\n");
return NULL;
}
if (MipSetIn->m_format == CMP_FORMAT_ASTC && !(configSetting->useCPU) && decodeWith == CMP_GPUDecode::GPUDecode_DIRECTX) {
configSetting->errMessage = "ASTC format does not supported by DirectX API. Please view ASTC compressed images using other options (CPU) (under Settings->Application Options).";
PrintInfo("Decompress Error: ASTC format does not supported by DirectX API. Please view ASTC compressed images using CPU (under Settings->Application Options).\n");
return NULL;
} else if (MipSetIn->m_format == CMP_FORMAT_ASTC && !(configSetting->useCPU) && decodeWith == CMP_GPUDecode::GPUDecode_OPENGL) {
configSetting->errMessage = "Decode ASTC with OpenGL is not supported. Please view ASTC compressed images using other options (CPU) (under Settings->Application Options).";
PrintInfo("Decompress Error: Decode ASTC with OpenGL is not supported. Please view ASTC compressed images using CPU (under Settings->Application Options).\n");
return NULL;
}
// Compress Options
bool silent = true;
CMP_CompressOptions CompressOptions;
memset(&CompressOptions, 0, sizeof(CMP_CompressOptions));
CompressOptions.dwnumThreads = 0;
CMIPS m_CMIPS;
MipSet *MipSetOut = new MipSet();
memset(MipSetOut, 0, sizeof(MipSet));
MipSetOut->m_TextureDataType = TDT_ARGB;
MipSetOut->m_swizzle = false;
MipSetOut->m_CubeFaceMask = MipSetIn->m_CubeFaceMask;
MipSetOut->m_Flags = MipSetIn->m_Flags;
MipSetOut->m_nDepth = MipSetIn->m_nDepth;
MipSetOut->m_nMaxMipLevels = MipSetIn->m_nMaxMipLevels;
MipSetOut->m_nHeight = MipSetIn->m_nHeight;
MipSetOut->m_nWidth = MipSetIn->m_nWidth;
// BMP is saved as CMP_FORMAT_ARGB_8888
// EXR is saved as CMP_FORMAT_ARGB_16F
switch (MipSetIn->m_format) {
case CMP_FORMAT_BC4_S:
case CMP_FORMAT_BC5_S:
MipSetOut->m_format = CMP_FORMAT_RGBA_8888_S;
break;
case CMP_FORMAT_BC6H:
case CMP_FORMAT_BC6H_SF:
MipSetOut->m_format = CMP_FORMAT_ARGB_16F;
MipSetOut->m_ChannelFormat = CF_Float16;
break;
default:
MipSetOut->m_format = CMP_FORMAT_ARGB_8888;
break;
}
// Allocate output MipSet
if (!m_CMIPS.AllocateMipSet(MipSetOut,
MipSetOut->m_ChannelFormat,
MipSetOut->m_TextureDataType,
MipSetIn->m_TextureType,
MipSetIn->m_nWidth,
MipSetIn->m_nHeight,
MipSetIn->m_nDepth)) { // depthsupport, what should nDepth be set as here?
configSetting->errMessage = "Memory Error(2): allocating MIPSet Output buffer.";
PrintInfo("Memory Error(2): allocating MIPSet Output buffer\n");
m_CMIPS.FreeMipSet(MipSetOut);
delete MipSetOut;
MipSetOut = NULL;
return NULL;
}
MipLevel* pCmpMipLevel = m_CMIPS.GetMipLevel(MipSetIn, 0);
int nMaxFaceOrSlice = CMP_MaxFacesOrSlices(MipSetIn, 0);
int nMaxMipLevels = MipSetIn->m_nMipLevels;
int nWidth = pCmpMipLevel->m_nWidth;
int nHeight = pCmpMipLevel->m_nHeight;
#ifdef USE_BASIS
if (MipSetIn->m_format == CMP_FORMAT_BASIS) {
// These are handled by basis structure: for compressonator use only top most mip levels
nMaxFaceOrSlice = 1;
nMaxMipLevels = 1;
}
#endif
CMP_BYTE* pMipData = m_CMIPS.GetMipLevel(MipSetIn, 0, 0)->m_pbData;
for (int nFaceOrSlice = 0; nFaceOrSlice<nMaxFaceOrSlice; nFaceOrSlice++) {
int nMipWidth = nWidth;
int nMipHeight = nHeight;
for (int nMipLevel = 0; nMipLevel< nMaxMipLevels; nMipLevel++) {
MipLevel* pInMipLevel = m_CMIPS.GetMipLevel(MipSetIn, nMipLevel, nFaceOrSlice);
if (!pInMipLevel) {
configSetting->errMessage = "Memory Error(2): allocating MIPSet Output Cmp level buffer";
PrintInfo("Memory Error(2): allocating MIPSet Output Cmp level buffer\n");
m_CMIPS.FreeMipSet(MipSetOut);
delete MipSetOut;
MipSetOut = NULL;
return NULL;
}
// Valid Mip Level ?
if (pInMipLevel->m_pbData)
pMipData = pInMipLevel->m_pbData;
if (!m_CMIPS.AllocateMipLevelData(m_CMIPS.GetMipLevel(MipSetOut, nMipLevel, nFaceOrSlice), nMipWidth,
nMipHeight, MipSetOut->m_ChannelFormat, MipSetOut->m_TextureDataType)) {
configSetting->errMessage = "Memory Error(2): allocating MIPSet Output level buffer.";
PrintInfo("Memory Error(2): allocating MIPSet Output level buffer\n");
m_CMIPS.FreeMipSet(MipSetOut);
delete MipSetOut;
MipSetOut = NULL;
return NULL;
}
//----------------------------
// Compressed source
//-----------------------------
CMP_Texture srcTexture;
srcTexture.dwSize = sizeof(srcTexture);
srcTexture.dwWidth = nMipWidth;
srcTexture.dwHeight = nMipHeight;
srcTexture.dwPitch = 0;
srcTexture.nBlockWidth = MipSetIn->m_nBlockWidth;
srcTexture.nBlockHeight = MipSetIn->m_nBlockHeight;
srcTexture.nBlockDepth = MipSetIn->m_nBlockDepth;
srcTexture.format = MipSetIn->m_format;
srcTexture.transcodeFormat = MipSetIn->m_transcodeFormat;
srcTexture.dwDataSize = CMP_CalculateBufferSize(&srcTexture);
srcTexture.pData = pMipData;
srcTexture.pMipSet = MipSetIn;
//-----------------------------
// Uncompressed Destination
//-----------------------------
CMP_Texture destTexture;
destTexture.dwSize = sizeof(destTexture);
destTexture.dwWidth = nMipWidth;
destTexture.dwHeight = nMipHeight;
destTexture.dwPitch = 0;
destTexture.nBlockWidth = MipSetOut->m_nBlockWidth;
destTexture.nBlockHeight = MipSetOut->m_nBlockHeight;
destTexture.nBlockDepth = MipSetOut->m_nBlockDepth;
destTexture.format = MipSetOut->m_format;
destTexture.dwDataSize = CMP_CalculateBufferSize(&destTexture);
destTexture.pData = m_CMIPS.GetMipLevel(MipSetOut, nMipLevel, nFaceOrSlice)->m_pbData;
destTexture.pMipSet = MipSetOut;
if (!silent) {
if ((nMipLevel > 1) || (nFaceOrSlice > 1))
PrintInfo("\rProcessing destination MipLevel %2d FaceOrSlice %2d", nMipLevel + 1, nFaceOrSlice);
else
PrintInfo("\rProcessing destination ");
}
try {
#ifdef _WIN32
if ((IsBadReadPtr(srcTexture.pData, srcTexture.dwDataSize))) {
configSetting->errMessage = "Memory Error(2): Source image cannot be accessed.";
PrintInfo("Memory Error(2): Source image\n");
m_CMIPS.FreeMipSet(MipSetOut);
delete MipSetOut;
MipSetOut = NULL;
return NULL;
}
if (/*(srcTexture.dwDataSize > destTexture.dwDataSize) ||*/ (IsBadWritePtr(destTexture.pData, destTexture.dwDataSize))) {
configSetting->errMessage = "Memory Error(2): Destination image must be compatible with source.";
PrintInfo("Memory Error(2): Destination image must be compatible with source\n");
m_CMIPS.FreeMipSet(MipSetOut);
delete MipSetOut;
MipSetOut = NULL;
return NULL;
}
#else
FILE *nullfd = std::fopen("/dev/random", "w");
if (std::fwrite(srcTexture.pData, srcTexture.dwDataSize, 1, nullfd) < 0) {
configSetting->errMessage = "Memory Error(2): Source image cannot be accessed.";
PrintInfo("Memory Error(2): Source image\n");
m_CMIPS.FreeMipSet(MipSetOut);
delete MipSetOut;
MipSetOut = NULL;
return NULL;
}
std::fclose(nullfd);
nullfd = std::fopen("/dev/random", "w");
if (std::fwrite(destTexture.pData, destTexture.dwDataSize, 1, nullfd) < 0) {
configSetting->errMessage = "Memory Error(2): Destination image must be compatible with source.";
PrintInfo("Memory Error(2): Destination image must be compatible with source\n");
m_CMIPS.FreeMipSet(MipSetOut);
delete MipSetOut;
MipSetOut = NULL;
return NULL;
}
std::fclose(nullfd);
#endif
// Return values of the CMP_ calls should be checked for failures
CMP_ERROR res;
if (configSetting->useCPU) {
res = CMP_ConvertTexture(&srcTexture, &destTexture, &CompressOptions, pFeedbackProc);
if (res != CMP_OK) {
configSetting->errMessage = "Compress Failed with Error " + res;
PrintInfo("Compress Failed with Error %d\n", res);
m_CMIPS.FreeMipSet(MipSetOut);
delete MipSetOut;
MipSetOut = NULL;
return NULL;
}
} else {
#ifdef _WIN32
CMP_ERROR res;
CMP_FORMAT hold_destformat = destTexture.format;
res = CMP_DecompressTexture(&srcTexture, &destTexture, decodeWith);
// Did decompress adjust any formats, if so make sure MipSetOut->m_format is updated
// This typically can happen when GPU views are used and the captured framebuffer differs
// from that which was set as a destination texture format. Note all buffer sizes and channel formats
// should match when this happens. Typical case can be moving from SNORM to UNORM bytes
if (hold_destformat != destTexture.format)
MipSetOut->m_format = destTexture.format;
if (res == CMP_ERR_UNSUPPORTED_GPU_ASTC_DECODE) {
configSetting->errMessage = "Error: ASTC compressed texture is not supported by the GPU device.\n";
PrintInfo("Error: ASTC compressed texture is not supported by the GPU device.\n");
m_CMIPS.FreeMipSet(MipSetOut);
delete MipSetOut;
MipSetOut = NULL;
return NULL;
} else if (res == CMP_ERR_UNABLE_TO_INIT_DECOMPRESSLIB) {
configSetting->errMessage = "Error: Failed to load decompress lib for this image or view.\n";
PrintInfo("Error: Failed to decompress with the API selected.\n");
m_CMIPS.FreeMipSet(MipSetOut);
delete MipSetOut;
MipSetOut = NULL;
return NULL;
} else if (res != CMP_OK) {
configSetting->errMessage = "Decompress Failed. Texture format not supported. Please view the compressed images using other options (CPU) (under Settings->Application Options)";
PrintInfo("Decompress Failed with Error %d\n", res);
m_CMIPS.FreeMipSet(MipSetOut);
delete MipSetOut;
MipSetOut = NULL;
return NULL;
}
#else
PrintInfo("GPU Decompress is not supported in linux.\n");
m_CMIPS.FreeMipSet(MipSetOut);
delete MipSetOut;
MipSetOut = NULL;
return NULL;
#endif
}
} catch (std::exception& e) {
PrintInfo(e.what());
m_CMIPS.FreeMipSet(MipSetOut);
delete MipSetOut;
MipSetOut = NULL;
return NULL;
}
pMipData += srcTexture.dwDataSize;
nMipWidth = (nMipWidth>1) ? (nMipWidth >> 1) : 1;
nMipHeight = (nMipHeight>1) ? (nMipHeight >> 1) : 1;
}
}
MipSetOut->m_nMipLevels = MipSetIn->m_nMipLevels;
return MipSetOut;
}
void swap_Bytes(CMP_BYTE *src, int width, int height, int offset) {
int i, j;
CMP_BYTE b;
for (i = 0; i<height; i++) {
for (j = 0; j<width; j++) {
b = *src; // hold 1st byte
*src = *(src + 2); // move 1st to offsetrd
*(src + 2) = b; // save offset to 1st
src = src + offset; // move to next set of bytes
}
}
}
void SwizzleMipMap(MipSet *pMipSet) {
CMP_DWORD dwWidth;
CMP_DWORD dwHeight;
CMP_BYTE *pData;
for (int nMipLevel = 0; nMipLevel<pMipSet->m_nMipLevels; nMipLevel++) {
for (int nFaceOrSlice = 0; nFaceOrSlice< CMP_MaxFacesOrSlices(pMipSet, nMipLevel); nFaceOrSlice++) {
//=====================
// Uncompressed source
//======================
MipLevel* pInMipLevel = g_CMIPS->GetMipLevel(pMipSet, nMipLevel, nFaceOrSlice);
dwWidth = pInMipLevel->m_nWidth;
dwHeight = pInMipLevel->m_nHeight;
pData = pInMipLevel->m_pbData;
// Swizzle to RGBA format when compressing from uncompressed DDS file! This is a Patch for now.
// may want to try this patch on other file types BMP & PNG to move swizzle out to main code.
switch (pMipSet->m_TextureDataType) {
case TDT_ARGB:
swap_Bytes(pInMipLevel->m_pbData, dwWidth, dwHeight, 4);
break;
case TDT_XRGB:
swap_Bytes(pInMipLevel->m_pbData, dwWidth, dwHeight, 3);
break;
default:
break;
}
}
}
}
// Determine if RGB channel to BGA can be done or skipped
// for special cases of compressed formats.
bool KeepSwizzle(CMP_FORMAT destformat) {
// determin of the swizzle flag needs to be turned on!
switch (destformat) {
case CMP_FORMAT_BC4:
case CMP_FORMAT_BC4_S:
case CMP_FORMAT_ATI1N: // same as BC4
case CMP_FORMAT_BC5:
case CMP_FORMAT_BC5_S:
case CMP_FORMAT_ATI2N: // same as BC5 channels swizzled to : Green & Red
case CMP_FORMAT_ATI2N_XY: // BC5 Red & Green Channel
case CMP_FORMAT_ATI2N_DXT5: //
case CMP_FORMAT_BC1:
case CMP_FORMAT_DXT1: // same as BC1
case CMP_FORMAT_BC2:
case CMP_FORMAT_DXT3: // same as BC2
case CMP_FORMAT_BC3:
case CMP_FORMAT_DXT5: // same as BC3
case CMP_FORMAT_ATC_RGB:
case CMP_FORMAT_ATC_RGBA_Explicit:
case CMP_FORMAT_ATC_RGBA_Interpolated:
return true;
break;
default:
break;
}
return false;
}
int AMDLoadMIPSTextureImage(const char *SourceFile, MipSet *MipSetIn, bool use_OCV, void *pluginManager) {
if (pluginManager == NULL)
return -1;
PluginInterface_Image *plugin_Image;
PluginManager *plugin_Manager = (PluginManager *)pluginManager;
if (use_OCV) {
plugin_Image = reinterpret_cast<PluginInterface_Image *>(plugin_Manager->GetPlugin("IMAGE", "OCV"));
} else {
std::string file_extension = CMP_GetFileExtension(SourceFile, false, true);
plugin_Image = reinterpret_cast<PluginInterface_Image*>(plugin_Manager->GetPlugin("IMAGE", (char*)file_extension.c_str()));
}
// do the load
if (plugin_Image) {
plugin_Image->TC_PluginSetSharedIO(&g_CMIPS);
if (plugin_Image->TC_PluginFileLoadTexture(SourceFile, MipSetIn) != 0) {
// Process Error
delete plugin_Image;
plugin_Image = NULL;
return -1;
}
delete plugin_Image;
plugin_Image = NULL;
} else {
#if (OPTION_CMP_QT == 1)
// Failed to load using a AMD Plugin
// Try Qt based
int result = -1;
QString filename(SourceFile);
QImage *qimage = new QImage(filename);
if (qimage) {
result = QImage2MIPS(qimage, g_CMIPS, MipSetIn);
delete qimage;
qimage = NULL;
}
return result;
#else
return -1;
#endif
}
return 0;
}
int AMDSaveMIPSTextureImage(const char *DestFile, MipSet *MipSetIn, bool use_OCV, CMP_CompressOptions option) {
bool filesaved = false;
CMIPS m_CMIPS;
std::string file_extension = CMP_GetJustFileExt(DestFile);
file_extension.erase(std::remove(file_extension.begin(), file_extension.end(), '.'), file_extension.end());
for(char& c : file_extension)
c = toupper(c);
PluginInterface_Image *plugin_Image;
if (use_OCV) {
plugin_Image = reinterpret_cast<PluginInterface_Image *>(g_pluginManager.GetPlugin("IMAGE", "OCV"));
} else {
plugin_Image = reinterpret_cast<PluginInterface_Image *>(g_pluginManager.GetPlugin("IMAGE", (char *)file_extension.c_str()));
}
if (plugin_Image) {
plugin_Image->TC_PluginSetSharedIO(&m_CMIPS);
bool holdswizzle = MipSetIn->m_swizzle;
if (file_extension.compare("TGA") == 0) {
// Special case Patch for TGA plugin
// to be fixed in V2.5 release
MipSetIn->m_swizzle = false;
switch (MipSetIn->m_isDeCompressed) {
case CMP_FORMAT_ASTC:
case CMP_FORMAT_BC7:
case CMP_FORMAT_BC6H:
case CMP_FORMAT_BC6H_SF:
case CMP_FORMAT_ETC_RGB:
case CMP_FORMAT_ETC2_RGB:
MipSetIn->m_swizzle = true;
break;
}
if ((MipSetIn->m_ChannelFormat == CF_Float32) || (MipSetIn->m_ChannelFormat == CF_Float16)) {
PrintInfo("\nError: TGA plugin does not support floating point data saving. Please use other file extension (i.e. dds).\n");
}
}
if (plugin_Image->TC_PluginFileSaveTexture(DestFile, MipSetIn) == 0) {
filesaved = true;
}
MipSetIn->m_swizzle = holdswizzle;
delete plugin_Image;
plugin_Image = NULL;
}
#if (OPTION_CMP_QT == 1)
if (!filesaved)
{
// Try Qt based filesave!
QImage *qimage = MIPS2QImage(&m_CMIPS, MipSetIn, 0, 0, option, nullptr);
if (qimage) {
if (!qimage->save(DestFile)) {
delete qimage;
qimage = NULL;
return(-1);
}
delete qimage;
qimage = NULL;
filesaved = true;
} else
return -1;
}
#endif
if (!filesaved) {
return -1;
}
return 0;
}
bool FormatSupportsQualitySetting(CMP_FORMAT format) {
return CMP_IsCompressedFormat(format);
}
bool FormatSupportsDXTCBase(CMP_FORMAT format) {
switch (format) {
case CMP_FORMAT_ATI1N :
case CMP_FORMAT_ATI2N :
case CMP_FORMAT_ATI2N_XY :
case CMP_FORMAT_ATI2N_DXT5 :
case CMP_FORMAT_BC1 :
case CMP_FORMAT_BC2 :
case CMP_FORMAT_BC3 :
case CMP_FORMAT_BC4 :
case CMP_FORMAT_BC5 :
case CMP_FORMAT_DXT1 :
case CMP_FORMAT_DXT3 :
case CMP_FORMAT_DXT5 :
case CMP_FORMAT_DXT5_xGBR :
case CMP_FORMAT_DXT5_RxBG :
case CMP_FORMAT_DXT5_RBxG :
case CMP_FORMAT_DXT5_xRBG :
case CMP_FORMAT_DXT5_RGxB :
case CMP_FORMAT_DXT5_xGxR :
return (true);
break;
default:
break;
}
return false;
}
Reference in New Issue View Git Blame Copy Permalink