ATOM-16320 Remove PVRTC and ETC compressor (#4557)
Signed-off-by: Qing Tao <qingtao@amazon.com>monroegm-disable-blank-issue-2
Qing Tao
4 years ago
committed by
GitHub
parent
2496bc38b5
commit
e64b9d3536
@ -1,233 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) Contributors to the Open 3D Engine Project.
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#include <Atom/ImageProcessing/ImageObject.h>
|
||||
#include <Processing/PixelFormatInfo.h>
|
||||
#include <Processing/ImageFlags.h>
|
||||
#include <Converters/PixelOperation.h>
|
||||
#include <Compressors/ETC2.h>
|
||||
|
||||
#include <EtcConfig.h>
|
||||
#include <Etc.h>
|
||||
#include <EtcImage.h>
|
||||
#include <EtcColorFloatRGBA.h>
|
||||
|
||||
namespace ImageProcessingAtom
|
||||
{
|
||||
//limited to 1 thread because AP requires so. We may change to n when AP allocate n thread to a job in the furture
|
||||
static const int MAX_COMP_JOBS = 1;
|
||||
static const int MIN_COMP_JOBS = 1;
|
||||
static const float ETC_LOW_EFFORT_LEVEL = 25.0f;
|
||||
static const float ETC_MED_EFFORT_LEVEL = 40.0f;
|
||||
static const float ETC_HIGH_EFFORT_LEVEL = 80.0f;
|
||||
|
||||
//Grab the Etc2Comp specific pixel format enum
|
||||
static Etc::Image::Format FindEtc2PixelFormat(EPixelFormat fmt)
|
||||
{
|
||||
switch (fmt)
|
||||
{
|
||||
case ePixelFormat_EAC_RG11:
|
||||
return Etc::Image::Format::RG11;
|
||||
case ePixelFormat_EAC_R11:
|
||||
return Etc::Image::Format::R11;
|
||||
case ePixelFormat_ETC2:
|
||||
return Etc::Image::Format::RGB8;
|
||||
case ePixelFormat_ETC2a1:
|
||||
return Etc::Image::Format::RGB8A1;
|
||||
case ePixelFormat_ETC2a:
|
||||
return Etc::Image::Format::RGBA8;
|
||||
default:
|
||||
return Etc::Image::Format::FORMATS;
|
||||
}
|
||||
}
|
||||
|
||||
//Get the errmetric required for the compression
|
||||
static Etc::ErrorMetric FindErrMetric(Etc::Image::Format fmt)
|
||||
{
|
||||
switch (fmt)
|
||||
{
|
||||
case Etc::Image::Format::RG11:
|
||||
return Etc::ErrorMetric::NORMALXYZ;
|
||||
case Etc::Image::Format::R11:
|
||||
return Etc::ErrorMetric::NUMERIC;
|
||||
case Etc::Image::Format::RGB8:
|
||||
return Etc::ErrorMetric::RGBX;
|
||||
case Etc::Image::Format::RGBA8:
|
||||
case Etc::Image::Format::RGB8A1:
|
||||
return Etc::ErrorMetric::RGBA;
|
||||
default:
|
||||
return Etc::ErrorMetric::ERROR_METRICS;
|
||||
}
|
||||
}
|
||||
|
||||
//Convert to sRGB format
|
||||
static Etc::Image::Format FindGammaEtc2PixelFormat(Etc::Image::Format fmt)
|
||||
{
|
||||
switch (fmt)
|
||||
{
|
||||
case Etc::Image::Format::RGB8:
|
||||
return Etc::Image::Format::SRGB8;
|
||||
case Etc::Image::Format::RGBA8:
|
||||
return Etc::Image::Format::SRGBA8;
|
||||
case Etc::Image::Format::RGB8A1:
|
||||
return Etc::Image::Format::SRGB8A1;
|
||||
default:
|
||||
return Etc::Image::Format::FORMATS;
|
||||
}
|
||||
}
|
||||
|
||||
bool ETC2Compressor::IsCompressedPixelFormatSupported(EPixelFormat fmt)
|
||||
{
|
||||
return (FindEtc2PixelFormat(fmt) != Etc::Image::Format::FORMATS);
|
||||
}
|
||||
|
||||
bool ETC2Compressor::IsUncompressedPixelFormatSupported(EPixelFormat fmt)
|
||||
{
|
||||
//for uncompress format
|
||||
if (fmt == ePixelFormat_R8G8B8A8)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
EPixelFormat ETC2Compressor::GetSuggestedUncompressedFormat([[maybe_unused]] EPixelFormat compressedfmt, [[maybe_unused]] EPixelFormat uncompressedfmt) const
|
||||
{
|
||||
return ePixelFormat_R8G8B8A8;
|
||||
}
|
||||
|
||||
bool ETC2Compressor::DoesSupportDecompress([[maybe_unused]] EPixelFormat fmtDst)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
ColorSpace ETC2Compressor::GetSupportedColorSpace([[maybe_unused]] EPixelFormat compressFormat) const
|
||||
{
|
||||
return ColorSpace::autoSelect;
|
||||
}
|
||||
|
||||
const char* ETC2Compressor::GetName() const
|
||||
{
|
||||
return "ETC2Compressor";
|
||||
}
|
||||
|
||||
IImageObjectPtr ETC2Compressor::CompressImage(IImageObjectPtr srcImage, EPixelFormat fmtDst,
|
||||
const CompressOption* compressOption) const
|
||||
{
|
||||
//validate input
|
||||
EPixelFormat fmtSrc = srcImage->GetPixelFormat();
|
||||
|
||||
//src format need to be uncompressed and dst format need to compressed.
|
||||
if (!IsUncompressedPixelFormatSupported(fmtSrc) || !IsCompressedPixelFormatSupported(fmtDst))
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
IImageObjectPtr dstImage(srcImage->AllocateImage(fmtDst));
|
||||
|
||||
//determinate compression quality
|
||||
ICompressor::EQuality quality = ICompressor::eQuality_Normal;
|
||||
//get setting from compression option
|
||||
if (compressOption)
|
||||
{
|
||||
quality = compressOption->compressQuality;
|
||||
}
|
||||
|
||||
float qualityEffort = 0.0f;
|
||||
switch (quality)
|
||||
{
|
||||
case eQuality_Preview:
|
||||
case eQuality_Fast:
|
||||
{
|
||||
qualityEffort = ETC_LOW_EFFORT_LEVEL;
|
||||
break;
|
||||
}
|
||||
case eQuality_Normal:
|
||||
{
|
||||
qualityEffort = ETC_MED_EFFORT_LEVEL;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
{
|
||||
qualityEffort = ETC_HIGH_EFFORT_LEVEL;
|
||||
}
|
||||
}
|
||||
|
||||
Etc::Image::Format dstEtc2Format = FindEtc2PixelFormat(fmtDst);
|
||||
if (srcImage->GetImageFlags() & EIF_SRGBRead)
|
||||
{
|
||||
dstEtc2Format = FindGammaEtc2PixelFormat(dstEtc2Format);
|
||||
}
|
||||
|
||||
//use to read pixel data from src image
|
||||
IPixelOperationPtr pixelOp = CreatePixelOperation(fmtSrc);
|
||||
//get count of bytes per pixel for images
|
||||
AZ::u32 pixelBytes = CPixelFormats::GetInstance().GetPixelFormatInfo(fmtSrc)->bitsPerBlock / 8;
|
||||
|
||||
const AZ::u32 mipCount = dstImage->GetMipCount();
|
||||
for (AZ::u32 mip = 0; mip < mipCount; ++mip)
|
||||
{
|
||||
const AZ::u32 width = srcImage->GetWidth(mip);
|
||||
const AZ::u32 height = srcImage->GetHeight(mip);
|
||||
|
||||
// Prepare source data
|
||||
AZ::u8* srcMem;
|
||||
AZ::u32 srcPitch;
|
||||
srcImage->GetImagePointer(mip, srcMem, srcPitch);
|
||||
const AZ::u32 pixelCount = srcImage->GetPixelCount(mip);
|
||||
|
||||
Etc::ColorFloatRGBA* rgbaPixels = new Etc::ColorFloatRGBA[pixelCount];
|
||||
Etc::ColorFloatRGBA* rgbaPixelPtr = rgbaPixels;
|
||||
float r, g, b, a;
|
||||
for (AZ::u32 pixelIdx = 0; pixelIdx < pixelCount; pixelIdx++, srcMem += pixelBytes, rgbaPixelPtr++)
|
||||
{
|
||||
pixelOp->GetRGBA(srcMem, r, g, b, a);
|
||||
rgbaPixelPtr->fA = a;
|
||||
rgbaPixelPtr->fR = r;
|
||||
rgbaPixelPtr->fG = g;
|
||||
rgbaPixelPtr->fB = b;
|
||||
}
|
||||
|
||||
//Call into etc2Comp lib to compress. https://medium.com/@duhroach/building-a-blazing-fast-etc2-compressor-307f3e9aad99
|
||||
Etc::ErrorMetric errMetric = FindErrMetric(dstEtc2Format);
|
||||
unsigned char* paucEncodingBits;
|
||||
unsigned int uiEncodingBitsBytes;
|
||||
unsigned int uiExtendedWidth;
|
||||
unsigned int uiExtendedHeight;
|
||||
int iEncodingTime_ms;
|
||||
|
||||
Etc::Encode(reinterpret_cast<float*>(rgbaPixels),
|
||||
width, height,
|
||||
dstEtc2Format,
|
||||
errMetric,
|
||||
qualityEffort,
|
||||
MIN_COMP_JOBS,
|
||||
MAX_COMP_JOBS,
|
||||
&paucEncodingBits, &uiEncodingBitsBytes,
|
||||
&uiExtendedWidth, &uiExtendedHeight,
|
||||
&iEncodingTime_ms);
|
||||
|
||||
AZ::u8* dstMem;
|
||||
AZ::u32 dstPitch;
|
||||
dstImage->GetImagePointer(mip, dstMem, dstPitch);
|
||||
|
||||
memcpy(dstMem, paucEncodingBits, uiEncodingBitsBytes);
|
||||
delete[] rgbaPixels;
|
||||
}
|
||||
|
||||
return dstImage;
|
||||
}
|
||||
|
||||
IImageObjectPtr ETC2Compressor::DecompressImage(IImageObjectPtr srcImage, [[maybe_unused]] EPixelFormat fmtDst) const
|
||||
{
|
||||
//etc2Comp doesn't support decompression
|
||||
//Since PVRTexLib support ETC formats too. It may take over the decompression.
|
||||
return nullptr;
|
||||
}
|
||||
} // namespace ImageProcessingAtom
|
||||
@ -1,31 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) Contributors to the Open 3D Engine Project.
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <Compressors/Compressor.h>
|
||||
|
||||
namespace ImageProcessingAtom
|
||||
{
|
||||
class ETC2Compressor
|
||||
: public ICompressor
|
||||
{
|
||||
public:
|
||||
static bool IsCompressedPixelFormatSupported(EPixelFormat fmt);
|
||||
static bool IsUncompressedPixelFormatSupported(EPixelFormat fmt);
|
||||
static bool DoesSupportDecompress(EPixelFormat fmtDst);
|
||||
|
||||
IImageObjectPtr CompressImage(IImageObjectPtr srcImage, EPixelFormat fmtDst, const CompressOption* compressOption) const override;
|
||||
IImageObjectPtr DecompressImage(IImageObjectPtr srcImage, EPixelFormat fmtDst) const override;
|
||||
|
||||
EPixelFormat GetSuggestedUncompressedFormat(EPixelFormat compressedfmt, EPixelFormat uncompressedfmt) const override;
|
||||
ColorSpace GetSupportedColorSpace(EPixelFormat compressFormat) const final;
|
||||
const char* GetName() const final;
|
||||
|
||||
};
|
||||
} // namespace ImageProcessingAtom
|
||||
@ -1,338 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) Contributors to the Open 3D Engine Project.
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#include <ImageProcessing_Traits_Platform.h>
|
||||
#include <AzCore/PlatformIncl.h>
|
||||
#include <Atom/ImageProcessing/ImageObject.h>
|
||||
#include <Processing/ImageFlags.h>
|
||||
#include <Processing/PixelFormatInfo.h>
|
||||
#include <Compressors/PVRTC.h>
|
||||
|
||||
#include <PVRTexture.h>
|
||||
#include <PVRTextureUtilities.h>
|
||||
|
||||
|
||||
namespace ImageProcessingAtom
|
||||
{
|
||||
// Note: PVRTexLib supports ETC formats, PVRTC formats and BC formats
|
||||
// We haven't tested the performace to compress BC formats compare to CTSquisher
|
||||
// For PVRTC formats, we only added PVRTC 1 support for now
|
||||
// The compression for ePVRTPF_EAC_R11 and ePVRTPF_EAC_RG11 are very slow. It takes 7 and 14 minutes for a 2048x2048 texture.
|
||||
EPVRTPixelFormat FindPvrPixelFormat(EPixelFormat fmt)
|
||||
{
|
||||
switch (fmt)
|
||||
{
|
||||
case ePixelFormat_PVRTC2:
|
||||
return ePVRTPF_PVRTCI_2bpp_RGBA;
|
||||
case ePixelFormat_PVRTC4:
|
||||
return ePVRTPF_PVRTCI_4bpp_RGBA;
|
||||
case ePixelFormat_EAC_R11:
|
||||
return ePVRTPF_EAC_R11;
|
||||
case ePixelFormat_EAC_RG11:
|
||||
return ePVRTPF_EAC_RG11;
|
||||
case ePixelFormat_ETC2:
|
||||
return ePVRTPF_ETC2_RGB;
|
||||
case ePixelFormat_ETC2a1:
|
||||
return ePVRTPF_ETC2_RGB_A1;
|
||||
case ePixelFormat_ETC2a:
|
||||
return ePVRTPF_ETC2_RGBA;
|
||||
default:
|
||||
return ePVRTPF_NumCompressedPFs;
|
||||
}
|
||||
}
|
||||
|
||||
bool PVRTCCompressor::IsCompressedPixelFormatSupported(EPixelFormat fmt)
|
||||
{
|
||||
return (FindPvrPixelFormat(fmt) != ePVRTPF_NumCompressedPFs);
|
||||
}
|
||||
|
||||
bool PVRTCCompressor::IsUncompressedPixelFormatSupported(EPixelFormat fmt)
|
||||
{
|
||||
//for uncompress format
|
||||
if (fmt == ePixelFormat_R8G8B8A8)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
EPixelFormat PVRTCCompressor::GetSuggestedUncompressedFormat([[maybe_unused]] EPixelFormat compressedfmt, [[maybe_unused]] EPixelFormat uncompressedfmt) const
|
||||
{
|
||||
return ePixelFormat_R8G8B8A8;
|
||||
}
|
||||
|
||||
ColorSpace PVRTCCompressor::GetSupportedColorSpace([[maybe_unused]] EPixelFormat compressFormat) const
|
||||
{
|
||||
return ColorSpace::autoSelect;
|
||||
}
|
||||
|
||||
const char* PVRTCCompressor::GetName() const
|
||||
{
|
||||
return "PVRTCCompressor";
|
||||
}
|
||||
|
||||
bool PVRTCCompressor::DoesSupportDecompress([[maybe_unused]] EPixelFormat fmtDst)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
IImageObjectPtr PVRTCCompressor::CompressImage(IImageObjectPtr srcImage, EPixelFormat fmtDst,
|
||||
const CompressOption* compressOption) const
|
||||
{
|
||||
//validate input
|
||||
EPixelFormat fmtSrc = srcImage->GetPixelFormat();
|
||||
|
||||
//src format need to be uncompressed and dst format need to compressed.
|
||||
if (!IsUncompressedPixelFormatSupported(fmtSrc) || !IsCompressedPixelFormatSupported(fmtDst))
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
IImageObjectPtr dstImage(srcImage->AllocateImage(fmtDst));
|
||||
|
||||
//determinate compression quality
|
||||
pvrtexture::ECompressorQuality internalQuality = pvrtexture::eETCFast;
|
||||
ICompressor::EQuality quality = ICompressor::eQuality_Normal;
|
||||
AZ::Vector3 uniformWeights = AZ::Vector3(0.3333f, 0.3334f, 0.3333f);
|
||||
AZ::Vector3 weights = uniformWeights;
|
||||
bool isUniform = true;
|
||||
//get setting from compression option
|
||||
if (compressOption)
|
||||
{
|
||||
quality = compressOption->compressQuality;
|
||||
weights = compressOption->rgbWeight;
|
||||
isUniform = (weights == uniformWeights);
|
||||
}
|
||||
|
||||
if (IsETCFormat(fmtDst))
|
||||
{
|
||||
if ((quality <= eQuality_Normal) && isUniform)
|
||||
{
|
||||
internalQuality = pvrtexture::eETCFast;
|
||||
}
|
||||
else if (quality <= eQuality_Normal)
|
||||
{
|
||||
internalQuality = pvrtexture::eETCNormal;
|
||||
}
|
||||
else if (isUniform)
|
||||
{
|
||||
internalQuality = pvrtexture::eETCSlow;
|
||||
}
|
||||
else
|
||||
{
|
||||
internalQuality = pvrtexture::eETCSlow;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (quality == eQuality_Preview)
|
||||
{
|
||||
internalQuality = pvrtexture::ePVRTCFastest;
|
||||
}
|
||||
else if (quality == eQuality_Fast)
|
||||
{
|
||||
internalQuality = pvrtexture::ePVRTCFast;
|
||||
}
|
||||
else if (quality == eQuality_Normal)
|
||||
{
|
||||
internalQuality = pvrtexture::ePVRTCNormal;
|
||||
}
|
||||
else
|
||||
{
|
||||
internalQuality = pvrtexture::ePVRTCHigh;
|
||||
}
|
||||
}
|
||||
|
||||
// setup color space
|
||||
EPVRTColourSpace cspace = ePVRTCSpacelRGB;
|
||||
if (srcImage->GetImageFlags() & EIF_SRGBRead)
|
||||
{
|
||||
cspace = ePVRTCSpacesRGB;
|
||||
}
|
||||
|
||||
//setup src texture for compression
|
||||
const pvrtexture::PixelType srcPixelType('r', 'g', 'b', 'a', 8, 8, 8, 8);
|
||||
const AZ::u32 dstMips = dstImage->GetMipCount();
|
||||
for (AZ::u32 mip = 0; mip < dstMips; ++mip)
|
||||
{
|
||||
const AZ::u32 width = srcImage->GetWidth(mip);
|
||||
const AZ::u32 height = srcImage->GetHeight(mip);
|
||||
|
||||
// Prepare source data
|
||||
AZ::u8* srcMem;
|
||||
uint32 srcPitch;
|
||||
srcImage->GetImagePointer(mip, srcMem, srcPitch);
|
||||
|
||||
const pvrtexture::CPVRTextureHeader srcHeader(
|
||||
srcPixelType.PixelTypeID, // AZ::u64 u64PixelFormat,
|
||||
width, // uint32 u32Height=1,
|
||||
height, // uint32 u32Width=1,
|
||||
1, // uint32 u32Depth=1,
|
||||
1, // uint32 u32NumMipMaps=1,
|
||||
1, // uint32 u32NumArrayMembers=1,
|
||||
1, // uint32 u32NumFaces=1,
|
||||
cspace, // EPVRTColourSpace eColourSpace=ePVRTCSpacelRGB,
|
||||
ePVRTVarTypeUnsignedByteNorm, // EPVRTVariableType eChannelType=ePVRTVarTypeUnsignedByteNorm,
|
||||
false); // bool bPreMultiplied=false);
|
||||
|
||||
pvrtexture::CPVRTexture compressTexture(srcHeader, srcMem);
|
||||
|
||||
//compressing
|
||||
bool isSuccess = false;
|
||||
#if AZ_TRAIT_IMAGEPROCESSING_SUPPORT_TRY_CATCH
|
||||
try
|
||||
#endif // AZ_TRAIT_IMAGEPROCESSING_SUPPORT_TRY_CATCH
|
||||
{
|
||||
isSuccess = pvrtexture::Transcode(
|
||||
compressTexture,
|
||||
pvrtexture::PixelType(FindPvrPixelFormat(fmtDst)),
|
||||
ePVRTVarTypeUnsignedByteNorm,
|
||||
cspace,
|
||||
internalQuality);
|
||||
}
|
||||
#if AZ_TRAIT_IMAGEPROCESSING_SUPPORT_TRY_CATCH
|
||||
catch (...)
|
||||
{
|
||||
AZ_Error("Image Processing", false, "Unknown exception in PVRTexLib");
|
||||
return nullptr;
|
||||
}
|
||||
#endif // AZ_TRAIT_IMAGEPROCESSING_SUPPORT_TRY_CATCH
|
||||
|
||||
if (!isSuccess)
|
||||
{
|
||||
AZ_Error("Image Processing", false, "Failed to compress image with PVRTexLib.");
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// Getting compressed data
|
||||
const void* const compressedData = compressTexture.getDataPtr();
|
||||
if (!compressedData)
|
||||
{
|
||||
AZ_Error("Image Processing", false, "Failed to obtain compressed image data by using PVRTexLib");
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
const AZ::u32 compressedDataSize = compressTexture.getDataSize();
|
||||
if (dstImage->GetMipBufSize(mip) != compressedDataSize)
|
||||
{
|
||||
AZ_Error("Image Processing", false, "Compressed image data size mismatch while using PVRTexLib");
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
//save compressed data to dst image
|
||||
AZ::u8* dstMem;
|
||||
AZ::u32 dstPitch;
|
||||
dstImage->GetImagePointer(mip, dstMem, dstPitch);
|
||||
memcpy(dstMem, compressedData, compressedDataSize);
|
||||
}
|
||||
|
||||
return dstImage;
|
||||
}
|
||||
|
||||
IImageObjectPtr PVRTCCompressor::DecompressImage(IImageObjectPtr srcImage, EPixelFormat fmtDst) const
|
||||
{
|
||||
//validate input
|
||||
EPixelFormat fmtSrc = srcImage->GetPixelFormat(); //compressed
|
||||
|
||||
if (!IsCompressedPixelFormatSupported(fmtSrc) || !IsUncompressedPixelFormatSupported(fmtDst))
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
EPVRTColourSpace colorSpace = ePVRTCSpacelRGB;
|
||||
if (srcImage->GetImageFlags() & EIF_SRGBRead)
|
||||
{
|
||||
colorSpace = ePVRTCSpacesRGB;
|
||||
}
|
||||
|
||||
IImageObjectPtr dstImage(srcImage->AllocateImage(fmtDst));
|
||||
|
||||
const AZ::u32 mipCount = dstImage->GetMipCount();
|
||||
for (AZ::u32 mip = 0; mip < mipCount; ++mip)
|
||||
{
|
||||
const AZ::u32 width = srcImage->GetWidth(mip);
|
||||
const AZ::u32 height = srcImage->GetHeight(mip);
|
||||
|
||||
// Preparing source compressed data
|
||||
const pvrtexture::CPVRTextureHeader compressedHeader(
|
||||
FindPvrPixelFormat(fmtSrc), // AZ::u64 u64PixelFormat,
|
||||
width, // uint32 u32Height=1,
|
||||
height, // uint32 u32Width=1,
|
||||
1, // uint32 u32Depth=1,
|
||||
1, // uint32 u32NumMipMaps=1,
|
||||
1, // uint32 u32NumArrayMembers=1,
|
||||
1, // uint32 u32NumFaces=1,
|
||||
colorSpace, // EPVRTColourSpace eColourSpace=ePVRTCSpacelRGB,
|
||||
ePVRTVarTypeUnsignedByteNorm, // EPVRTVariableType eChannelType=ePVRTVarTypeUnsignedByteNorm,
|
||||
false); // bool bPreMultiplied=false);
|
||||
|
||||
const AZ::u32 compressedDataSize = compressedHeader.getDataSize();
|
||||
if (srcImage->GetMipBufSize(mip) != compressedDataSize)
|
||||
{
|
||||
AZ_Error("Image Processing", false, "Decompressed image data size mismatch while using PVRTexLib");
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
AZ::u8* srcMem;
|
||||
AZ::u32 srcPitch;
|
||||
srcImage->GetImagePointer(mip, srcMem, srcPitch);
|
||||
pvrtexture::CPVRTexture cTexture(compressedHeader, srcMem);
|
||||
|
||||
// Decompress
|
||||
bool bOk = false;
|
||||
#if AZ_TRAIT_IMAGEPROCESSING_SUPPORT_TRY_CATCH
|
||||
try
|
||||
{
|
||||
#endif // AZ_TRAIT_IMAGEPROCESSING_SUPPORT_TRY_CATCH
|
||||
bOk = pvrtexture::Transcode(
|
||||
cTexture,
|
||||
pvrtexture::PVRStandard8PixelType,
|
||||
ePVRTVarTypeUnsignedByteNorm,
|
||||
colorSpace,
|
||||
pvrtexture::ePVRTCHigh);
|
||||
|
||||
#if AZ_TRAIT_IMAGEPROCESSING_SUPPORT_TRY_CATCH
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
AZ_Error("Image Processing", false, "Unknown exception in PVRTexLib when decompressing");
|
||||
return nullptr;
|
||||
}
|
||||
#endif // AZ_TRAIT_IMAGEPROCESSING_SUPPORT_TRY_CATCH
|
||||
|
||||
if (!bOk)
|
||||
{
|
||||
AZ_Error("Image Processing", false, "Failed to decompress an image by using PVRTexLib");
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// Getting decompressed data
|
||||
const void* const pDecompressedData = cTexture.getDataPtr();
|
||||
if (!pDecompressedData)
|
||||
{
|
||||
AZ_Error("Image Processing", false, "Failed to obtain decompressed image data by using PVRTexLib");
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
const AZ::u32 decompressedDataSize = cTexture.getDataSize();
|
||||
if (dstImage->GetMipBufSize(mip) != decompressedDataSize)
|
||||
{
|
||||
AZ_Error("Image Processing", false, "Decompressed image data size mismatch while using PVRTexLib");
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
//save decompressed image to dst image
|
||||
AZ::u8* dstMem;
|
||||
AZ::u32 dstPitch;
|
||||
dstImage->GetImagePointer(mip, dstMem, dstPitch);
|
||||
memcpy(dstMem, pDecompressedData, decompressedDataSize);
|
||||
}
|
||||
|
||||
return dstImage;
|
||||
}
|
||||
} //namespace ImageProcessingAtom
|
||||
@ -1,30 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) Contributors to the Open 3D Engine Project.
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <Compressors/Compressor.h>
|
||||
|
||||
namespace ImageProcessingAtom
|
||||
{
|
||||
class PVRTCCompressor
|
||||
: public ICompressor
|
||||
{
|
||||
public:
|
||||
static bool IsCompressedPixelFormatSupported(EPixelFormat fmt);
|
||||
static bool IsUncompressedPixelFormatSupported(EPixelFormat fmt);
|
||||
static bool DoesSupportDecompress(EPixelFormat fmtDst);
|
||||
|
||||
IImageObjectPtr CompressImage(IImageObjectPtr srcImage, EPixelFormat fmtDst, const CompressOption* compressOption) const override;
|
||||
IImageObjectPtr DecompressImage(IImageObjectPtr srcImage, EPixelFormat fmtDst) const override;
|
||||
|
||||
EPixelFormat GetSuggestedUncompressedFormat(EPixelFormat compressedfmt, EPixelFormat uncompressedfmt) const override;
|
||||
ColorSpace GetSupportedColorSpace(EPixelFormat compressFormat) const final;
|
||||
const char* GetName() const final;
|
||||
};
|
||||
} // namespace ImageProcessingAtom
|
||||
Loading…
Reference in New Issue