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

1312 lines
42 KiB
C++
Raw Blame History

//=====================================================================
// Copyright 2008 (c), ATI Technologies Inc. All rights reserved.
// Copyright 2020 (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.
//
#include "compressonator.h"
#include "cmp_mips.h"
#include <stdarg.h>
#include <stdio.h>
#include <assert.h>
void (*PrintStatusLine)(char*) = NULL;
void PrintInfo(const char* Format, ...)
{
if (PrintStatusLine)
{
// define a pointer to save argument list
va_list args;
char buff[1024];
// process the arguments into our debug buffer
va_start(args, Format);
vsnprintf(buff, 1024, Format, args);
va_end(args);
PrintStatusLine(buff);
}
}
void CMP_CMIPS::PrintError(const char* Format, ...)
{
char buff[1024];
// define a pointer to save argument list
va_list args;
// process the arguments into our debug buffer
va_start(args, Format);
vsnprintf(buff, 1024, Format, args);
va_end(args);
PrintInfo(buff);
}
void CMP_CMIPS::Print(const char* Format, ...)
{
if (!PrintLine)
return;
if (m_infolevel & 0x01)
{
char buff[1024];
// define a pointer to save argument list
va_list args;
// process the arguments into our debug buffer
va_start(args, Format);
vsnprintf(buff, 1024, Format, args);
va_end(args);
PrintLine(buff);
}
}
// Determins the active channels used for a given format
// See CMP_AnalysisData for more details on the bits set
CMP_UINT CMP_API CMP_getFormat_nChannels(CMP_FORMAT format)
{
CMP_UINT RGBAChannels;
switch (format)
{
case CMP_FORMAT_ATI1N:
case CMP_FORMAT_BC4:
case CMP_FORMAT_BC4_S: // All channels are used and equal, Red is used as active channel
RGBAChannels = 0b0001; // R
break;
case CMP_FORMAT_ATI2N_XY:
case CMP_FORMAT_BC5_S:
case CMP_FORMAT_BC5: // Only Red & Green channels active
RGBAChannels = 0b0011; // GR
break;
default:
RGBAChannels = 0b0111; // BGR , alpha skipped user can set this after
break;
}
return RGBAChannels;
}
CMP_INT CMP_API CMP_CalcMinMipSize(CMP_INT nHeight, CMP_INT nWidth, CMP_INT MipsLevel)
{
while (MipsLevel > 1)
{
nWidth = CMP_MAX(nWidth >> 1, 1);
nHeight = CMP_MAX(nHeight >> 1, 1);
MipsLevel--;
}
return (nWidth);
}
CMP_INT CMP_API CMP_CalcMaxMipLevel(CMP_INT nHeight, CMP_INT nWidth, CMP_BOOL bForGPU)
{
CMP_INT MaxLipLevel = 1;
while (MaxLipLevel < MAX_MIPLEVEL_SUPPORTED)
{
nWidth = CMP_MAX(nWidth >> 1, 1);
nHeight = CMP_MAX(nHeight >> 1, 1);
if (bForGPU)
{
if ((nWidth % 4) || (nHeight % 4))
break;
}
MaxLipLevel++;
if ((nWidth == 1) || (nHeight == 1))
break;
}
return (MaxLipLevel);
}
CMP_ERROR CMP_API CMP_CreateCompressMipSet(CMP_MipSet* pMipSetCMP, CMP_MipSet* pMipSetSRC)
{
CMP_CMIPS CMips;
pMipSetCMP->m_Flags = MS_FLAG_Default;
pMipSetCMP->m_nHeight = pMipSetSRC->m_nHeight;
pMipSetCMP->m_nWidth = pMipSetSRC->m_nWidth;
pMipSetCMP->dwWidth = pMipSetSRC->dwWidth;
pMipSetCMP->dwHeight = pMipSetSRC->dwHeight;
pMipSetCMP->m_ChannelFormat = CF_Compressed;
pMipSetCMP->m_dwFourCC = CMP_MAKEFOURCC('D', 'X', '1', '0');
pMipSetCMP->m_nBlockHeight = 4;
pMipSetCMP->m_nBlockWidth = 4;
pMipSetCMP->m_nMaxMipLevels = pMipSetSRC->m_nMaxMipLevels;
pMipSetCMP->m_nMipLevels = 1;
pMipSetCMP->m_TextureType = pMipSetSRC->m_TextureType;
pMipSetCMP->m_nDepth = pMipSetSRC->m_nDepth;
if (!CMips.AllocateMipSet(
pMipSetCMP, CF_Compressed, TDT_ARGB, pMipSetCMP->m_TextureType, pMipSetSRC->m_nWidth, pMipSetSRC->m_nHeight, pMipSetCMP->m_nDepth))
return CMP_ERR_MEM_ALLOC_FOR_MIPSET;
//----------------------------------------------------------------
// Access the data table for mip level 0 (full texture width and height)
//----------------------------------------------------------------
MipLevel* pOutMipLevel = CMips.GetMipLevel(pMipSetCMP, 0);
//-----------------------------------------------------------------------
// Calculate the target compressed block buffer size (4 bytes x 4 bytes)
//-----------------------------------------------------------------------
unsigned int Width = ((pMipSetSRC->m_nWidth + 3) / 4) * 4;
unsigned int Height = ((pMipSetSRC->m_nHeight + 3) / 4) * 4;
pMipSetCMP->dwDataSize = Width * Height;
//----------------------------------------------------------------
// Allocate memory for the mip level 0
//----------------------------------------------------------------
if (!CMips.AllocateCompressedMipLevelData(pOutMipLevel, pMipSetSRC->m_nWidth, pMipSetSRC->m_nHeight, pMipSetCMP->dwDataSize))
{
std::printf("Memory Error(1): allocating MIPSet compression level data buffer\n");
return CMP_ERR_MEM_ALLOC_FOR_MIPSET;
}
pMipSetCMP->pData = pOutMipLevel->m_pbData;
return CMP_OK;
}
CMP_ERROR CMP_API CMP_CreateMipSet(CMP_MipSet* pMipSet, CMP_INT nWidth, CMP_INT nHeight, CMP_INT nDepth, ChannelFormat channelFormat, TextureType textureType)
{
CMP_CMIPS CMips;
pMipSet->m_Flags = MS_FLAG_Default;
pMipSet->m_nHeight = nHeight;
pMipSet->m_nWidth = nWidth;
pMipSet->dwWidth = 0;
pMipSet->dwHeight = 0;
pMipSet->m_ChannelFormat = channelFormat;
pMipSet->m_dwFourCC = 0;
pMipSet->m_nBlockHeight = 4;
pMipSet->m_nBlockWidth = 4;
pMipSet->m_nMaxMipLevels = CMP_CalcMaxMipLevel(nHeight, nWidth, false);
pMipSet->m_nMipLevels = 1;
pMipSet->m_TextureType = textureType;
pMipSet->m_nDepth = nDepth;
if (!CMips.AllocateMipSet(pMipSet, channelFormat, TDT_ARGB, pMipSet->m_TextureType, nWidth, nHeight, nDepth))
return CMP_ERR_MEM_ALLOC_FOR_MIPSET;
//----------------------------------------------------------------
// Access the data table for mip level 0 (full texture width and height)
//----------------------------------------------------------------
MipLevel* pOutMipLevel = CMips.GetMipLevel(pMipSet, 0);
//-----------------------------------------------------------------------
// Calculate the target compressed block buffer size (4 bytes x 4 bytes)
//-----------------------------------------------------------------------
CMP_INT bytesPerChannel; // use m_ChannelFormat for this
switch (channelFormat)
{
case CF_16bit:
case CF_Float16:
bytesPerChannel = 8;
break;
case CF_32bit:
case CF_Float32:
bytesPerChannel = 16;
break;
case CF_2101010 :
case CF_Float9995E :
case CF_YUV_420 :
case CF_YUV_422 :
case CF_YUV_444 :
case CF_YUV_4444 :
// toDo
return CMP_ERR_UNSUPPORTED_SOURCE_FORMAT;
break;
case CF_Compressed:
default:
bytesPerChannel = 4;
break;
}
pMipSet->dwDataSize = (nWidth * nHeight) * bytesPerChannel;
//----------------------------------------------------------------
// Allocate memory for the mip level 0
//----------------------------------------------------------------
if (!CMips.AllocateCompressedMipLevelData(pOutMipLevel, pMipSet->m_nWidth, pMipSet->m_nHeight, pMipSet->dwDataSize))
{
std::printf("Memory Error(1): allocating MIPSet compression level data buffer\n");
return CMP_ERR_MEM_ALLOC_FOR_MIPSET;
}
pMipSet->pData = pOutMipLevel->m_pbData;
return CMP_OK;
}
// Code duplication for all 3 functions to calc MSE & PSNR
// can reduce to typed templates
void CMP_calcMSE_PSNRb(MipLevel* pCurMipLevel, CMP_BYTE* pdata1, CMP_BYTE* pdata2, CMP_AnalysisData* pAnalysisData)
{
CMP_UINT RGBAChannels = pAnalysisData->channelBitMap;
CMP_DOUBLE mse;
CMP_DOUBLE mseR = 0.0;
CMP_DOUBLE mseG = 0.0;
CMP_DOUBLE mseB = 0.0;
CMP_DOUBLE mseA = 0.0;
CMP_DOUBLE mseRGBA = 0.0;
CMP_INT totalPixelsR = 0;
CMP_INT totalPixelsG = 0;
CMP_INT totalPixelsB = 0;
CMP_INT totalPixelsA = 0;
CMP_INT totalPixels = 0;
for (int y = 0; y < pCurMipLevel->m_nHeight; y++)
{
for (int x = 0; x < pCurMipLevel->m_nWidth; x++)
{
// calc Gamma for the all active channels
// Red channel
if (RGBAChannels & 0b0001)
{
mse = pow(abs(*pdata1 - *pdata2), 2);
mseR += mse;
mseRGBA += mse;
totalPixelsR++;
totalPixels++;
}
pdata1++;
pdata2++;
// Green channel
if (RGBAChannels & 0b0010)
{
mse = pow(abs(*pdata1 - *pdata2), 2);
mseG += mse;
mseRGBA += mse;
totalPixelsG++;
totalPixels++;
}
pdata1++;
pdata2++;
// Blue channel
if (RGBAChannels & 0b0100)
{
mse = pow(abs(*pdata1 - *pdata2), 2);
mseB += mse;
mseRGBA += mse;
totalPixelsB++;
totalPixels++;
}
pdata1++;
pdata2++;
// Alpha channel
if (RGBAChannels & 0b1000)
{
mse = pow(abs(*pdata1 - *pdata2), 2);
mseA += mse;
mseRGBA += mse;
totalPixelsA++;
totalPixels++;
}
pdata1++;
pdata2++;
}
}
if (totalPixels == 0)
{
totalPixels = 1;
}
pAnalysisData->mse = mseRGBA / totalPixels;
pAnalysisData->mseR = mseR / totalPixelsR;
pAnalysisData->mseG = mseG / totalPixelsG;
pAnalysisData->mseB = mseB / totalPixelsB;
pAnalysisData->mseA = mseA / totalPixelsA;
if (pAnalysisData->mse <= 0.0)
{
pAnalysisData->mse = 0.0;
pAnalysisData->mseR = 0.0;
pAnalysisData->mseG = 0.0;
pAnalysisData->mseB = 0.0;
pAnalysisData->mseA = 0.0;
pAnalysisData->psnr = 128;
pAnalysisData->psnrR = 128;
pAnalysisData->psnrG = 128;
pAnalysisData->psnrB = 128;
pAnalysisData->psnrA = 128;
}
else
{
if (pAnalysisData->mse > 0.0)
pAnalysisData->psnr = 10 * log((1.0 * 255 * 255) / pAnalysisData->mse) / log(10.0);
if (pAnalysisData->mseR > 0.0)
pAnalysisData->psnrR = 10 * log((1.0 * 255 * 255) / pAnalysisData->mseR) / log(10.0);
if (pAnalysisData->mseG > 0.0)
pAnalysisData->psnrG = 10 * log((1.0 * 255 * 255) / pAnalysisData->mseG) / log(10.0);
if (pAnalysisData->mseB > 0.0)
pAnalysisData->psnrB = 10 * log((1.0 * 255 * 255) / pAnalysisData->mseB) / log(10.0);
if (pAnalysisData->mseA > 0.0)
pAnalysisData->psnrA = 10 * log((1.0 * 255 * 255) / pAnalysisData->mseA) / log(10.0);
}
}
static CMP_FLOAT HalfShorttoFloat(CMP_HALFSHORT f)
{
CMP_HALF A;
A.setBits(f);
return ((CMP_FLOAT)A);
}
inline float clamp(float a, float l, float h)
{
return (a < l) ? l : ((a > h) ? h : a);
}
inline float knee(double x, double f)
{
return float(log(x * f + 1.f) / f);
}
static float cmp_findKneeValue(float x, float y)
{
float f0 = 0;
float f1 = 1.f;
while (knee(x, f1) > y)
{
f0 = f1;
f1 = f1 * 2.f;
}
for (int i = 0; i < 30; ++i)
{
const float f2 = (f0 + f1) / 2.f;
const float y2 = knee(x, f2);
if (y2 < y)
{
f1 = f2;
}
else
{
f0 = f2;
}
}
return (f0 + f1) / 2.f;
}
// This is the default convertion used for CT_Foat16 to CF_8Bit in Compressonators transcoding example. EXR to BC1..5,7
static CMP_BYTE HalfShorttoByteCMP(CMP_HALFSHORT halfdata, CMP_BOOL alpha, CMP_AnalysisData* pAnalysisData)
{
(alpha); // Unref for now
CMP_FLOAT fdata = HalfShorttoFloat(halfdata);
CMP_FLOAT fInputKneeHigh, fInputGamma;
if (pAnalysisData->fInputKneeHigh <= 0.0f)
fInputKneeHigh = 5.0f;
else
fInputKneeHigh = pAnalysisData->fInputKneeHigh;
float kl = powf(2.f, pAnalysisData->fInputKneeLow);
float f = cmp_findKneeValue(powf(2.f, fInputKneeHigh) - kl, powf(2.f, 3.5f) - kl);
float luminance3f = powf(2, -3.5); // always assume max intensity is 1 and 3.5f darker for scale later
if (pAnalysisData->fInputGamma == 0.0f)
fInputGamma = 2.2f;
else
fInputGamma = pAnalysisData->fInputGamma;
float invGamma = 1 / fInputGamma; //for gamma correction
float scale = 255.0f * powf(luminance3f, invGamma);
CMP_BYTE retb;
// 1) Compensate for fogging by subtracting defog from the raw pixel values.
if (pAnalysisData->fInputDefog > 0.0)
{
fdata = fdata - pAnalysisData->fInputDefog;
}
// 2) Multiply the defogged pixel values by 2^(exposure + 2.47393).
const float exposeScale = powf(2, pAnalysisData->fInputExposure + 2.47393f);
fdata = fdata * exposeScale;
// 3) Values that are now 1.0 are called "middle gray".
// If defog and exposure are both set to 0.0, then
// middle gray corresponds to a raw pixel value of 0.18.
// In step 6, middle gray values will be mapped to an
// intensity 3.5 f-stops below the display's maximum
// intensity.
// 4) Apply a knee function. The knee function has two
// parameters, kneeLow and kneeHigh. Pixel values
// below 2^kneeLow are not changed by the knee
// function. Pixel values above kneeLow are lowered
// according to a logarithmic curve, such that the
// value 2^kneeHigh is mapped to 2^3.5. (In step 6,
// this value will be mapped to the the display's
// maximum intensity.)
if (fdata > kl)
{
fdata = kl + knee(fdata - kl, f);
}
// 5) Gamma-correct the pixel values, according to the
// screen's gamma. (We assume that the gamma curve
// is a simple power function.)
fdata = powf(fdata, invGamma);
// 6) Scale the values such that middle gray pixels are
// mapped to a frame buffer value that is 3.5 f-stops
// below the display's maximum intensity.
fdata *= scale;
retb = (CMP_BYTE)clamp(fdata, 0.f, 255.f);
return (retb);
}
void CMP_calcMSE_PSNRHalfShort(MipLevel* pCurMipLevel, CMP_HALFSHORT* pdata1, CMP_HALFSHORT* pdata2, CMP_AnalysisData* pAnalysisData)
{
CMP_UINT RGBAChannels = pAnalysisData->channelBitMap;
CMP_DOUBLE mse;
CMP_DOUBLE mseR = 0.0;
CMP_DOUBLE mseG = 0.0;
CMP_DOUBLE mseB = 0.0;
CMP_DOUBLE mseA = 0.0;
CMP_DOUBLE mseRGBA = 0.0;
CMP_INT totalPixelsR = 0;
CMP_INT totalPixelsG = 0;
CMP_INT totalPixelsB = 0;
CMP_INT totalPixelsA = 0;
CMP_INT totalPixels = 0;
CMP_FLOAT pixf1;
CMP_FLOAT pixf2;
for (int y = 0; y < pCurMipLevel->m_nHeight; y++)
{
for (int x = 0; x < pCurMipLevel->m_nWidth; x++)
{
// calc Gamma for the all active channels
// Red channel
if (RGBAChannels & 0b0001)
{
pixf1 = HalfShorttoFloat(*pdata1); // convert short int to float
pixf2 = HalfShorttoFloat(*pdata2); // convert short int to float
mse = pow(abs(pixf1 - pixf2), 2);
mseR += mse;
mseRGBA += mse;
totalPixelsR++;
totalPixels++;
}
pdata1++;
pdata2++;
// Green channel
if (RGBAChannels & 0b0010)
{
pixf1 = HalfShorttoFloat(*pdata1); // convert short int to float
pixf2 = HalfShorttoFloat(*pdata2); // convert short int to float
mse = pow(abs(pixf1 - pixf2), 2);
mseG += mse;
mseRGBA += mse;
totalPixelsG++;
totalPixels++;
}
pdata1++;
pdata2++;
// Blue channel
if (RGBAChannels & 0b0100)
{
pixf1 = HalfShorttoFloat(*pdata1); // convert short int to float
pixf2 = HalfShorttoFloat(*pdata2); // convert short int to float
mse = pow(abs(pixf1 - pixf2), 2);
mseB += mse;
mseRGBA += mse;
totalPixelsB++;
totalPixels++;
}
pdata1++;
pdata2++;
// Alpha channel
if (RGBAChannels & 0b1000)
{
pixf1 = HalfShorttoFloat(*pdata1); // convert short int to float
pixf2 = HalfShorttoFloat(*pdata2); // convert short int to float
mse = pow(abs(pixf1 - pixf2), 2);
mseA += mse;
mseRGBA += mse;
totalPixelsA++;
totalPixels++;
}
pdata1++;
pdata2++;
}
}
if (totalPixels == 0)
{
totalPixels = 1;
}
pAnalysisData->mse = mseRGBA / totalPixels;
pAnalysisData->mseR = mseR / totalPixelsR;
pAnalysisData->mseG = mseG / totalPixelsG;
pAnalysisData->mseB = mseB / totalPixelsB;
pAnalysisData->mseA = mseA / totalPixelsA;
if (pAnalysisData->mse <= 0.0)
{
pAnalysisData->mse = 0.0;
pAnalysisData->mseR = 0.0;
pAnalysisData->mseG = 0.0;
pAnalysisData->mseB = 0.0;
pAnalysisData->mseA = 0.0;
pAnalysisData->psnr = 128;
pAnalysisData->psnrR = 128;
pAnalysisData->psnrG = 128;
pAnalysisData->psnrB = 128;
pAnalysisData->psnrA = 128;
}
else
{
if (pAnalysisData->mse > 0.0)
pAnalysisData->psnr = 10 * log((1.0 * 255 * 255) / pAnalysisData->mse) / log(10.0);
if (pAnalysisData->mseR > 0.0)
pAnalysisData->psnrR = 10 * log((1.0 * 255 * 255) / pAnalysisData->mseR) / log(10.0);
if (pAnalysisData->mseG > 0.0)
pAnalysisData->psnrG = 10 * log((1.0 * 255 * 255) / pAnalysisData->mseG) / log(10.0);
if (pAnalysisData->mseB > 0.0)
pAnalysisData->psnrB = 10 * log((1.0 * 255 * 255) / pAnalysisData->mseB) / log(10.0);
if (pAnalysisData->mseA > 0.0)
pAnalysisData->psnrA = 10 * log((1.0 * 255 * 255) / pAnalysisData->mseA) / log(10.0);
}
}
void CMP_calcMSE_PSNRHalfShortByte(MipLevel* pCurMipLevel, CMP_HALFSHORT* pdata1, CMP_BYTE* pdata2, CMP_AnalysisData* pAnalysisData)
{
CMP_UINT RGBAChannels = pAnalysisData->channelBitMap;
CMP_DOUBLE mse;
CMP_DOUBLE mseR = 0.0;
CMP_DOUBLE mseG = 0.0;
CMP_DOUBLE mseB = 0.0;
CMP_DOUBLE mseA = 0.0;
CMP_DOUBLE mseRGBA = 0.0;
CMP_INT totalPixelsR = 0;
CMP_INT totalPixelsG = 0;
CMP_INT totalPixelsB = 0;
CMP_INT totalPixelsA = 0;
CMP_INT totalPixels = 0;
CMP_BYTE pixf1;
CMP_BYTE pixf2;
for (int y = 0; y < pCurMipLevel->m_nHeight; y++)
{
for (int x = 0; x < pCurMipLevel->m_nWidth; x++)
{
// calc Gamma for the all active channels
// Red channel
if (RGBAChannels & 0b0001)
{
pixf1 = HalfShorttoByteCMP(*pdata1, false, pAnalysisData);
pixf2 = *pdata2;
mse = pow(abs(pixf1 - pixf2), 2);
mseR += mse;
mseRGBA += mse;
totalPixelsR++;
totalPixels++;
}
pdata1++;
pdata2++;
// Green channel
if (RGBAChannels & 0b0010)
{
pixf1 = HalfShorttoByteCMP(*pdata1, false, pAnalysisData);
pixf2 = *pdata2;
mse = pow(abs(pixf1 - pixf2), 2);
mseG += mse;
mseRGBA += mse;
totalPixelsG++;
totalPixels++;
}
pdata1++;
pdata2++;
// Blue channel
if (RGBAChannels & 0b0100)
{
pixf1 = HalfShorttoByteCMP(*pdata1, false, pAnalysisData);
pixf2 = *pdata2;
mse = pow(abs(pixf1 - pixf2), 2);
mseB += mse;
mseRGBA += mse;
totalPixelsB++;
totalPixels++;
}
pdata1++;
pdata2++;
// Alpha channel
if (RGBAChannels & 0b1000)
{
pixf1 = HalfShorttoByteCMP(*pdata1, true, pAnalysisData);
pixf2 = *pdata2;
mse = pow(abs(pixf1 - pixf2), 2);
mseA += mse;
mseRGBA += mse;
totalPixelsA++;
totalPixels++;
}
pdata1++;
pdata2++;
}
}
if (totalPixels == 0)
{
totalPixels = 1;
}
pAnalysisData->mse = mseRGBA / totalPixels;
pAnalysisData->mseR = mseR / totalPixelsR;
pAnalysisData->mseG = mseG / totalPixelsG;
pAnalysisData->mseB = mseB / totalPixelsB;
pAnalysisData->mseA = mseA / totalPixelsA;
if (pAnalysisData->mse <= 0.0)
{
pAnalysisData->mse = 0.0;
pAnalysisData->mseR = 0.0;
pAnalysisData->mseG = 0.0;
pAnalysisData->mseB = 0.0;
pAnalysisData->mseA = 0.0;
pAnalysisData->psnr = 128;
pAnalysisData->psnrR = 128;
pAnalysisData->psnrG = 128;
pAnalysisData->psnrB = 128;
pAnalysisData->psnrA = 128;
}
else
{
if (pAnalysisData->mse > 0.0)
pAnalysisData->psnr = 10 * log((1.0 * 255 * 255) / pAnalysisData->mse) / log(10.0);
if (pAnalysisData->mseR > 0.0)
pAnalysisData->psnrR = 10 * log((1.0 * 255 * 255) / pAnalysisData->mseR) / log(10.0);
if (pAnalysisData->mseG > 0.0)
pAnalysisData->psnrG = 10 * log((1.0 * 255 * 255) / pAnalysisData->mseG) / log(10.0);
if (pAnalysisData->mseB > 0.0)
pAnalysisData->psnrB = 10 * log((1.0 * 255 * 255) / pAnalysisData->mseB) / log(10.0);
if (pAnalysisData->mseA > 0.0)
pAnalysisData->psnrA = 10 * log((1.0 * 255 * 255) / pAnalysisData->mseA) / log(10.0);
}
}
void CMP_calcMSE_PSNRf32(MipLevel* pCurMipLevel, CMP_FLOAT* pdata1, CMP_FLOAT* pdata2, CMP_AnalysisData* pAnalysisData)
{
CMP_UINT RGBAChannels = pAnalysisData->channelBitMap;
CMP_DOUBLE mse;
CMP_DOUBLE mseR = 0.0;
CMP_DOUBLE mseG = 0.0;
CMP_DOUBLE mseB = 0.0;
CMP_DOUBLE mseA = 0.0;
CMP_DOUBLE mseRGBA = 0.0;
CMP_INT totalPixelsR = 0;
CMP_INT totalPixelsG = 0;
CMP_INT totalPixelsB = 0;
CMP_INT totalPixelsA = 0;
CMP_INT totalPixels = 0;
for (int y = 0; y < pCurMipLevel->m_nHeight; y++)
{
for (int x = 0; x < pCurMipLevel->m_nWidth; x++)
{
// calc Gamma for the all active channels
// Red channel
if (RGBAChannels & 0b0001)
{
mse = pow(abs(*pdata1 - *pdata2), 2);
mseR += mse;
mseRGBA += mse;
totalPixelsR++;
totalPixels++;
}
pdata1++;
pdata2++;
// Green channel
if (RGBAChannels & 0b0010)
{
mse = pow(abs(*pdata1 - *pdata2), 2);
mseG += mse;
mseRGBA += mse;
totalPixelsG++;
totalPixels++;
}
pdata1++;
pdata2++;
// Blue channel
if (RGBAChannels & 0b0100)
{
mse = pow(abs(*pdata1 - *pdata2), 2);
mseB += mse;
mseRGBA += mse;
totalPixelsB++;
totalPixels++;
}
pdata1++;
pdata2++;
// Alpha channel
if (RGBAChannels & 0b1000)
{
mse = pow(abs(*pdata1 - *pdata2), 2);
mseA += mse;
mseRGBA += mse;
totalPixelsA++;
totalPixels++;
}
pdata1++;
pdata2++;
}
}
if (totalPixels == 0)
{
totalPixels = 1;
}
pAnalysisData->mse = mseRGBA / totalPixels;
pAnalysisData->mseR = mseR / totalPixelsR;
pAnalysisData->mseG = mseG / totalPixelsG;
pAnalysisData->mseB = mseB / totalPixelsB;
pAnalysisData->mseA = mseA / totalPixelsA;
if (pAnalysisData->mse <= 0.0)
{
pAnalysisData->mse = 0.0;
pAnalysisData->mseR = 0.0;
pAnalysisData->mseG = 0.0;
pAnalysisData->mseB = 0.0;
pAnalysisData->mseA = 0.0;
pAnalysisData->psnr = 128;
pAnalysisData->psnrR = 128;
pAnalysisData->psnrG = 128;
pAnalysisData->psnrB = 128;
pAnalysisData->psnrA = 128;
}
else
{
if (pAnalysisData->mse > 0.0)
pAnalysisData->psnr = 10 * log((1.0 * 255 * 255) / pAnalysisData->mse) / log(10.0);
if (pAnalysisData->mseR > 0.0)
pAnalysisData->psnrR = 10 * log((1.0 * 255 * 255) / pAnalysisData->mseR) / log(10.0);
if (pAnalysisData->mseG > 0.0)
pAnalysisData->psnrG = 10 * log((1.0 * 255 * 255) / pAnalysisData->mseG) / log(10.0);
if (pAnalysisData->mseB > 0.0)
pAnalysisData->psnrB = 10 * log((1.0 * 255 * 255) / pAnalysisData->mseB) / log(10.0);
if (pAnalysisData->mseA > 0.0)
pAnalysisData->psnrA = 10 * log((1.0 * 255 * 255) / pAnalysisData->mseA) / log(10.0);
}
}
CMP_ERROR CMP_API CMP_MipSetAnlaysis(CMP_MipSet* src1, CMP_MipSet* src2, CMP_INT nMipLevel, CMP_INT nFaceOrSlice, CMP_AnalysisData* pAnalysisData)
{
if ((!src1) || (!src2))
return CMP_ERR_GENERIC;
// sanity checks
if (src1->m_nHeight != src2->m_nHeight)
return CMP_ERR_GENERIC;
CMIPS CMips;
MipLevel* pCurMipLevel1;
MipLevel* pCurMipLevel2;
pAnalysisData->mse = 0.0f;
pAnalysisData->psnr = 0.0f;
pCurMipLevel1 = CMips.GetMipLevel(src1, nMipLevel, nFaceOrSlice);
if (!pCurMipLevel1)
return CMP_ERR_INVALID_SOURCE_TEXTURE;
pCurMipLevel2 = CMips.GetMipLevel(src2, nMipLevel, nFaceOrSlice);
if (!pCurMipLevel2)
return CMP_ERR_INVALID_SOURCE_TEXTURE;
// processed only if both codecs have the same channel formats
if ((src1->m_ChannelFormat == CF_8bit) && (src2->m_ChannelFormat == CF_8bit))
CMP_calcMSE_PSNRb(pCurMipLevel1, pCurMipLevel1->m_pbData, pCurMipLevel2->m_pbData, pAnalysisData);
else if ((src1->m_ChannelFormat == CF_Float16) && (src2->m_ChannelFormat == CF_Float16))
CMP_calcMSE_PSNRHalfShort(pCurMipLevel1, pCurMipLevel1->m_phfsData, pCurMipLevel2->m_phfsData, pAnalysisData);
else if ((src1->m_ChannelFormat == CF_Float32) && (src2->m_ChannelFormat == CF_Float32))
CMP_calcMSE_PSNRf32(pCurMipLevel1, pCurMipLevel1->m_pfData, pCurMipLevel2->m_pfData, pAnalysisData);
else if ((src1->m_ChannelFormat == CF_Float16) && (src2->m_ChannelFormat == CF_8bit))
CMP_calcMSE_PSNRHalfShortByte(pCurMipLevel1, pCurMipLevel1->m_phfsData, pCurMipLevel2->m_pbData, pAnalysisData);
return CMP_OK;
}
CMP_INT CMP_MaxFacesOrSlices(const CMP_MipSet* pMipSet, CMP_INT nMipLevel)
{
if (!pMipSet)
return 0;
if (pMipSet->m_nDepth < 1)
return 0;
if (pMipSet->m_TextureType == TT_2D || pMipSet->m_TextureType == TT_CubeMap)
return pMipSet->m_nDepth;
int nMaxSlices = pMipSet->m_nDepth;
for (int i = 0; i < pMipSet->m_nMipLevels; i++)
{
if (i == nMipLevel)
return nMaxSlices;
nMaxSlices = nMaxSlices > 1 ? nMaxSlices >> 1 : 1; //div by 2, min of 1
}
return 0; //nMipLevel was too high
}
CMP_MipLevel* CMP_CMIPS::GetMipLevel(const CMP_MipSet* pMipSet, int nMipLevel, int nFaceOrSlice)
{
if (!pMipSet)
{
assert(pMipSet);
return NULL;
}
if (!pMipSet->m_pMipLevelTable)
{
return NULL;
}
if (nMipLevel > MAX_MIPLEVEL_SUPPORTED)
{
return NULL;
}
if (nMipLevel > pMipSet->m_nMaxMipLevels)
{
assert(nMipLevel <= pMipSet->m_nMaxMipLevels);
return NULL;
}
if (nFaceOrSlice < 0)
{
return NULL; //not an error, indicates requested face doesn't exist
}
int nDepth = pMipSet->m_nDepth, index = 0, whichMipLevel = 0;
switch (pMipSet->m_TextureType)
{
case TT_2D:
if (nFaceOrSlice != 0)
{
return NULL;
}
return (pMipSet->m_pMipLevelTable)[nMipLevel];
case TT_CubeMap:
if (nFaceOrSlice > 6)
{ //cubemap have at most 6 faces
assert(nFaceOrSlice > 6);
return NULL;
}
return (pMipSet->m_pMipLevelTable)[nMipLevel * nDepth + nFaceOrSlice];
case TT_VolumeTexture:
while (whichMipLevel <= nMipLevel)
{
if (whichMipLevel == nMipLevel)
{
return (pMipSet->m_pMipLevelTable)[index + nFaceOrSlice];
}
else
{
index += nDepth;
whichMipLevel++;
nDepth = nDepth > 1 ? nDepth >> 1 : 1;
}
}
return NULL;
default:
assert(0);
return NULL;
}
}
// Mip Levels are coded as follows
// 1 is original size 2 = 1/2 size 3 = 1/4 size etc...
// this value is based on arrays been MipMap[maxMipLevels]
int CMP_CMIPS::GetMaxMipLevels(int nWidth, int nHeight, int nDepth)
{
int maxMipLevels = 0;
assert(nWidth > 0 && nHeight > 0 && nDepth > 0);
while (nWidth >= 1 || nHeight >= 1 || nDepth > 1)
{
maxMipLevels++;
if (nWidth == 1 || nHeight == 1)
break;
//div by 2
nWidth = nWidth > 1 ? nWidth >> 1 : 1;
nHeight = nHeight > 1 ? nHeight >> 1 : 1;
nDepth = nDepth > 1 ? nDepth >> 1 : 1;
}
return maxMipLevels;
}
bool CMP_CMIPS::AllocateMipLevelTable(CMP_MipLevelTable** ppMipLevelTable, int nMaxMipLevels, CMP_TextureType textureType, int nDepth, int& nLevelsToAllocate)
{
//TODO test
assert(nDepth > 0);
nLevelsToAllocate = 0;
//determine # miplevels to allocate based on texture type
switch (textureType)
{
case TT_2D:
nLevelsToAllocate = nMaxMipLevels;
if (nDepth != 1)
{
return false;
}
break;
case TT_CubeMap:
if (nDepth > 6)
{
return false;
}
nLevelsToAllocate = nMaxMipLevels * nDepth;
break;
case TT_VolumeTexture:
for (int i = 0; i < nMaxMipLevels; i++)
{
nLevelsToAllocate += nDepth;
if (nDepth > 1)
{
nDepth >>= 1;
}
}
break;
default:
return false;
}
//allocate the mipLevelTable (buncha pointers to miplevels)
*ppMipLevelTable = reinterpret_cast<CMP_MipLevelTable*>(calloc(nLevelsToAllocate, sizeof(CMP_MipLevel*)));
assert(*ppMipLevelTable);
return (*ppMipLevelTable != NULL);
}
bool CMP_CMIPS::AllocateAllMipLevels(CMP_MipLevelTable* pMipLevelTable, CMP_TextureType /*textureType*/, int nLevelsToAllocate)
{
//TODO test
//allocate each MipLevel that the table points to
for (int i = 0; i < nLevelsToAllocate; i++)
{
pMipLevelTable[i] = reinterpret_cast<CMP_MipLevel*>(calloc(sizeof(CMP_MipLevel), 1));
//make sure it was allocated ok
assert(pMipLevelTable[i]);
if (!pMipLevelTable[i])
{
//free previous mipLevels
for (i -= 1; i >= 0; i--)
{
if (pMipLevelTable[i])
{
free(pMipLevelTable[i]);
pMipLevelTable[i] = NULL;
}
}
return false;
}
}
return true;
}
bool CMP_CMIPS::AllocateMipSet(CMP_MipSet* pMipSet,
CMP_ChannelFormat channelFormat,
TextureDataType textureDataType,
CMP_TextureType textureType,
int nWidth,
int nHeight,
int nDepth)
{
//TODO test
assert(pMipSet);
if (!(nWidth > 0 && nHeight > 0 && nDepth > 0))
return false;
if (pMipSet->m_pMipLevelTable)
{
assert(!pMipSet->m_pMipLevelTable);
return false;
}
//depth only matters for this when its volume texture
pMipSet->m_nMaxMipLevels = GetMaxMipLevels(nWidth, nHeight, textureType == TT_VolumeTexture ? nDepth : 1);
if (pMipSet->m_nMipLevels > pMipSet->m_nMaxMipLevels || pMipSet->m_nMipLevels < 0)
pMipSet->m_nMipLevels = 0;
pMipSet->m_ChannelFormat = channelFormat;
pMipSet->m_TextureDataType = textureDataType;
pMipSet->m_TextureType = textureType;
//Probably shouldn't wipe this out either pMipSet->m_Flags = MS_Default;
//On second thought, DONT wipe this out pMipSet->m_CubeFaceMask = 0;
pMipSet->m_nWidth = nWidth;
pMipSet->m_nHeight = nHeight;
pMipSet->m_nDepth = nDepth;
int numLevelsToAllocate;
if (!AllocateMipLevelTable(&pMipSet->m_pMipLevelTable, pMipSet->m_nMaxMipLevels, textureType, nDepth, numLevelsToAllocate))
{
//mipleveltable allocation failed
return false;
}
if (!AllocateAllMipLevels(pMipSet->m_pMipLevelTable, textureType, numLevelsToAllocate))
{
//allocation of mip levels failed
if (pMipSet->m_pMipLevelTable)
{
free(pMipSet->m_pMipLevelTable);
pMipSet->m_pMipLevelTable = NULL;
}
return false;
}
return true;
}
bool CMP_CMIPS::AllocateMipLevelData(CMP_MipLevel* pMipLevel, int nWidth, int nHeight, CMP_ChannelFormat channelFormat, TextureDataType textureDataType)
{
//TODO test
assert(pMipLevel);
assert(nWidth > 0 && nHeight > 0);
CMP_DWORD dwBitsPerPixel;
switch (channelFormat)
{
case CF_8bit:
case CF_2101010:
case CF_Float9995E:
dwBitsPerPixel = 8;
break;
case CF_16bit:
case CF_Float16:
dwBitsPerPixel = 16;
break;
case CF_32bit:
case CF_Float32:
dwBitsPerPixel = 32;
break;
default:
assert(0);
return false;
}
switch (textureDataType)
{
case TDT_XRGB:
case TDT_ARGB:
case TDT_NORMAL_MAP:
dwBitsPerPixel *= 4;
break;
case TDT_RGB:
dwBitsPerPixel *= 3;
break;
case TDT_RG:
dwBitsPerPixel *= 2;
break;
case TDT_R:
break;
default:
assert(0);
return false;
}
CMP_DWORD dwPitch = CMP_PAD_BYTE(nWidth, dwBitsPerPixel);
pMipLevel->m_dwLinearSize = dwPitch * nHeight;
pMipLevel->m_nWidth = nWidth;
pMipLevel->m_nHeight = nHeight;
pMipLevel->m_pbData = reinterpret_cast<CMP_BYTE*>(malloc(pMipLevel->m_dwLinearSize));
return (pMipLevel->m_pbData != NULL);
}
bool CMP_CMIPS::AllocateCompressedMipLevelData(CMP_MipLevel* pMipLevel, int nWidth, int nHeight, CMP_DWORD dwSize)
{
//TODO test
assert(pMipLevel);
assert(nWidth > 0 && nHeight > 0);
pMipLevel->m_dwLinearSize = dwSize;
pMipLevel->m_nWidth = nWidth;
pMipLevel->m_nHeight = nHeight;
pMipLevel->m_pbData = reinterpret_cast<CMP_BYTE*>(malloc(pMipLevel->m_dwLinearSize));
return (pMipLevel->m_pbData != NULL);
}
void CMP_CMIPS::FreeMipSet(CMP_MipSet* pMipSet)
{
//TODO test
int nTotalOldMipLevels = 0;
assert(pMipSet);
if (pMipSet)
{
if (pMipSet->m_pMipLevelTable)
{
//determine number of miplevels in the old mipleveltable
switch (pMipSet->m_TextureType)
{
case TT_2D:
nTotalOldMipLevels = pMipSet->m_nMaxMipLevels;
break;
case TT_CubeMap:
nTotalOldMipLevels = pMipSet->m_nMaxMipLevels * pMipSet->m_nDepth;
break;
case TT_VolumeTexture:
for (int depth = pMipSet->m_nDepth, mipLevels = 0; mipLevels < pMipSet->m_nMaxMipLevels; mipLevels++)
{
nTotalOldMipLevels += depth;
if (depth > 1)
{
depth >>= 1;
}
}
break;
default:
assert(0);
}
//free all miplevels and their data except the one use in gui view
for (int i = 0; i < nTotalOldMipLevels - 2; i++)
{
if (pMipSet->m_pMipLevelTable[i]->m_pbData)
{
#ifdef USE_BASIS
if (pMipSet->m_format == CMP_FORMAT_BASIS)
{
CMP_VEC8& basis_data = *(pMipSet->m_pMipLevelTable[i]->m_pvec8Data);
if (basis_data.size() > 0)
delete &basis_data;
}
else
#endif
free(pMipSet->m_pMipLevelTable[i]->m_pbData);
pMipSet->m_pMipLevelTable[i]->m_pbData = NULL;
}
if (pMipSet->m_pMipLevelTable[i])
{
free(pMipSet->m_pMipLevelTable[i]);
pMipSet->m_pMipLevelTable[i] = NULL;
}
}
free(pMipSet->m_pMipLevelTable);
pMipSet->m_pMipLevelTable = NULL;
pMipSet->m_nMaxMipLevels = 0;
pMipSet->m_nMipLevels = 0;
}
}
}
void CMP_CMIPS::FreeMipLevelData(CMP_MipLevel* pMipLevel)
{
if (pMipLevel->m_pbData)
{
free(pMipLevel->m_pbData);
pMipLevel->m_pbData = NULL;
}
}
bool CMP_CMIPS::AllocateCompressedDestBuffer(CMP_MipSet* SourceTexture, CMP_FORMAT format, CMP_MipSet* DestTexture)
{
CMP_MipLevel* pInMipLevel = GetMipLevel(SourceTexture, 0);
SourceTexture->dwWidth = pInMipLevel->m_nWidth;
SourceTexture->dwHeight = pInMipLevel->m_nHeight;
SourceTexture->dwDataSize = pInMipLevel->m_dwLinearSize;
SourceTexture->pData = pInMipLevel->m_pbData;
SourceTexture->m_swizzle = false;
memset(DestTexture, 0, sizeof(CMP_MipSet));
DestTexture->m_Flags = MS_FLAG_Default;
//----------------------------------------------------------------
// Allocate the compression buffer and miplevel tables
//----------------------------------------------------------------
DestTexture->m_nHeight = SourceTexture->m_nHeight;
DestTexture->m_nWidth = SourceTexture->m_nWidth;
DestTexture->dwWidth = pInMipLevel->m_nWidth;
DestTexture->dwHeight = pInMipLevel->m_nHeight;
DestTexture->m_ChannelFormat = CF_Compressed;
DestTexture->m_format = format;
DestTexture->m_dwFourCC = CMP_MIPS_FOURCC_DX10;
DestTexture->m_nBlockHeight = 4;
DestTexture->m_nBlockWidth = 4;
DestTexture->m_nMaxMipLevels = SourceTexture->m_nMaxMipLevels;
DestTexture->m_nMipLevels = 1;
DestTexture->m_nDepth = SourceTexture->m_nDepth;
if (DestTexture->m_nDepth < 1)
DestTexture->m_nDepth = 1; // depthsupport on compressed data ?
if (!AllocateMipSet(DestTexture, CF_8bit, TDT_ARGB, TT_2D, SourceTexture->m_nWidth, SourceTexture->m_nHeight, 1))
{
// std::printf("Memory Error(1): allocating MIPSet Compression buffer\n");
return false;
}
//----------------------------------------------------------------
// Access the data table for mip level 0 (full texture width and height)
//----------------------------------------------------------------
CMP_MipLevel* pOutMipLevel = GetMipLevel(DestTexture, 0);
//----------------------------------------------------------------
// Calculate the target compressed block buffer size (4 bytes x 4 bytes)
//----------------------------------------------------------------
unsigned int Width = ((SourceTexture->m_nWidth + 3) / 4) * 4;
unsigned int Height = ((SourceTexture->m_nHeight + 3) / 4) * 4;
DestTexture->dwDataSize = Width * Height;
//----------------------------------------------------------------
// Allocate memory for the mip level 0
//----------------------------------------------------------------
if (!AllocateCompressedMipLevelData(pOutMipLevel, DestTexture->dwWidth, DestTexture->dwHeight, DestTexture->dwDataSize))
{
//std::printf("Memory Error(1): allocating MIPSet compression level data buffer\n");
return false;
}
DestTexture->pData = pOutMipLevel->m_pbData;
return true;
}
void CMP_CMIPS::SetProgress(unsigned int value)
{
if (SetProgressValue)
{
SetProgressValue(value, &m_canceled);
}
}
Reference in New Issue View Git Blame Copy Permalink