hyzboy/TexConv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
TexConv/CMP_Framework/Compute_Base.cpp

1106 lines
37 KiB
C++
Raw Blame History

//=====================================================================
// Copyright (c) 2020 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 Compute_Base.cpp
//
//=====================================================================
#include <cstdlib>
#include "compute_base.h"
#include "plugininterface.h"
#include "texture.h"
#include "cmp_core.h"
#include "bcn_common_kernel.h"
#ifndef _WIN32
#include <unistd.h> /* For open(), creat() */
#endif
#ifndef STB_IMAGE_IMPLEMENTATION
#define STB_IMAGE_IMPLEMENTATION
#endif
#include "stb_image.h"
#ifndef STB_IMAGE_WRITE_IMPLEMENTATION
#define STB_IMAGE_WRITE_IMPLEMENTATION
#endif
#include "gltf/stb_image_write.h"
#include <string>
#include <mutex>
CMP_CHAR* GetFormatDesc(CMP_FORMAT nFormat);
PluginManager g_pluginManager;
PluginInterface_Encoder* plugin_encoder_codec = NULL;
static CMP_BOOL HostPluginsRegistered = FALSE;
static CMP_FORMAT cmp_format_hold = CMP_FORMAT_Unknown;
PluginInterface_Pipeline* g_ComputeBase = NULL;
static CMP_Compute_type ComputeType = CMP_CPU;
static int exitreg = false;
static int startupreg = false;
extern void* make_Plugin_DDS();
extern void* make_Plugin_HPC();
// CMP_Core Compression Codecs
extern void* make_Plugin_BC1();
extern void* make_Plugin_BC2();
extern void* make_Plugin_BC3();
extern void* make_Plugin_BC4();
extern void* make_Plugin_BC4_S();
extern void* make_Plugin_BC5();
extern void* make_Plugin_BC5_S();
extern void* make_Plugin_BC6H();
extern void* make_Plugin_BC6H_SF();
extern void* make_Plugin_BC7();
#ifdef USE_GTC
extern void* make_Plugin_GTC();
#endif
#ifdef USE_APC
extern void* make_Plugin_APC();
#endif
void CMP_RegisterHostPlugins() {
if (HostPluginsRegistered == FALSE) {
// Hosts
g_pluginManager.registerStaticPlugin("IMAGE", "DDS", (void*)make_Plugin_DDS);
g_pluginManager.registerStaticPlugin("PIPELINE","HPC", (void*)make_Plugin_HPC);
// Encoders
g_pluginManager.registerStaticPlugin("ENCODER", "BC1", (void*)make_Plugin_BC1);
g_pluginManager.registerStaticPlugin("ENCODER", "BC2", (void*)make_Plugin_BC2);
g_pluginManager.registerStaticPlugin("ENCODER", "BC3", (void*)make_Plugin_BC3);
g_pluginManager.registerStaticPlugin("ENCODER", "BC4", (void*)make_Plugin_BC4);
g_pluginManager.registerStaticPlugin("ENCODER", "BC4_S", (void*)make_Plugin_BC4_S);
g_pluginManager.registerStaticPlugin("ENCODER", "BC5", (void*)make_Plugin_BC5);
g_pluginManager.registerStaticPlugin("ENCODER", "BC5_S", (void*)make_Plugin_BC5_S);
g_pluginManager.registerStaticPlugin("ENCODER", "BC6H", (void*)make_Plugin_BC6H);
g_pluginManager.registerStaticPlugin("ENCODER", "BC6H_SF", (void*)make_Plugin_BC6H_SF);
g_pluginManager.registerStaticPlugin("ENCODER", "BC7", (void*)make_Plugin_BC7);
#ifdef USE_GTC
g_pluginManager.registerStaticPlugin("ENCODER", "GTC", (void*)make_Plugin_GTC);
#endif
#ifdef USE_APC
g_pluginManager.registerStaticPlugin("ENCODER", "APC", (void*)make_Plugin_APC);
#endif
g_pluginManager.getPluginList(".", TRUE);
HostPluginsRegistered = TRUE;
}
}
//
// Closes the Compute library allocation
//
CMP_ERROR CMP_API CMP_DestroyComputeLibrary(bool forceclose = false) {
if (g_ComputeBase && forceclose) {
if (plugin_encoder_codec) {
delete plugin_encoder_codec;
plugin_encoder_codec = NULL;
}
g_ComputeBase->TC_Close();
//free(g_ComputeBase);
delete g_ComputeBase;
g_ComputeBase = NULL;
}
return CMP_OK;
}
const CMP_CHAR* GetEncodeWithDesc(CMP_Compute_type nFormat) {
switch (nFormat) {
case CMP_HPC: // Use CPU High Performance Compute to compress textures, full support
return "HPC";
break;
case CMP_GPU_OCL:
return "OCL";
break;
case CMP_GPU_HW:
return "GPU";
break;
case CMP_GPU_VLK:
return "VLK";
break;
case CMP_GPU_DXC:
return "DXC";
break;
}
return "CPU";
}
#ifdef _WIN32
bool cmp_recompile_shader(std::string m_sourceShaderFile) {
bool rebuild = false;
FILE* p_file_bin = NULL;
errno_t fopen_result;
// Check build configuration of the shader, has it been modified since last use
fopen_result = fopen_s(&p_file_bin, m_sourceShaderFile.c_str(), "r+");
if (fopen_result == 0) {
time_t attr;
fseek(p_file_bin, 3, SEEK_CUR);
fscanf_s(p_file_bin, "%llx", &attr);
struct stat attrib;
stat(m_sourceShaderFile.c_str(), &attrib);
if (attr != attrib.st_ctime) {
char buff[128];
sprintf_s(buff, " %llx ", attrib.st_ctime);
// snprintf(buff, 128, " %llx ", attrib.st_ctime);
fseek(p_file_bin, 2, SEEK_SET);
fwrite(buff, 1, 9, p_file_bin);
rebuild = true;
}
fseek(p_file_bin, 0, SEEK_SET);
fclose(p_file_bin);
}
return rebuild;
}
#endif
//-------------------------
// Application is "Exiting"
//-------------------------
void exiting() {
exitreg = false;
CMP_DestroyComputeLibrary(true);
}
#ifdef _WIN32
bool isDX12Supported() {
typedef LONG NTSTATUS, *PNTSTATUS;
typedef NTSTATUS(WINAPI * RtlGetVersionPtr)(PRTL_OSVERSIONINFOW);
RTL_OSVERSIONINFOW win10OSver = {0};
HMODULE hMod = ::GetModuleHandleW(L"ntdll.dll");
if (hMod) {
RtlGetVersionPtr fxPtr = (RtlGetVersionPtr)::GetProcAddress(hMod, "RtlGetVersion");
if (fxPtr != nullptr) {
RTL_OSVERSIONINFOW rovi = {0};
rovi.dwOSVersionInfoSize = sizeof(rovi);
if (0 == fxPtr(&rovi)) {
win10OSver = rovi;
}
}
}
if (win10OSver.dwMajorVersion < 10) {
return false;
}
if ((win10OSver.dwBuildNumber != 0) && (win10OSver.dwBuildNumber < 15063)) {
return false;
}
return true;
}
#else
bool isDX12Supported()
{
return false;
}
#endif
//
// Initialize the Compute library based on support types
//
CMP_ERROR CMP_API CMP_CreateComputeLibrary(MipSet* srcTexture, KernelOptions* kernel_options, void* CMips) {
CMP_Compute_type CompType = kernel_options->encodeWith;
CMP_FORMAT cmp_format = kernel_options->format;
if ((CompType != ComputeType) || cmp_format != cmp_format_hold) {
CMP_DestroyComputeLibrary(true);
}
if (plugin_encoder_codec == NULL) {
plugin_encoder_codec = reinterpret_cast<PluginInterface_Encoder*>(g_pluginManager.GetPlugin("ENCODER", GetFormatDesc(cmp_format)));
if (plugin_encoder_codec == NULL) {
PrintInfo("Format [%s] for [%s] is not supported or failed to load\n", GetFormatDesc(cmp_format), GetEncodeWithDesc(CompType));
return CMP_ERR_UNABLE_TO_INIT_COMPUTELIB;
}
cmp_format_hold = cmp_format;
}
if (kernel_options->srcfile == NULL) {
kernel_options->srcfile = plugin_encoder_codec->TC_ComputeSourceFile(kernel_options->encodeWith);
if (kernel_options->srcfile == NULL) {
PrintInfo("Failed to load the encoders shader code\n");
return CMP_ERR_NOSHADER_CODE_DEFINED;
}
}
// Initialize the compression codec, pass kernel options
kernel_options->height = srcTexture->dwHeight;
kernel_options->width = srcTexture->dwWidth;
kernel_options->srcformat = srcTexture->m_format;
if (plugin_encoder_codec->TC_Init(kernel_options) != 0) {
PrintInfo("Failed to init encoder\n");
return CMP_ERR_UNABLE_TO_INIT_COMPUTELIB;
}
if (plugin_encoder_codec->TC_PluginSetSharedIO(CMips) != 0) {
PrintInfo("Warning unable to set print IO\n");
}
// Are we re-running the same codec type
if (g_ComputeBase && (ComputeType == CompType)) {
return CMP_OK;
}
switch (CompType) {
default:
case CMP_HPC:
g_ComputeBase = reinterpret_cast<PluginInterface_Pipeline*>(g_pluginManager.GetPlugin("PIPELINE", "HPC"));
break;
case CMP_GPU_OCL:
g_ComputeBase = reinterpret_cast<PluginInterface_Pipeline*>(g_pluginManager.GetPlugin("PIPELINE", "GPU_OCL"));
break;
case CMP_GPU_HW:
g_ComputeBase = reinterpret_cast<PluginInterface_Pipeline*>(g_pluginManager.GetPlugin("PIPELINE", "GPU_HW"));
break;
case CMP_GPU_DXC:
if (isDX12Supported()) {
g_ComputeBase = reinterpret_cast<PluginInterface_Pipeline*>(g_pluginManager.GetPlugin("PIPELINE", "GPU_DXC"));
} else {
PrintInfo("Format [%s] for [%s] is supported for DX12 only\n", GetFormatDesc(cmp_format), GetEncodeWithDesc(CompType));
return CMP_ERR_UNABLE_TO_INIT_COMPUTELIB;
}
break;
case CMP_GPU_VLK:
g_ComputeBase = reinterpret_cast<PluginInterface_Pipeline*>(g_pluginManager.GetPlugin("PIPELINE", "GPU_VLK"));
break;
}
if (g_ComputeBase) {
// some code here if needed
if (g_ComputeBase->TC_Init(kernel_options) != 0)
return CMP_ERR_UNABLE_TO_INIT_COMPUTELIB;
ComputeType = CompType;
// Init IO
if (g_ComputeBase->TC_PluginSetSharedIO(CMips) != 0)
return CMP_ERR_UNABLE_TO_INIT_COMPUTELIB;
} else
return CMP_ERR_UNABLE_TO_INIT_COMPUTELIB;
if (!exitreg) {
exitreg = true;
std::atexit(exiting);
}
if (!startupreg) {
startupreg = true;
// reserved for any one time startup code need
}
return CMP_OK;
}
CMP_ERROR CMP_API CMP_GetPerformanceStats(KernelPerformanceStats* pPerfStats) {
CMP_ERROR result;
if (g_ComputeBase) {
result = g_ComputeBase->TC_GetPerformanceStats(pPerfStats);
if (result != CMP_OK)
return (result);
} else
return CMP_ABORTED;
return CMP_OK;
}
CMP_ERROR CMP_API CMP_GetDeviceInfo(KernelDeviceInfo* pDeviceInfo) {
CMP_ERROR result;
if (g_ComputeBase) {
result = g_ComputeBase->TC_GetDeviceInfo(pDeviceInfo);
if (result != CMP_OK)
return (result);
} else
return CMP_ABORTED;
return CMP_OK;
}
CMP_ERROR CMP_API CMP_CompressTexture(KernelOptions* options, CMP_MipSet srcMipSet, CMP_MipSet dstMipSet, CMP_Feedback_Proc pFeedback) {
CMP_ERROR result;
if (g_ComputeBase) {
result = g_ComputeBase->TC_Compress(options, srcMipSet, dstMipSet, pFeedback);
if (result != CMP_OK)
return (result);
} else
return CMP_ABORTED;
return CMP_OK;
}
CMP_ERROR CMP_API CMP_SetComputeOptions(ComputeOptions* options) {
options->plugin_compute = plugin_encoder_codec;
if (g_ComputeBase) {
g_ComputeBase->TC_SetComputeOptions(options);
} else
return CMP_ERR_UNABLE_TO_INIT_COMPUTELIB;
return CMP_OK;
}
//==================== Compressonator =================================
CodecType GetCodecType2(CMP_FORMAT format) {
switch (format) {
case CMP_FORMAT_ARGB_2101010:
return CT_None;
case CMP_FORMAT_RGBA_8888:
return CT_None;
case CMP_FORMAT_BGRA_8888:
return CT_None;
case CMP_FORMAT_ARGB_8888:
return CT_None;
case CMP_FORMAT_RGBA_8888_S:
return CT_None;
case CMP_FORMAT_BGR_888:
return CT_None;
case CMP_FORMAT_RGB_888:
return CT_None;
case CMP_FORMAT_RG_8:
return CT_None;
case CMP_FORMAT_R_8:
return CT_None;
case CMP_FORMAT_ARGB_16:
return CT_None;
case CMP_FORMAT_RG_16:
return CT_None;
case CMP_FORMAT_R_16:
return CT_None;
case CMP_FORMAT_ARGB_16F:
return CT_None;
case CMP_FORMAT_RG_16F:
return CT_None;
case CMP_FORMAT_R_16F:
return CT_None;
case CMP_FORMAT_ARGB_32F:
return CT_None;
case CMP_FORMAT_RG_32F:
return CT_None;
case CMP_FORMAT_R_32F:
return CT_None;
case CMP_FORMAT_RGBE_32F:
return CT_None;
#ifdef ARGB_32_SUPPORT
case CMP_FORMAT_ARGB_32:
return CT_None;
case CMP_FORMAT_RG_32:
return CT_None;
case CMP_FORMAT_R_32:
return CT_None;
#endif // ARGB_32_SUPPORT
case CMP_FORMAT_DXT1:
return CT_DXT1;
case CMP_FORMAT_DXT3:
return CT_DXT3;
case CMP_FORMAT_DXT5:
return CT_DXT5;
case CMP_FORMAT_DXT5_xGBR:
return CT_DXT5_xGBR;
case CMP_FORMAT_DXT5_RxBG:
return CT_DXT5_RxBG;
case CMP_FORMAT_DXT5_RBxG:
return CT_DXT5_RBxG;
case CMP_FORMAT_DXT5_xRBG:
return CT_DXT5_xRBG;
case CMP_FORMAT_DXT5_RGxB:
return CT_DXT5_RGxB;
case CMP_FORMAT_DXT5_xGxR:
return CT_DXT5_xGxR;
case CMP_FORMAT_ATI1N:
return CT_ATI1N;
case CMP_FORMAT_ATI2N:
return CT_ATI2N;
case CMP_FORMAT_ATI2N_XY:
return CT_ATI2N_XY;
case CMP_FORMAT_ATI2N_DXT5:
return CT_ATI2N_DXT5;
case CMP_FORMAT_BC1:
return CT_DXT1;
case CMP_FORMAT_BC2:
return CT_DXT3;
case CMP_FORMAT_BC3:
return CT_DXT5;
case CMP_FORMAT_BC4:
return CT_ATI1N;
case CMP_FORMAT_BC4_S:
return CT_ATI1N_S;
case CMP_FORMAT_BC5:
return CT_ATI2N_XY;
case CMP_FORMAT_BC5_S:
return CT_ATI2N_XY_S;
case CMP_FORMAT_BC6H:
return CT_BC6H;
case CMP_FORMAT_BC6H_SF:
return CT_BC6H_SF;
case CMP_FORMAT_BC7:
return CT_BC7;
case CMP_FORMAT_ASTC:
return CT_ASTC;
case CMP_FORMAT_ATC_RGB:
return CT_ATC_RGB;
case CMP_FORMAT_ATC_RGBA_Explicit:
return CT_ATC_RGBA_Explicit;
case CMP_FORMAT_ATC_RGBA_Interpolated:
return CT_ATC_RGBA_Interpolated;
case CMP_FORMAT_ETC_RGB:
return CT_ETC_RGB;
case CMP_FORMAT_ETC2_RGB:
return CT_ETC2_RGB;
case CMP_FORMAT_ETC2_SRGB:
return CT_ETC2_SRGB;
case CMP_FORMAT_ETC2_RGBA:
return CT_ETC2_RGBA;
case CMP_FORMAT_ETC2_RGBA1:
return CT_ETC2_RGBA1;
case CMP_FORMAT_ETC2_SRGBA:
return CT_ETC2_SRGBA;
case CMP_FORMAT_ETC2_SRGBA1:
return CT_ETC2_SRGBA1;
#ifdef USE_GTC
case CMP_FORMAT_GTC:
return CT_GTC;
#endif
#ifdef USE_APC
case CMP_FORMAT_APC:
return CT_APC;
#endif
#ifdef USE_BASIS
case CMP_FORMAT_BASIS:
return CT_BASIS;
#endif
default:
return CT_Unknown;
}
}
CMP_DWORD CalcBufferSizeCT(CodecType nCodecType, CMP_DWORD dwWidth, CMP_DWORD dwHeight, CMP_BYTE nBlockWidth, CMP_BYTE nBlockHeight) {
#ifdef USE_DBGTRACE
DbgTrace(("IN: nCodecType %d, dwWidth %d, dwHeight %d", nCodecType, dwWidth, dwHeight));
#endif
CMP_DWORD dwChannels;
CMP_DWORD dwBitsPerChannel;
CMP_DWORD buffsize = 0;
switch (nCodecType) {
// Block size is 4x4 and 64 bits per block
case CT_DXT1:
case CT_ATI1N:
case CT_ATI1N_S:
case CT_ATC_RGB:
case CT_ETC_RGB:
case CT_ETC2_RGB:
case CT_ETC2_SRGB:
case CT_ETC2_RGBA1:
case CT_ETC2_SRGBA1:
dwChannels = 1;
dwBitsPerChannel = 4;
dwWidth = ((dwWidth + 3) / 4) * 4;
dwHeight = ((dwHeight + 3) / 4) * 4;
buffsize = (dwWidth * dwHeight * dwChannels * dwBitsPerChannel) / 8;
break;
// Block size is 4x4 and 128 bits per block
case CT_ETC2_RGBA:
case CT_ETC2_SRGBA:
// dwChannels = 2;
// dwBitsPerChannel = 4;
// dwWidth = ((dwWidth + 3) / 4) * 4;
// dwHeight = ((dwHeight + 3) / 4) * 4;
// buffsize = (dwWidth * dwHeight * dwChannels * dwBitsPerChannel) / 8;
dwWidth = ((dwWidth + 3) / 4) * 4;
dwHeight = ((dwHeight + 3) / 4) * 4;
buffsize = dwWidth * dwHeight;
if (buffsize < 16)
buffsize = 16;
break;
// Block size is 4x4 and 128 bits per block
case CT_DXT3:
case CT_DXT5:
case CT_DXT5_xGBR:
case CT_DXT5_RxBG:
case CT_DXT5_RBxG:
case CT_DXT5_xRBG:
case CT_DXT5_RGxB:
case CT_DXT5_xGxR:
case CT_ATI2N:
case CT_ATI2N_XY:
case CT_ATI2N_XY_S:
case CT_ATI2N_DXT5:
case CT_ATC_RGBA_Explicit:
case CT_ATC_RGBA_Interpolated:
dwChannels = 2;
dwBitsPerChannel = 4;
dwWidth = ((dwWidth + 3) / 4) * 4;
dwHeight = ((dwHeight + 3) / 4) * 4;
buffsize = (dwWidth * dwHeight * dwChannels * dwBitsPerChannel) / 8;
break;
// Block size is 4x4 and 128 bits per block
case CT_BC6H:
case CT_BC6H_SF:
dwWidth = ((dwWidth + 3) / 4) * 4;
dwHeight = ((dwHeight + 3) / 4) * 4;
buffsize = dwWidth * dwHeight;
if (buffsize < 16)
buffsize = 16;
break;
// Block size is 4x4 and 128 bits per block
case CT_BC7:
dwWidth = ((dwWidth + 3) / 4) * 4;
dwHeight = ((dwHeight + 3) / 4) * 4;
buffsize = dwWidth * dwHeight;
if (buffsize < 16)
buffsize = 16;
break;
// Block size ranges from 4x4 to 12x12 and 128 bits per block
case CT_ASTC:
dwWidth = ((dwWidth + nBlockWidth - 1) / nBlockWidth) * 4;
dwHeight = ((dwHeight + nBlockHeight - 1) / nBlockHeight) * 4;
buffsize = dwWidth * dwHeight;
break;
#ifdef _WIN32
// Block size is 4x4 and 128 bits per block. in future releases its will vary in Block Sizes and bits per block may change to 256
#ifdef USE_GTC
case CT_GTC:
dwWidth = ((dwWidth + 3) / 4) * 4;
dwHeight = ((dwHeight + 3) / 4) * 4;
buffsize = dwWidth * dwHeight;
if (buffsize < (4 * 4))
buffsize = 4 * 4;
break;
#endif
#ifdef USE_APC
case CT_APC:
dwWidth = ((dwWidth + nBlockWidth - 1) / nBlockWidth) * 4;
dwHeight = ((dwHeight + nBlockHeight - 1) / nBlockHeight) * 4;
buffsize = dwWidth * dwHeight;
break;
#endif
#ifdef USE_BASIS
// Block size is 4x4 and 128 bits per block, needs conformation!!
case CT_BASIS:
dwWidth = ((dwWidth + 3) / 4) * 4;
dwHeight = ((dwHeight + 3) / 4) * 4;
buffsize = dwWidth * dwHeight;
if (buffsize < (4 * 4))
buffsize = 4 * 4;
break;
#endif
#endif
default:
return 0;
}
#ifdef USE_DBGTRACE
DbgTrace(("OUT: %d", buffsize));
#endif
return buffsize;
}
CMP_DWORD CalcBufferSize2(CMP_FORMAT format, CMP_DWORD dwWidth, CMP_DWORD dwHeight, CMP_DWORD dwPitch, CMP_BYTE nBlockWidth, CMP_BYTE nBlockHeight) {
#ifdef USE_DBGTRACE
DbgTrace(("format %d dwWidth %d dwHeight %d dwPitch %d", format, dwWidth, dwHeight, dwPitch));
#endif
switch (format) {
case CMP_FORMAT_RGBA_8888:
case CMP_FORMAT_BGRA_8888:
case CMP_FORMAT_ARGB_8888:
case CMP_FORMAT_RGBA_8888_S:
case CMP_FORMAT_ARGB_2101010:
return ((dwPitch) ? (dwPitch * dwHeight) : (dwWidth * 4 * dwHeight));
case CMP_FORMAT_BGR_888:
case CMP_FORMAT_RGB_888:
return ((dwPitch) ? (dwPitch * dwHeight) : ((((dwWidth * 3) + 3) >> 2) * 4 * dwHeight));
case CMP_FORMAT_RG_8:
return ((dwPitch) ? (dwPitch * dwHeight) : (dwWidth * 2 * dwHeight));
case CMP_FORMAT_R_8:
return ((dwPitch) ? (dwPitch * dwHeight) : (dwWidth * dwHeight));
case CMP_FORMAT_ARGB_16:
case CMP_FORMAT_ARGB_16F:
return ((dwPitch) ? (dwPitch * dwHeight) : (dwWidth * 4 * sizeof(CMP_WORD) * dwHeight));
case CMP_FORMAT_RG_16:
case CMP_FORMAT_RG_16F:
return ((dwPitch) ? (dwPitch * dwHeight) : (dwWidth * 4 * sizeof(CMP_WORD) * dwHeight));
case CMP_FORMAT_R_16:
case CMP_FORMAT_R_16F:
return ((dwPitch) ? (dwPitch * dwHeight) : (dwWidth * 4 * sizeof(CMP_WORD) * dwHeight));
#ifdef ARGB_32_SUPPORT
case CMP_FORMAT_ARGB_32:
#endif // ARGB_32_SUPPORT
case CMP_FORMAT_ARGB_32F:
return ((dwPitch) ? (dwPitch * dwHeight) : (dwWidth * 4 * sizeof(float) * dwHeight));
#ifdef ARGB_32_SUPPORT
case CMP_FORMAT_RG_32:
#endif // ARGB_32_SUPPORT
case CMP_FORMAT_RG_32F:
return ((dwPitch) ? (dwPitch * dwHeight) : (dwWidth * 2 * sizeof(float) * dwHeight));
#ifdef ARGB_32_SUPPORT
case CMP_FORMAT_R_32:
#endif // ARGB_32_SUPPORT
case CMP_FORMAT_R_32F:
return ((dwPitch) ? (dwPitch * dwHeight) : (dwWidth * 1 * sizeof(float) * dwHeight));
default:
return CalcBufferSizeCT(GetCodecType2(format), dwWidth, dwHeight, nBlockWidth, nBlockHeight);
}
}
CMP_DWORD CMP_API CMP_CalculateBufferSize2(const CMP_Texture* pTexture) {
#ifdef USE_DBGTRACE
DbgTrace(("-------> pTexture [%x]", pTexture));
#endif
assert(pTexture);
if (pTexture == NULL)
return 0;
assert(pTexture->dwSize == sizeof(CMP_Texture));
if (pTexture->dwSize != sizeof(CMP_Texture))
return 0;
assert(pTexture->dwWidth > 0);
if (pTexture->dwWidth <= 0)
return 0;
assert(pTexture->dwHeight > 0);
if (pTexture->dwHeight <= 0)
return 0;
assert(pTexture->format >= CMP_FORMAT_RGBA_8888_S && pTexture->format <= CMP_FORMAT_MAX);
if (pTexture->format < CMP_FORMAT_RGBA_8888_S || pTexture->format > CMP_FORMAT_MAX)
return 0;
return CalcBufferSize2(pTexture->format, pTexture->dwWidth, pTexture->dwHeight, pTexture->dwPitch, pTexture->nBlockWidth, pTexture->nBlockHeight);
}
//===========================================================================================================
// This is a high level API that locks calling thread with mutex, blocking if necessary until completed
//===========================================================================================================
std::mutex cmp_mutex;
CMP_ERROR CMP_API CMP_ProcessTexture(CMP_MipSet* srcMipSet, CMP_MipSet* dstMipSet, KernelOptions kernelOptions, CMP_Feedback_Proc pFeedbackProc)
{
cmp_mutex.lock();
CMP_CMIPS CMips;
assert(srcMipSet);
assert(dstMipSet);
// -------------
// Output
// -------------
dstMipSet->m_Flags = MS_FLAG_Default;
dstMipSet->m_format = kernelOptions.format;
dstMipSet->m_nHeight = srcMipSet->m_nHeight;
dstMipSet->m_nWidth = srcMipSet->m_nWidth;
CMP_Format2FourCC(dstMipSet->m_format, dstMipSet);
//=====================================================
// Case Uncompressed Source to Compressed Destination
//=====================================================
// Allocate compression data
dstMipSet->m_ChannelFormat = CF_Compressed;
dstMipSet->m_nMaxMipLevels = srcMipSet->m_nMaxMipLevels;
dstMipSet->m_nMipLevels = 1; // this is overwriiten depending on input.
dstMipSet->m_nBlockWidth = 4; // Update is required for other sizes.
dstMipSet->m_nBlockHeight = 4; // - need to fix p_MipSetIn m_nBlock settings for this to work
dstMipSet->m_nBlockDepth = 1;
dstMipSet->m_nDepth = srcMipSet->m_nDepth;
dstMipSet->m_TextureType = srcMipSet->m_TextureType;
if (!CMips.AllocateMipSet(dstMipSet, dstMipSet->m_ChannelFormat, TDT_ARGB, dstMipSet->m_TextureType, srcMipSet->m_nWidth, srcMipSet->m_nHeight, dstMipSet->m_nDepth)) {
cmp_mutex.unlock();
return CMP_ERR_MEM_ALLOC_FOR_MIPSET;
}
CMP_Texture srcTexture;
srcTexture.dwSize = sizeof(srcTexture);
int DestMipLevel = srcMipSet->m_nMipLevels;
dstMipSet->m_nMipLevels = DestMipLevel;
for (int nMipLevel = 0; nMipLevel < DestMipLevel; nMipLevel++) {
for (int nFaceOrSlice = 0; nFaceOrSlice < CMP_MaxFacesOrSlices(srcMipSet, nMipLevel); nFaceOrSlice++) {
//=====================
// Uncompressed source
//======================
MipLevel* pInMipLevel = CMips.GetMipLevel(srcMipSet, nMipLevel, nFaceOrSlice);
srcTexture.dwPitch = 0;
srcTexture.nBlockWidth = srcMipSet->m_nBlockWidth;
srcTexture.nBlockHeight = srcMipSet->m_nBlockHeight;
srcTexture.nBlockDepth = srcMipSet->m_nBlockDepth;
srcTexture.format = srcMipSet->m_format;
srcTexture.dwWidth = pInMipLevel->m_nWidth;
srcTexture.dwHeight = pInMipLevel->m_nHeight;
srcTexture.pData = pInMipLevel->m_pbData;
srcTexture.dwDataSize = CMP_CalculateBufferSize2(&srcTexture);
// Temporary setting!
srcMipSet->dwWidth = pInMipLevel->m_nWidth;
srcMipSet->dwHeight = pInMipLevel->m_nHeight;
srcMipSet->pData = pInMipLevel->m_pbData;
srcMipSet->dwDataSize = CMP_CalculateBufferSize2(&srcTexture);
//========================
// Compressed Destination
//========================
CMP_Texture destTexture;
destTexture.dwSize = sizeof(destTexture);
destTexture.dwWidth = pInMipLevel->m_nWidth;
destTexture.dwHeight = pInMipLevel->m_nHeight;
destTexture.dwPitch = 0;
destTexture.nBlockWidth = srcMipSet->m_nBlockWidth;
destTexture.nBlockHeight = srcMipSet->m_nBlockHeight;
destTexture.format = dstMipSet->m_format;
destTexture.dwDataSize = CMP_CalculateBufferSize2(&destTexture);
dstMipSet->m_format = dstMipSet->m_format;
dstMipSet->dwDataSize = CMP_CalculateBufferSize2(&destTexture);
dstMipSet->dwWidth = pInMipLevel->m_nWidth;
dstMipSet->dwHeight = pInMipLevel->m_nHeight;
MipLevel* pOutMipLevel = CMips.GetMipLevel(dstMipSet, nMipLevel, nFaceOrSlice);
if (!CMips.AllocateCompressedMipLevelData(pOutMipLevel, destTexture.dwWidth, destTexture.dwHeight, destTexture.dwDataSize)) {
return CMP_ERR_MEM_ALLOC_FOR_MIPSET;
}
destTexture.pData = pOutMipLevel->m_pbData;
dstMipSet->pData = pOutMipLevel->m_pbData;
//========================
// Process ConvertTexture
//========================
//------------------------------------------------
// Initializing the Host Framework
// if it fails revert to CPU version of the codec
//------------------------------------------------
ComputeOptions options;
options.force_rebuild = false; // set this to true if you want the shader source code to be allways compiled!
//===============================================================================
// Initalize the Pipeline that will be used for the codec to run on HPC or GPU
//===============================================================================
if (CMP_CreateComputeLibrary(srcMipSet, &kernelOptions, &CMips) != CMP_OK) {
PrintInfo("Failed to init HOST Lib. CPU will be used for compression\n");
cmp_mutex.unlock();
return CMP_ERR_FAILED_HOST_SETUP;
}
// Init Compute Codec info IO
if ((CMips.PrintLine == NULL) && (PrintStatusLine != NULL)) {
CMips.PrintLine = PrintStatusLine;
}
// Set any addition feature as needed for the Host
if (CMP_SetComputeOptions(&options) != CMP_OK) {
CMP_DestroyComputeLibrary(false);
PrintInfo("Failed to setup SPMD GPU options\n");
cmp_mutex.unlock();
return CMP_ERR_FAILED_HOST_SETUP;
}
// Do the compression
if (CMP_CompressTexture(&kernelOptions, *srcMipSet, *dstMipSet, pFeedbackProc) != CMP_OK) {
CMips.FreeMipSet(dstMipSet);
CMP_DestroyComputeLibrary(false);
PrintInfo("Failed to run compute plugin: CPU will be used for compression.\n");
cmp_mutex.unlock();
return CMP_ERR_FAILED_HOST_SETUP;
}
// Get Performance Stats
if (kernelOptions.getPerfStats) {
if (CMP_GetPerformanceStats(&kernelOptions.perfStats) != CMP_OK)
PrintInfo("Warning unable to get compute plugin performance stats\n");
}
//===============================================================================
// Close the Pipeline with option to cache as needed
//===============================================================================
CMP_DestroyComputeLibrary(false);
}
}
if (pFeedbackProc)
pFeedbackProc(100, NULL, NULL);
cmp_mutex.unlock();
return CMP_OK;
}
//
// Block Level Encoder Support
//
CMP_ERROR CMP_API CMP_CreateBlockEncoder(void** block_encoder, CMP_EncoderSetting encodeSettings) {
CMP_RegisterHostPlugins(); // Keep for legacy, user should now use CMP_InitFramework
PluginInterface_Encoder* encoder_codec;
encoder_codec = reinterpret_cast<PluginInterface_Encoder*>(g_pluginManager.GetPlugin("ENCODER", GetFormatDesc((CMP_FORMAT)encodeSettings.format)));
if (encoder_codec == NULL) {
PrintInfo("Failed to load [%s] encoder\n", GetFormatDesc((CMP_FORMAT)encodeSettings.format));
return CMP_ERR_UNABLE_TO_LOAD_ENCODER;
}
CMP_Encoder* blockEncoder = (CMP_Encoder*)encoder_codec->TC_Create();
if (blockEncoder == NULL) {
PrintInfo("Failed to create block encoder [%s]\n", GetFormatDesc((CMP_FORMAT)encodeSettings.format));
return CMP_ERR_UNABLE_TO_CREATE_ENCODER;
}
KernelOptions kernelOptions;
kernelOptions.height = encodeSettings.height;
kernelOptions.width = encodeSettings.width;
kernelOptions.fquality = encodeSettings.quality;
encoder_codec->TC_Init(&kernelOptions);
blockEncoder->m_quality = encodeSettings.quality;
blockEncoder->m_srcHeight = encodeSettings.height;
blockEncoder->m_srcWidth = encodeSettings.width;
*block_encoder = blockEncoder;
delete encoder_codec;
return CMP_OK;
}
CMP_ERROR CMP_API CMP_CompressBlock(void** block_encoder, void* SourceTexture, unsigned int sourceStride, void* DestTexture, unsigned int DestStride) {
CMP_Encoder* encoder = (CMP_Encoder*)*block_encoder;
encoder->m_srcStride = sourceStride;
encoder->m_dstStride = DestStride;
CMP_ERROR res = (CMP_ERROR)encoder->CompressBlock(0, 0, SourceTexture, DestTexture);
return (res);
}
CMP_ERROR CMP_API
CMP_CompressBlockXY(void** block_encoder, unsigned int x, unsigned int y, void* in, unsigned int sourceStride, void* out, unsigned int DestStride) {
CMP_Encoder* encoder = (CMP_Encoder*)*block_encoder;
encoder->m_srcStride = sourceStride;
encoder->m_dstStride = DestStride;
CMP_ERROR res = (CMP_ERROR)encoder->CompressBlock(x, y, in, out);
return (res);
}
void CMP_API CMP_DestroyBlockEncoder(void** block_encoder) {
delete *block_encoder;
}
void CMP_API CMP_GetMipLevel(CMP_MipLevel** data, const CMP_MipSet* pMipSet, int nMipLevel, int nFaceOrSlice) {
CMP_CMIPS CMips;
*data = CMips.GetMipLevel(pMipSet, nMipLevel, nFaceOrSlice);
}
//==============================
// FILE IO static plugin libs
//==============================
CMP_ERROR stb_load(const char* SourceFile, MipSet* MipSetIn) {
int Width, Height, ComponentCount;
unsigned char* pTempData = stbi_load(SourceFile, &Width, &Height, &ComponentCount, STBI_rgb_alpha);
if (pTempData == NULL) {
return CMP_ERR_UNSUPPORTED_SOURCE_FORMAT;
}
CMP_CMIPS CMips;
memset(MipSetIn, 0, sizeof(MipSet));
if (!CMips.AllocateMipSet(MipSetIn, CF_8bit, TDT_ARGB, TT_2D, Width, Height, 1)) {
return CMP_ERR_MEM_ALLOC_FOR_MIPSET;
}
if (!CMips.AllocateMipLevelData(CMips.GetMipLevel(MipSetIn, 0), Width, Height, CF_8bit, TDT_ARGB)) {
return CMP_ERR_MEM_ALLOC_FOR_MIPSET;
}
MipSetIn->m_nMipLevels = 1;
MipSetIn->m_format = CMP_FORMAT_RGBA_8888;
CMP_BYTE* pData = CMips.GetMipLevel(MipSetIn, 0)->m_pbData;
// RGBA : 8888 = 4 bytes
CMP_DWORD dwPitch = (4 * MipSetIn->m_nWidth);
CMP_DWORD dwSize = dwPitch * MipSetIn->m_nHeight;
memcpy(pData, pTempData, dwSize);
// Assign miplevel 0 to MipSetin pData ref
// both miplevel pData and mipset pData will point to the same location
// Typically mipset pData is assign a pointer to the current miplevel data been processed at run time
MipSetIn->pData = pData;
MipSetIn->dwDataSize = dwSize;
stbi_image_free(pTempData);
return CMP_OK;
}
void CMP_API CMP_FreeMipSet(CMP_MipSet* MipSetIn) {
if (!MipSetIn)
return;
if (MipSetIn->m_pMipLevelTable) {
CMP_CMIPS CMips;
CMips.FreeMipSet(MipSetIn);
MipSetIn->m_pMipLevelTable = NULL;
}
}
char toupperChar(char ch) {
return static_cast<char>(::toupper(static_cast<unsigned char>(ch)));
}
void CMP_API CMP_InitFramework()
{
CMP_RegisterHostPlugins();
}
CMP_ERROR CMP_API CMP_LoadTexture(const char* SourceFile, CMP_MipSet* MipSetIn) {
CMP_RegisterHostPlugins(); // Keep for legacy, user should now use CMP_InitFramework
CMP_CMIPS CMips;
CMP_ERROR status = CMP_OK;
std::string fn = SourceFile;
std::string file_extension = fn.substr(fn.find_last_of(".") + 1);
std::transform(file_extension.begin(), file_extension.end(), file_extension.begin(), toupperChar);
PluginInterface_Image* plugin_Image;
do {
plugin_Image = reinterpret_cast<PluginInterface_Image*>(g_pluginManager.GetPlugin("IMAGE", (char*)file_extension.c_str()));
// do the load
if (plugin_Image == NULL) {
status = CMP_ERR_PLUGIN_FILE_NOT_FOUND;
break;
} else {
plugin_Image->TC_PluginSetSharedIO(&CMips);
if (plugin_Image->TC_PluginFileLoadTexture(SourceFile, MipSetIn) != 0) {
// Process Error
delete plugin_Image;
plugin_Image = NULL;
status = CMP_ERR_UNABLE_TO_LOAD_FILE;
break;
}
delete plugin_Image;
plugin_Image = NULL;
}
} while (0);
// load failed: try stb lib
if (status != CMP_OK) {
status = stb_load(SourceFile, MipSetIn);
} else {
// Make sure MipSetIn->pData is at top mip level
if (MipSetIn->pData == NULL) {
CMP_MipLevel* pOutMipLevel = CMips.GetMipLevel(MipSetIn, 0, 0);
MipSetIn->pData = pOutMipLevel->m_pbData;
MipSetIn->dwDataSize = pOutMipLevel->m_dwLinearSize;
MipSetIn->dwHeight = pOutMipLevel->m_nHeight;
MipSetIn->dwWidth = pOutMipLevel->m_nWidth;
}
}
return status;
}
CMP_ERROR CMP_API CMP_SaveTexture(const char* DestFile, CMP_MipSet* MipSetIn)
{
CMP_RegisterHostPlugins(); // Keep for legacy, user should now use CMP_InitFramework
bool filesaved = false;
CMIPS m_CMIPS;
std::string fn = DestFile;
std::string file_extension = fn.substr(fn.find_last_of(".") + 1);
std::transform(file_extension.begin(), file_extension.end(), file_extension.begin(), toupperChar);
//if (((((file_extension.compare("DDS") == 0)
// || file_extension.compare("KTX") == 0)
// || file_extension.compare("KTX2") == 0))
// != TRUE)
// {
// return CMP_ERR_INVALID_DEST_TEXTURE;
//}
PluginInterface_Image* plugin_Image;
plugin_Image = reinterpret_cast<PluginInterface_Image*>(g_pluginManager.GetPlugin("IMAGE", (char*)file_extension.c_str()));
if (plugin_Image) {
bool holdswizzle = MipSetIn->m_swizzle;
if (plugin_Image->TC_PluginFileSaveTexture(DestFile, (MipSet*)MipSetIn) == 0) {
filesaved = true;
}
MipSetIn->m_swizzle = holdswizzle;
delete plugin_Image;
plugin_Image = NULL;
}
if (!filesaved) { // ToDo create a stb_save()
if (file_extension.compare("PNG") == 0)
stbi_write_png(DestFile, MipSetIn->m_nWidth, MipSetIn->m_nHeight, 4, MipSetIn->pData, MipSetIn->m_nWidth * 4);
else
if (file_extension.compare("BMP") == 0)
stbi_write_bmp(DestFile, MipSetIn->m_nWidth, MipSetIn->m_nHeight, 4, MipSetIn->pData);
else
if (file_extension.compare("JPG") == 0)
stbi_write_jpg(DestFile, MipSetIn->m_nWidth, MipSetIn->m_nHeight, 4, MipSetIn->pData, 100);
else
return CMP_ERR_GENERIC;
}
return CMP_OK;
}
CMP_INT CMP_API CMP_NumberOfProcessors(void) {
#ifndef _WIN32
return sysconf(_SC_NPROCESSORS_ONLN);
#else
// Figure out how many cores there are on this machine
//SYSTEM_INFO sysinfo;
//GetSystemInfo(&sysinfo);
//return (sysinfo.dwNumberOfProcessors);
return GetMaximumProcessorCount(0);
#endif
}
Reference in New Issue View Git Blame Copy Permalink