//=============================================================================== // Copyright (c) 2007-2016 Advanced Micro Devices, Inc. All rights reserved. // Copyright (c) 2004-2006 ATI Technologies Inc. // // 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 Name: Compressonator.cpp // Description: A library to compress/decompress textures // // Revisions // Feb 2016 - Fix Parameter processing & Swizzle issue for DXTC Codecs // Jan 2016 - Added ASTC support - // Jan 2014 - Completed support for BC6H and Command line options for new compressonator // Apr 2014 - Refactored Library // Code clean to support MSV 2010 and up ////////////////////////////////////////////////////////////////////////////// #include "common.h" #include "compressonator.h" // User shared: Keep priviate code out of this header #include "compress.h" #include "atiformats.h" #include "cmp_mips.h" #include "debug.h" #include "format_conversion.h" #include using namespace CMP; extern CodecType GetCodecType(CMP_FORMAT format); extern CMP_ERROR GetError(CodecError err); extern CMP_ERROR CheckTexture(const CMP_Texture* pTexture, bool bSource); extern CMP_ERROR CompressTexture(const CMP_Texture* pSourceTexture, CMP_Texture* pDestTexture, const CMP_CompressOptions* pOptions, CMP_Feedback_Proc pFeedbackProc, CodecType destType); extern CMP_ERROR ThreadedCompressTexture(const CMP_Texture* pSourceTexture, CMP_Texture* pDestTexture, const CMP_CompressOptions* pOptions, CMP_Feedback_Proc pFeedbackProc, CodecType destType); #ifdef _LOCAL_DEBUG char DbgTracer::buff[MAX_DBGBUFF_SIZE]; char DbgTracer::PrintBuff[MAX_DBGPPRINTBUFF_SIZE]; #endif CMP_DWORD CMP_API CMP_CalculateBufferSize(const CMP_Texture* pTexture) { #ifdef USE_DBGTRACE DbgTrace(("-------> pTexture [%x]", pTexture)); #endif if (pTexture == NULL) return 0; if (pTexture->dwSize != sizeof(CMP_Texture)) return 0; if (pTexture->dwWidth <= 0) return 0; if (pTexture->dwHeight <= 0) return 0; // Check format range is valid if (!CMP_IsValidFormat(pTexture->format)) return 0; if (pTexture->format == CMP_FORMAT_BROTLIG && CMP_IsValidFormat( pTexture->transcodeFormat)) { // If the data size is already known, we skip the calculation and use it directly, otherwise we calculate using the transcode format if (pTexture->dwDataSize == 0) return CalcBufferSize(pTexture->transcodeFormat, pTexture->dwWidth, pTexture->dwHeight, pTexture->dwPitch, pTexture->nBlockWidth, pTexture->nBlockHeight); else return pTexture->dwDataSize; } return CalcBufferSize(pTexture->format, pTexture->dwWidth, pTexture->dwHeight, pTexture->dwPitch, pTexture->nBlockWidth, pTexture->nBlockHeight); } CMP_DWORD CalcBufferSize(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: return ((dwPitch) ? (dwPitch * dwHeight) : (dwWidth * 4 * dwHeight)); case CMP_FORMAT_RGBA_1010102: case CMP_FORMAT_ARGB_2101010: return ((dwPitch) ? (dwPitch * dwHeight) : (dwWidth * 4 * dwHeight)); case CMP_FORMAT_BGR_888: case CMP_FORMAT_RGB_888: case CMP_FORMAT_RGB_888_S: return ((dwPitch) ? (dwPitch * dwHeight) : ((((dwWidth * 3) + 3) >> 2) * 4 * dwHeight)); case CMP_FORMAT_RG_8: case CMP_FORMAT_RG_8_S: return ((dwPitch) ? (dwPitch * dwHeight) : (dwWidth * 2 * dwHeight)); case CMP_FORMAT_R_8: case CMP_FORMAT_R_8_S: return ((dwPitch) ? (dwPitch * dwHeight) : (dwWidth * dwHeight)); case CMP_FORMAT_ARGB_16: case CMP_FORMAT_ARGB_16F: case CMP_FORMAT_ABGR_16F: case CMP_FORMAT_RGBA_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)); case CMP_FORMAT_BINARY: return dwWidth*dwHeight; default: return CalcBufferSize(GetCodecType(format), dwWidth, dwHeight, nBlockWidth, nBlockHeight); } } // This call is used to swizzle source data content. // Use example: CMP_Map_Bytes(pData, dwWidth, dwHeight, { 2, 1, 0, 3 },4); void CMP_Map_Bytes(BYTE* src, int width, int height, CMP_MAP_BYTES_SET map, CMP_BYTE offset) { int i, j; BYTE b[4]; for (i = 0; i < height; i++) { for (j = 0; j < width; j++) { if (offset == 4) { b[0] = *src; b[1] = *(src + 1); b[2] = *(src + 2); b[3] = *(src + 3); *(src) = b[map.B0]; *(src + 1) = b[map.B1]; *(src + 2) = b[map.B2]; *(src + 3) = b[map.B3]; src = src + 4; // move to next set of bytes } else if (offset == 3) { b[0] = *src; b[1] = *(src + 1); b[2] = *(src + 2); b[3] = *(src + 3); *(src) = b[map.B0]; *(src + 1) = b[map.B1]; *(src + 2) = b[map.B2]; src = src + 3; // move to next set of bytes } } } } #ifndef USE_OLD_SWIZZLE // For now this function will only handle a single case // where the source data remains the same size and only RGBA channels // are swizzled according output compressed formats, // if source is compressed then no change is performed void CMP_PrepareSourceForCMP_Destination(CMP_Texture* pTexture, CMP_FORMAT DestFormat) { CMP_DWORD dwWidth = pTexture->dwWidth; CMP_DWORD dwHeight = pTexture->dwHeight; CMP_FORMAT newSrcFormat = pTexture->format; CMP_BYTE* pData; pData = pTexture->pData; switch (newSrcFormat) { case CMP_FORMAT_BGRA_8888: { switch (DestFormat) { case CMP_FORMAT_ATI1N: case CMP_FORMAT_ATI2N: case CMP_FORMAT_ATI2N_XY: case CMP_FORMAT_ATI2N_DXT5: case CMP_FORMAT_ATC_RGB: case CMP_FORMAT_ATC_RGBA_Explicit: case CMP_FORMAT_ATC_RGBA_Interpolated: case CMP_FORMAT_BC1: case CMP_FORMAT_BC2: case CMP_FORMAT_BC3: case CMP_FORMAT_BC4: case CMP_FORMAT_BC4_S: case CMP_FORMAT_BC5: case CMP_FORMAT_BC5_S: 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: { // The source format is correct for these codecs break; } #if (OPTION_BUILD_ASTC == 1) case CMP_FORMAT_ASTC: #endif case CMP_FORMAT_BC6H: case CMP_FORMAT_BC7: case CMP_FORMAT_GT: case CMP_FORMAT_ETC_RGB: case CMP_FORMAT_ETC2_RGB: case CMP_FORMAT_ETC2_SRGB: case CMP_FORMAT_ETC2_RGBA: case CMP_FORMAT_ETC2_RGBA1: case CMP_FORMAT_ETC2_SRGBA: case CMP_FORMAT_ETC2_SRGBA1: { newSrcFormat = CMP_FORMAT_RGBA_8888; CMP_Map_Bytes(pData, dwWidth, dwHeight, {2, 1, 0, 3}, 4); break; } default: break; } break; } case CMP_FORMAT_RGBA_8888: { switch (DestFormat) { case CMP_FORMAT_ATI1N: case CMP_FORMAT_ATI2N: case CMP_FORMAT_ATI2N_XY: case CMP_FORMAT_ATI2N_DXT5: case CMP_FORMAT_ATC_RGB: case CMP_FORMAT_ATC_RGBA_Explicit: case CMP_FORMAT_ATC_RGBA_Interpolated: case CMP_FORMAT_BC1: case CMP_FORMAT_BC2: case CMP_FORMAT_BC3: case CMP_FORMAT_BC4: case CMP_FORMAT_BC4_S: case CMP_FORMAT_BC5: case CMP_FORMAT_BC5_S: 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: { newSrcFormat = CMP_FORMAT_BGRA_8888; CMP_Map_Bytes(pData, dwWidth, dwHeight, {2, 1, 0, 3}, 4); break; } #if (OPTION_BUILD_ASTC == 1) case CMP_FORMAT_ASTC: #endif case CMP_FORMAT_BC6H: case CMP_FORMAT_BC7: case CMP_FORMAT_ETC_RGB: case CMP_FORMAT_ETC2_RGB: case CMP_FORMAT_ETC2_SRGB: case CMP_FORMAT_ETC2_RGBA: case CMP_FORMAT_ETC2_RGBA1: case CMP_FORMAT_ETC2_SRGBA: case CMP_FORMAT_ETC2_SRGBA1: case CMP_FORMAT_GT: { // format is correct } default: break; } break; } case CMP_FORMAT_ARGB_8888: { switch (DestFormat) { case CMP_FORMAT_ATI1N: case CMP_FORMAT_ATI2N: case CMP_FORMAT_ATI2N_XY: case CMP_FORMAT_ATI2N_DXT5: case CMP_FORMAT_ATC_RGB: case CMP_FORMAT_ATC_RGBA_Explicit: case CMP_FORMAT_ATC_RGBA_Interpolated: 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: { newSrcFormat = CMP_FORMAT_BGRA_8888; CMP_Map_Bytes(pData, dwWidth, dwHeight, {3, 2, 1, 0}, 4); break; } #if (OPTION_BUILD_ASTC == 1) case CMP_FORMAT_ASTC: #endif case CMP_FORMAT_BC6H: case CMP_FORMAT_BC7: case CMP_FORMAT_ETC_RGB: case CMP_FORMAT_ETC2_RGB: case CMP_FORMAT_ETC2_SRGB: case CMP_FORMAT_ETC2_RGBA: case CMP_FORMAT_ETC2_RGBA1: case CMP_FORMAT_ETC2_SRGBA: case CMP_FORMAT_ETC2_SRGBA1: case CMP_FORMAT_GT: { newSrcFormat = CMP_FORMAT_RGBA_8888; CMP_Map_Bytes(pData, dwWidth, dwHeight, {1, 2, 3, 0}, 4); break; } default: break; } break; } default: break; } // Update Source format to new one pTexture->format = newSrcFormat; } // For now this function will only handle a single case // where the source data remains the same size and only RGBA channels // are swizzled according output compressed formats, // if source is compressed then no change is performed void CMP_PrepareCMPSourceForIMG_Destination(CMP_Texture* pDstTexture, CMP_FORMAT SrcFormat) { CMP_DWORD dwWidth = pDstTexture->dwWidth; CMP_DWORD dwHeight = pDstTexture->dwHeight; CMP_FORMAT newDstFormat = pDstTexture->format; CMP_BYTE* pData; pData = pDstTexture->pData; switch (SrcFormat) { // decompressed Data is in the form BGRA case CMP_FORMAT_ATI1N: case CMP_FORMAT_ATI2N: case CMP_FORMAT_ATI2N_XY: case CMP_FORMAT_ATI2N_DXT5: case CMP_FORMAT_ATC_RGB: case CMP_FORMAT_ATC_RGBA_Explicit: case CMP_FORMAT_ATC_RGBA_Interpolated: case CMP_FORMAT_BC1: case CMP_FORMAT_BC2: case CMP_FORMAT_BC3: case CMP_FORMAT_BC4: case CMP_FORMAT_BC4_S: case CMP_FORMAT_BC5: case CMP_FORMAT_BC5_S: 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: { switch (newDstFormat) { case CMP_FORMAT_BGRA_8888: break; case CMP_FORMAT_RGBA_8888: { CMP_Map_Bytes(pData, dwWidth, dwHeight, {2, 1, 0, 3}, 4); break; } default: break; } } // decompressed Data is in the form RGBA_8888 #if (OPTION_BUILD_ASTC == 1) case CMP_FORMAT_ASTC: #endif case CMP_FORMAT_BC6H: case CMP_FORMAT_BC7: case CMP_FORMAT_GT: case CMP_FORMAT_ETC_RGB: case CMP_FORMAT_ETC2_RGB: case CMP_FORMAT_ETC2_SRGB: case CMP_FORMAT_ETC2_RGBA: case CMP_FORMAT_ETC2_RGBA1: case CMP_FORMAT_ETC2_SRGBA: case CMP_FORMAT_ETC2_SRGBA1: { switch (newDstFormat) { case CMP_FORMAT_RGBA_8888: break; case CMP_FORMAT_BGRA_8888: { CMP_Map_Bytes(pData, dwWidth, dwHeight, {2, 1, 0, 3}, 4); break; } default: break; } } } } #endif CMP_ERROR CMP_API CMP_ConvertTexture(CMP_Texture* pSourceTexture, CMP_Texture* pDestTexture, const CMP_CompressOptions* pOptions, CMP_Feedback_Proc pFeedbackProc) { #ifdef USE_DBGTRACE DbgTrace(("-------> pSourceTexture [%x] pDestTexture [%x] pOptions [%x]", pSourceTexture, pDestTexture, pOptions)); #endif CMP_ERROR tc_err = CheckTexture(pSourceTexture, true); if (tc_err != CMP_OK) return tc_err; // make a local copy of the texture to avoid modifying the user's data CMP_Texture srcTextureCopy = *pSourceTexture; #ifdef ENABLE_MAKE_COMPATIBLE_API FloatParams floatParams(pOptions); ConvertedBuffer compatibleBuffer = CreateCompatibleBuffer(pDestTexture->format, &srcTextureCopy, &floatParams); srcTextureCopy.format = compatibleBuffer.format; srcTextureCopy.pData = (CMP_BYTE*)compatibleBuffer.data; srcTextureCopy.dwDataSize = compatibleBuffer.dataSize; #endif tc_err = CheckTexture(pDestTexture, false); if (tc_err != CMP_OK) return tc_err; if (srcTextureCopy.dwWidth != pDestTexture->dwWidth || srcTextureCopy.dwHeight != pDestTexture->dwHeight) return CMP_ERR_SIZE_MISMATCH; CodecType srcType = GetCodecType(srcTextureCopy.format); assert(srcType != CT_Unknown); if (srcType == CT_Unknown) return CMP_ERR_UNSUPPORTED_SOURCE_FORMAT; CodecType destType = GetCodecType(pDestTexture->format); assert(destType != CT_Unknown); if (destType == CT_Unknown) return CMP_ERR_UNSUPPORTED_SOURCE_FORMAT; if (srcType == destType) { // Easy case ? if (srcTextureCopy.format == pDestTexture->format && srcTextureCopy.dwPitch == pDestTexture->dwPitch) memcpy(pDestTexture->pData, srcTextureCopy.pData, CMP_CalculateBufferSize(&srcTextureCopy)); else { CodecBufferType srcBufferType = GetCodecBufferType(srcTextureCopy.format); CodecBufferType destBufferType = GetCodecBufferType(pDestTexture->format); CCodecBuffer* pSrcBuffer = CreateCodecBuffer(srcBufferType, srcTextureCopy.nBlockWidth, srcTextureCopy.nBlockHeight, srcTextureCopy.nBlockDepth, srcTextureCopy.dwWidth, srcTextureCopy.dwHeight, srcTextureCopy.dwPitch, srcTextureCopy.pData, srcTextureCopy.dwDataSize); assert(pSrcBuffer); if (!pSrcBuffer) return CMP_ERR_GENERIC; CCodecBuffer* pDestBuffer = CreateCodecBuffer(destBufferType, pDestTexture->nBlockWidth, pDestTexture->nBlockHeight, pDestTexture->nBlockDepth, pDestTexture->dwWidth, pDestTexture->dwHeight, pDestTexture->dwPitch, pDestTexture->pData, pDestTexture->dwDataSize); assert(pDestBuffer); if (!pDestBuffer) { delete pSrcBuffer; return CMP_ERR_GENERIC; } DISABLE_FP_EXCEPTIONS; pDestBuffer->Copy(*pSrcBuffer); RESTORE_FP_EXCEPTIONS; delete pSrcBuffer; delete pDestBuffer; } return CMP_OK; } else if (srcType == CT_None && destType != CT_None) { #ifndef USE_OLD_SWIZZLE CMP_PrepareSourceForCMP_Destination(&srcTextureCopy, pDestTexture->format); #endif CMP_BOOL bMultithread = true; if (!pOptions->bDisableMultiThreading && (pOptions->dwnumThreads == 1)) bMultithread = false; #ifdef THREADED_COMPRESS // Note: // BC7/BC6H has issues with this setting - we already set multithreading via numThreads so // this call is disabled for BC7/BC6H ASTC Codecs. // if the use has set DiableMultiThreading then numThreads will be set to 1 (regradless of its original value) if (((!pOptions || !pOptions->bDisableMultiThreading) && f_dwProcessorCount > 1) && (bMultithread) && #if (OPTION_BUILD_ASTC == 1) (destType != CT_ASTC) && #endif (destType != CT_BC7) && (destType != CT_BC6H) && (destType != CT_BC6H_SF) #ifdef USE_APC && (destType != CT_APC) #endif #ifdef USE_GTC && (destType != CT_GTC) #endif #ifdef USE_LOSSLESS_COMPRESSION && (destType != CT_BRLG) #endif #ifdef USE_BASIS && (destType != CT_BASIS) #endif ) { tc_err = ThreadedCompressTexture(&srcTextureCopy, pDestTexture, pOptions, pFeedbackProc, destType); return tc_err; } else #endif // THREADED_COMPRESS { tc_err = CompressTexture(&srcTextureCopy, pDestTexture, pOptions, pFeedbackProc, destType); return tc_err; } } else if (srcType != CT_None && destType == CT_None) { // Decompressing CCodec* pCodec = CreateCodec(srcType); assert(pCodec); if (pCodec == NULL) { return CMP_ERR_UNABLE_TO_INIT_CODEC; } if (pOptions && pOptions->dwSize == sizeof(CMP_CompressOptions)) { #ifdef USE_LOSSLESS_COMPRESSION if (pOptions->bUseGPUDecompress) { pCodec->SetParameter(CodecParameters::UseGPUDecompression, (CMP_DWORD)1); } #endif } CodecBufferType destBufferType = GetCodecBufferType(pDestTexture->format); CCodecBuffer* pSrcBuffer = pCodec->CreateBuffer(srcTextureCopy.nBlockWidth, srcTextureCopy.nBlockHeight, srcTextureCopy.nBlockDepth, srcTextureCopy.dwWidth, srcTextureCopy.dwHeight, srcTextureCopy.dwPitch, srcTextureCopy.pData, srcTextureCopy.dwDataSize); pDestTexture->nBlockWidth = srcTextureCopy.nBlockWidth; pDestTexture->nBlockHeight = srcTextureCopy.nBlockHeight; pDestTexture->nBlockDepth = srcTextureCopy.nBlockDepth; CCodecBuffer* pDestBuffer = CreateCodecBuffer(destBufferType, pDestTexture->nBlockWidth, pDestTexture->nBlockHeight, pDestTexture->nBlockDepth, pDestTexture->dwWidth, pDestTexture->dwHeight, pDestTexture->dwPitch, pDestTexture->pData, pDestTexture->dwDataSize); // assert(pDestBuffer); // assert(pSrcBuffer); if (pSrcBuffer == NULL || pDestBuffer == NULL) { SAFE_DELETE(pCodec); SAFE_DELETE(pSrcBuffer); SAFE_DELETE(pDestBuffer); return CMP_ERR_GENERIC; } DISABLE_FP_EXCEPTIONS; pSrcBuffer->SetBlockHeight(srcTextureCopy.nBlockHeight); pSrcBuffer->SetBlockWidth(srcTextureCopy.nBlockWidth); pSrcBuffer->SetBlockDepth(srcTextureCopy.nBlockDepth); pSrcBuffer->SetFormat(srcTextureCopy.format); pSrcBuffer->SetTranscodeFormat(srcTextureCopy.transcodeFormat); pDestBuffer->SetBlockHeight(pDestTexture->nBlockHeight); pDestBuffer->SetBlockWidth(pDestTexture->nBlockWidth); pDestBuffer->SetBlockDepth(pDestTexture->nBlockDepth); pDestBuffer->SetFormat(pDestTexture->format); CodecError err1 = pCodec->Decompress(*pSrcBuffer, *pDestBuffer, pFeedbackProc); RESTORE_FP_EXCEPTIONS; #ifndef USE_OLD_SWIZZLE CMP_PrepareCMPSourceForIMG_Destination(pDestTexture, srcTextureCopy.format); #endif SAFE_DELETE(pCodec); SAFE_DELETE(pSrcBuffer); SAFE_DELETE(pDestBuffer); return GetError(err1); } else { // Decompressing & then compressing // Decompressing CCodec* pCodecIn = CreateCodec(srcType); CCodec* pCodecOut = CreateCodec(destType); assert(pCodecIn); assert(pCodecOut); if (pCodecIn == NULL || pCodecOut == NULL) { SAFE_DELETE(pCodecIn); SAFE_DELETE(pCodecOut); return CMP_ERR_UNABLE_TO_INIT_CODEC; } CCodecBuffer* pSrcBuffer = pCodecIn->CreateBuffer(srcTextureCopy.nBlockWidth, srcTextureCopy.nBlockHeight, srcTextureCopy.nBlockDepth, srcTextureCopy.dwWidth, srcTextureCopy.dwHeight, srcTextureCopy.dwPitch, srcTextureCopy.pData, srcTextureCopy.dwDataSize); CCodecBuffer* pTempBuffer = CreateCodecBuffer( CBT_RGBA32F, pDestTexture->nBlockWidth, pDestTexture->nBlockHeight, pDestTexture->nBlockDepth, pDestTexture->dwWidth, pDestTexture->dwHeight); CCodecBuffer* pDestBuffer = pCodecOut->CreateBuffer(pDestTexture->nBlockWidth, pDestTexture->nBlockHeight, pDestTexture->nBlockDepth, pDestTexture->dwWidth, pDestTexture->dwHeight, pDestTexture->dwPitch, pDestTexture->pData, pDestTexture->dwDataSize); assert(pSrcBuffer); assert(pTempBuffer); assert(pDestBuffer); if (pSrcBuffer == NULL || pTempBuffer == NULL || pDestBuffer == NULL) { SAFE_DELETE(pCodecIn); SAFE_DELETE(pCodecOut); SAFE_DELETE(pSrcBuffer); SAFE_DELETE(pTempBuffer); SAFE_DELETE(pDestBuffer); return CMP_ERR_GENERIC; } DISABLE_FP_EXCEPTIONS; CodecError err2 = pCodecIn->Decompress(*pSrcBuffer, *pTempBuffer, pFeedbackProc); if (err2 == CE_OK) { err2 = pCodecOut->Compress(*pTempBuffer, *pDestBuffer, pFeedbackProc); } RESTORE_FP_EXCEPTIONS; return GetError(err2); } } CMP_ERROR CMP_API CMP_ConvertMipTexture(CMP_MipSet* p_MipSetIn, CMP_MipSet* p_MipSetOut, const CMP_CompressOptions* pOptions, CMP_Feedback_Proc pFeedbackProc) { assert(p_MipSetIn); assert(p_MipSetOut); assert(pOptions); CMP_CMIPS CMips; // -------------------------------- // Setup Compressed Mip Set Traget // -------------------------------- //if (GetCodecType(pOptions->DestFormat) == CT_Unknown) return CMP_ERR_UNKNOWN_DESTINATION_FORMAT; // ------------- // Output // ------------- memset(p_MipSetOut, 0, sizeof(CMP_MipSet)); p_MipSetOut->m_Flags = MS_FLAG_Default; p_MipSetOut->m_format = pOptions->DestFormat; p_MipSetOut->m_nHeight = p_MipSetIn->m_nHeight; p_MipSetOut->m_nWidth = p_MipSetIn->m_nWidth; CMP_Format2FourCC(pOptions->DestFormat, p_MipSetOut); // Default compression block size if not set! p_MipSetIn->m_nBlockWidth = (p_MipSetIn->m_nBlockWidth == 0) ? 4 : p_MipSetIn->m_nBlockWidth; p_MipSetIn->m_nBlockHeight = (p_MipSetIn->m_nBlockHeight == 0) ? 4 : p_MipSetIn->m_nBlockHeight; p_MipSetIn->m_nDepth = (p_MipSetIn->m_nDepth < 1) ? 1 : p_MipSetIn->m_nDepth; // Allocate compression data p_MipSetOut->m_nMipLevels = 1; // this is overwritten depending on input. p_MipSetOut->m_ChannelFormat = CF_Compressed; p_MipSetOut->m_nMaxMipLevels = p_MipSetIn->m_nMaxMipLevels; p_MipSetOut->m_nBlockWidth = p_MipSetIn->m_nBlockWidth; p_MipSetOut->m_nBlockHeight = p_MipSetIn->m_nBlockHeight; p_MipSetOut->m_nDepth = p_MipSetIn->m_nDepth; p_MipSetOut->m_TextureType = p_MipSetIn->m_TextureType; if (pOptions->DestFormat == CMP_FORMAT_BROTLIG) p_MipSetOut->m_transcodeFormat = p_MipSetIn->m_format; p_MipSetOut->m_nIterations = 0; // tracks number of processed data miplevels //===================================================== // Case Uncompressed Source to Compressed Destination //===================================================== CMP_Texture srcTexture = {}; srcTexture.dwSize = sizeof(srcTexture); #ifdef USE_BASIS if (pOptions->DestFormat == CMP_FORMAT_BASIS) { p_MipSetOut->m_format = CMP_FORMAT_BASIS; p_MipSetOut->m_transcodeFormat = CMP_FORMAT_BC1; p_MipSetOut->m_TextureType = TT_2D; p_MipSetOut->m_TextureDataType = TDT_ARGB; p_MipSetOut->m_ChannelFormat = CF_Compressed; p_MipSetOut->dwDataSize = 0; // will be set after compression p_MipSetOut->dwWidth = 1; // Container for 1 linear data buffer p_MipSetOut->dwHeight = 1; // Container for 1 linear data buffer p_MipSetOut->m_nDepth = 1; if (!CMips.AllocateMipSet(p_MipSetOut, p_MipSetOut->m_ChannelFormat, TDT_ARGB, p_MipSetOut->m_TextureType, 1, 1, 1)) { return CMP_ERR_MEM_ALLOC_FOR_MIPSET; } //===================== // Uncompressed source //====================== CMP_MipLevel* pInMipLevel = CMips.GetMipLevel(p_MipSetIn, 0, 0); srcTexture.dwPitch = 0; srcTexture.nBlockWidth = p_MipSetIn->m_nBlockWidth; srcTexture.nBlockHeight = p_MipSetIn->m_nBlockHeight; srcTexture.nBlockDepth = p_MipSetIn->m_nBlockDepth; srcTexture.format = p_MipSetIn->m_format; srcTexture.dwWidth = p_MipSetIn->m_nWidth; srcTexture.dwHeight = p_MipSetIn->m_nHeight; srcTexture.transcodeFormat = p_MipSetIn->m_transcodeFormat; srcTexture.pData = pInMipLevel->m_pbData; srcTexture.dwWidth = pInMipLevel->m_nWidth; srcTexture.dwHeight = pInMipLevel->m_nHeight; srcTexture.pData = pInMipLevel->m_pbData; srcTexture.dwDataSize = CMP_CalculateBufferSize(&srcTexture); //======================== // Compressed Destination //======================== CMP_Texture destTexture; MipLevel* pOutMipLevel = CMips.GetMipLevel(p_MipSetOut, 0, 0); pOutMipLevel->m_pvec8Data = new CMP_VEC8(); // size = 0 before compression, will be set during processing p_MipSetOut->pData = pOutMipLevel->m_pbData; destTexture.dwSize = sizeof(destTexture); destTexture.dwWidth = p_MipSetIn->m_nWidth; destTexture.dwHeight = p_MipSetIn->m_nHeight; destTexture.dwPitch = 0; destTexture.nBlockWidth = p_MipSetIn->m_nBlockWidth; destTexture.nBlockHeight = p_MipSetIn->m_nBlockHeight; destTexture.format = pOptions->DestFormat; srcTexture.transcodeFormat = p_MipSetIn->m_transcodeFormat; destTexture.dwDataSize = CMP_CalculateBufferSize(&srcTexture); // This will be reset after compression destTexture.pData = pOutMipLevel->m_pbData; //======================== // Process ConvertTexture //======================== CMP_ERROR cmp_status = CMP_ConvertTexture(&srcTexture, &destTexture, pOptions, pFeedbackProc); if (cmp_status != CMP_OK) { return cmp_status; } } else #endif { if (!CMips.AllocateMipSet(p_MipSetOut, p_MipSetOut->m_ChannelFormat, TDT_ARGB, p_MipSetOut->m_TextureType, p_MipSetIn->m_nWidth, p_MipSetIn->m_nHeight, p_MipSetOut->m_nDepth)) { return CMP_ERR_MEM_ALLOC_FOR_MIPSET; } p_MipSetOut->m_nMipLevels = p_MipSetIn->m_nMipLevels; for (int nMipLevel = 0; nMipLevel < p_MipSetIn->m_nMipLevels; nMipLevel++) { if ((pOptions->m_PrintInfoStr) && p_MipSetIn->m_nMipLevels > 1) { char buff[256]; snprintf(buff, sizeof(buff), "Processing miplevel %d for texture...\n", nMipLevel); pOptions->m_PrintInfoStr(buff); } for (int nFaceOrSlice = 0; nFaceOrSlice < CMP_MaxFacesOrSlices(p_MipSetIn, nMipLevel); nFaceOrSlice++) { CMP_DWORD sourceDataSize = 0; //===================== // Uncompressed source //====================== CMP_MipLevel* pInMipLevel = CMips.GetMipLevel(p_MipSetIn, nMipLevel, nFaceOrSlice); srcTexture.dwPitch = 0; srcTexture.nBlockWidth = p_MipSetIn->m_nBlockWidth; srcTexture.nBlockHeight = p_MipSetIn->m_nBlockHeight; srcTexture.nBlockDepth = p_MipSetIn->m_nBlockDepth; srcTexture.format = p_MipSetIn->m_format; srcTexture.transcodeFormat = p_MipSetIn->m_transcodeFormat; srcTexture.dwWidth = pInMipLevel->m_nWidth; srcTexture.dwHeight = pInMipLevel->m_nHeight; srcTexture.pData = pInMipLevel->m_pbData; srcTexture.dwDataSize = CMP_CalculateBufferSize(&srcTexture); // Temporary settings p_MipSetIn->dwWidth = srcTexture.dwWidth; p_MipSetIn->dwHeight = srcTexture.dwHeight; p_MipSetIn->pData = srcTexture.pData; p_MipSetIn->dwDataSize = srcTexture.dwDataSize; //======================== // Compressed Destination //======================== CMP_Texture destTexture = {}; destTexture.dwSize = sizeof(destTexture); destTexture.dwWidth = pInMipLevel->m_nWidth; destTexture.dwHeight = pInMipLevel->m_nHeight; destTexture.dwPitch = 0; destTexture.nBlockWidth = p_MipSetIn->m_nBlockWidth; destTexture.nBlockHeight = p_MipSetIn->m_nBlockHeight; destTexture.format = pOptions->DestFormat; destTexture.transcodeFormat = p_MipSetOut->m_transcodeFormat; destTexture.dwDataSize = CMP_CalculateBufferSize(&destTexture); p_MipSetOut->m_format = destTexture.format; p_MipSetOut->dwDataSize = destTexture.dwDataSize; p_MipSetOut->dwWidth = destTexture.dwWidth; p_MipSetOut->dwHeight = destTexture.dwHeight; //-------------------------------------- // Allocate MipSet for Block Compressors //-------------------------------------- CMP_MipLevel* pOutMipLevel = CMips.GetMipLevel(p_MipSetOut, nMipLevel, nFaceOrSlice); if (!CMips.AllocateCompressedMipLevelData(pOutMipLevel, destTexture.dwWidth, destTexture.dwHeight, destTexture.dwDataSize)) { return CMP_ERR_MEM_ALLOC_FOR_MIPSET; } destTexture.pData = pOutMipLevel->m_pbData; p_MipSetOut->pData = pOutMipLevel->m_pbData; //========================== // Print info about input //========================== // NOTE: This is duplicated in CMP_ConvertMipTextureCGP if (pOptions->m_PrintInfoStr) { char buff[256]; if ((p_MipSetOut->m_format == CMP_FORMAT_BROTLIG) || (p_MipSetOut->m_format == CMP_FORMAT_BINARY)) snprintf(buff, sizeof(buff), "Source data size = %d Bytes\n", srcTexture.dwDataSize); else snprintf(buff, sizeof(buff), "Source data size = %d Bytes, width = %d px height = %d px\n", srcTexture.dwDataSize, srcTexture.dwWidth, srcTexture.dwHeight); pOptions->m_PrintInfoStr(buff); } // this is needed to preserve the correct initial source size because CMP_ConvertTexture might // edit the srcTexture and change its format into one better suited for processing sourceDataSize = srcTexture.dwDataSize; //======================== // Process ConvertTexture //======================== CMP_ERROR cmp_status = CMP_ConvertTexture(&srcTexture, &destTexture, pOptions, pFeedbackProc); if (cmp_status != CMP_OK) { return cmp_status; } else p_MipSetOut->m_nIterations++; if (p_MipSetOut->m_format == CMP_FORMAT_BROTLIG) { p_MipSetOut->dwDataSize = destTexture.dwDataSize; } //========================== // Print info about output //========================== // NOTE: This is mostly duplicated in CMP_ConvertMipTextureCGP if (pOptions->m_PrintInfoStr && (destTexture.dwDataSize > 0) && (p_MipSetOut->m_format != CMP_FORMAT_BINARY)) { char buff[256]; snprintf(buff, sizeof(buff), "\rDestination data size = %d Bytes Resulting compression ratio = %2.2f:1\n", destTexture.dwDataSize, sourceDataSize / (float)destTexture.dwDataSize); pOptions->m_PrintInfoStr(buff); } } } } //if (pFeedbackProc) // pFeedbackProc(100, NULL, NULL); return CMP_OK; }