Integrate bug fixes from trunk.
This commit is contained in:
parent
e8bb3f2886
commit
6e1a87129f
|
@ -1,5 +1,7 @@
|
||||||
NVIDIA Texture Tools version 2.0.3
|
NVIDIA Texture Tools version 2.0.3
|
||||||
* More accurate DXT3 compressor. Fixes issue 38.
|
* More accurate DXT3 compressor. Fixes issue 38.
|
||||||
|
* Remove legacy compressors. Fix issue 34.
|
||||||
|
* Check for single color in all compressors. Fixes issue 43.
|
||||||
* Fix error in fast downsample filter, reported by Noel Llopis.
|
* Fix error in fast downsample filter, reported by Noel Llopis.
|
||||||
|
|
||||||
NVIDIA Texture Tools version 2.0.2
|
NVIDIA Texture Tools version 2.0.2
|
||||||
|
|
|
@ -13,10 +13,10 @@ SET(NVTT_SRCS
|
||||||
CompressDXT.cpp
|
CompressDXT.cpp
|
||||||
CompressRGB.h
|
CompressRGB.h
|
||||||
CompressRGB.cpp
|
CompressRGB.cpp
|
||||||
FastCompressDXT.h
|
|
||||||
FastCompressDXT.cpp
|
|
||||||
QuickCompressDXT.h
|
QuickCompressDXT.h
|
||||||
QuickCompressDXT.cpp
|
QuickCompressDXT.cpp
|
||||||
|
OptimalCompressDXT.h
|
||||||
|
OptimalCompressDXT.cpp
|
||||||
SingleColorLookup.h
|
SingleColorLookup.h
|
||||||
CompressionOptions.h
|
CompressionOptions.h
|
||||||
CompressionOptions.cpp
|
CompressionOptions.cpp
|
||||||
|
|
|
@ -29,8 +29,8 @@
|
||||||
|
|
||||||
#include "nvtt.h"
|
#include "nvtt.h"
|
||||||
#include "CompressDXT.h"
|
#include "CompressDXT.h"
|
||||||
#include "FastCompressDXT.h"
|
|
||||||
#include "QuickCompressDXT.h"
|
#include "QuickCompressDXT.h"
|
||||||
|
#include "OptimalCompressDXT.h"
|
||||||
#include "CompressionOptions.h"
|
#include "CompressionOptions.h"
|
||||||
#include "OutputOptions.h"
|
#include "OutputOptions.h"
|
||||||
|
|
||||||
|
@ -57,26 +57,33 @@ using namespace nv;
|
||||||
using namespace nvtt;
|
using namespace nvtt;
|
||||||
|
|
||||||
|
|
||||||
void nv::fastCompressDXT1(const Image * image, const OutputOptions::Private & outputOptions)
|
nv::FastCompressor::FastCompressor() : m_image(NULL), m_alphaMode(AlphaMode_None)
|
||||||
{
|
{
|
||||||
const uint w = image->width();
|
}
|
||||||
const uint h = image->height();
|
|
||||||
|
nv::FastCompressor::~FastCompressor()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
void nv::FastCompressor::setImage(const Image * image, nvtt::AlphaMode alphaMode)
|
||||||
|
{
|
||||||
|
m_image = image;
|
||||||
|
m_alphaMode = alphaMode;
|
||||||
|
}
|
||||||
|
|
||||||
|
void nv::FastCompressor::compressDXT1(const OutputOptions::Private & outputOptions)
|
||||||
|
{
|
||||||
|
const uint w = m_image->width();
|
||||||
|
const uint h = m_image->height();
|
||||||
|
|
||||||
ColorBlock rgba;
|
ColorBlock rgba;
|
||||||
BlockDXT1 block;
|
BlockDXT1 block;
|
||||||
|
|
||||||
for (uint y = 0; y < h; y += 4) {
|
for (uint y = 0; y < h; y += 4) {
|
||||||
for (uint x = 0; x < w; x += 4) {
|
for (uint x = 0; x < w; x += 4) {
|
||||||
rgba.init(image, x, y);
|
rgba.init(m_image, x, y);
|
||||||
|
|
||||||
if (rgba.isSingleColor())
|
|
||||||
{
|
|
||||||
QuickCompress::compressDXT1(rgba.color(0), &block);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
QuickCompress::compressDXT1(rgba, &block);
|
QuickCompress::compressDXT1(rgba, &block);
|
||||||
}
|
|
||||||
|
|
||||||
if (outputOptions.outputHandler != NULL) {
|
if (outputOptions.outputHandler != NULL) {
|
||||||
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
||||||
|
@ -86,27 +93,19 @@ void nv::fastCompressDXT1(const Image * image, const OutputOptions::Private & ou
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
void nv::fastCompressDXT1a(const Image * image, const OutputOptions::Private & outputOptions)
|
void nv::FastCompressor::compressDXT1a(const OutputOptions::Private & outputOptions)
|
||||||
{
|
{
|
||||||
const uint w = image->width();
|
const uint w = m_image->width();
|
||||||
const uint h = image->height();
|
const uint h = m_image->height();
|
||||||
|
|
||||||
ColorBlock rgba;
|
ColorBlock rgba;
|
||||||
BlockDXT1 block;
|
BlockDXT1 block;
|
||||||
|
|
||||||
for (uint y = 0; y < h; y += 4) {
|
for (uint y = 0; y < h; y += 4) {
|
||||||
for (uint x = 0; x < w; x += 4) {
|
for (uint x = 0; x < w; x += 4) {
|
||||||
rgba.init(image, x, y);
|
rgba.init(m_image, x, y);
|
||||||
|
|
||||||
// @@ We could do better here: check for single RGB, but varying alpha.
|
|
||||||
if (rgba.isSingleColor())
|
|
||||||
{
|
|
||||||
QuickCompress::compressDXT1a(rgba.color(0), &block);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
QuickCompress::compressDXT1a(rgba, &block);
|
QuickCompress::compressDXT1a(rgba, &block);
|
||||||
}
|
|
||||||
|
|
||||||
if (outputOptions.outputHandler != NULL) {
|
if (outputOptions.outputHandler != NULL) {
|
||||||
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
||||||
|
@ -116,17 +115,18 @@ void nv::fastCompressDXT1a(const Image * image, const OutputOptions::Private & o
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
void nv::fastCompressDXT3(const Image * image, const nvtt::OutputOptions::Private & outputOptions)
|
void nv::FastCompressor::compressDXT3(const nvtt::OutputOptions::Private & outputOptions)
|
||||||
{
|
{
|
||||||
const uint w = image->width();
|
const uint w = m_image->width();
|
||||||
const uint h = image->height();
|
const uint h = m_image->height();
|
||||||
|
|
||||||
ColorBlock rgba;
|
ColorBlock rgba;
|
||||||
BlockDXT3 block;
|
BlockDXT3 block;
|
||||||
|
|
||||||
for (uint y = 0; y < h; y += 4) {
|
for (uint y = 0; y < h; y += 4) {
|
||||||
for (uint x = 0; x < w; x += 4) {
|
for (uint x = 0; x < w; x += 4) {
|
||||||
rgba.init(image, x, y);
|
rgba.init(m_image, x, y);
|
||||||
|
|
||||||
QuickCompress::compressDXT3(rgba, &block);
|
QuickCompress::compressDXT3(rgba, &block);
|
||||||
|
|
||||||
if (outputOptions.outputHandler != NULL) {
|
if (outputOptions.outputHandler != NULL) {
|
||||||
|
@ -137,19 +137,19 @@ void nv::fastCompressDXT3(const Image * image, const nvtt::OutputOptions::Privat
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
void nv::fastCompressDXT5(const Image * image, const nvtt::OutputOptions::Private & outputOptions)
|
void nv::FastCompressor::compressDXT5(const nvtt::OutputOptions::Private & outputOptions)
|
||||||
{
|
{
|
||||||
const uint w = image->width();
|
const uint w = m_image->width();
|
||||||
const uint h = image->height();
|
const uint h = m_image->height();
|
||||||
|
|
||||||
ColorBlock rgba;
|
ColorBlock rgba;
|
||||||
BlockDXT5 block;
|
BlockDXT5 block;
|
||||||
|
|
||||||
for (uint y = 0; y < h; y += 4) {
|
for (uint y = 0; y < h; y += 4) {
|
||||||
for (uint x = 0; x < w; x += 4) {
|
for (uint x = 0; x < w; x += 4) {
|
||||||
rgba.init(image, x, y);
|
rgba.init(m_image, x, y);
|
||||||
//QuickCompress::compressDXT5(rgba, &block); // @@ Use fast version!!
|
|
||||||
nv::compressBlock_BoundsRange(rgba, &block);
|
QuickCompress::compressDXT5(rgba, &block, 0);
|
||||||
|
|
||||||
if (outputOptions.outputHandler != NULL) {
|
if (outputOptions.outputHandler != NULL) {
|
||||||
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
||||||
|
@ -159,23 +159,21 @@ void nv::fastCompressDXT5(const Image * image, const nvtt::OutputOptions::Privat
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
void nv::fastCompressDXT5n(const Image * image, const nvtt::OutputOptions::Private & outputOptions)
|
void nv::FastCompressor::compressDXT5n(const nvtt::OutputOptions::Private & outputOptions)
|
||||||
{
|
{
|
||||||
const uint w = image->width();
|
const uint w = m_image->width();
|
||||||
const uint h = image->height();
|
const uint h = m_image->height();
|
||||||
|
|
||||||
ColorBlock rgba;
|
ColorBlock rgba;
|
||||||
BlockDXT5 block;
|
BlockDXT5 block;
|
||||||
|
|
||||||
for (uint y = 0; y < h; y += 4) {
|
for (uint y = 0; y < h; y += 4) {
|
||||||
for (uint x = 0; x < w; x += 4) {
|
for (uint x = 0; x < w; x += 4) {
|
||||||
rgba.init(image, x, y);
|
rgba.init(m_image, x, y);
|
||||||
|
|
||||||
// copy X coordinate to alpha channel and Y coordinate to green channel.
|
|
||||||
rgba.swizzleDXT5n();
|
rgba.swizzleDXT5n();
|
||||||
|
|
||||||
//QuickCompress::compressDXT5(rgba, &block); // @@ Use fast version!!
|
QuickCompress::compressDXT5(rgba, &block, 0);
|
||||||
nv::compressBlock_BoundsRange(rgba, &block);
|
|
||||||
|
|
||||||
if (outputOptions.outputHandler != NULL) {
|
if (outputOptions.outputHandler != NULL) {
|
||||||
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
||||||
|
@ -185,42 +183,28 @@ void nv::fastCompressDXT5n(const Image * image, const nvtt::OutputOptions::Priva
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
void nv::fastCompressBC4(const Image * image, const nvtt::OutputOptions::Private & outputOptions)
|
nv::SlowCompressor::SlowCompressor() : m_image(NULL), m_alphaMode(AlphaMode_None)
|
||||||
{
|
{
|
||||||
// @@ TODO
|
|
||||||
// compress red channel (X)
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
nv::SlowCompressor::~SlowCompressor()
|
||||||
void nv::fastCompressBC5(const Image * image, const nvtt::OutputOptions::Private & outputOptions)
|
|
||||||
{
|
{
|
||||||
// @@ TODO
|
|
||||||
// compress red, green channels (X,Y)
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void nv::SlowCompressor::setImage(const Image * image, nvtt::AlphaMode alphaMode)
|
||||||
void nv::doPrecomputation()
|
|
||||||
{
|
{
|
||||||
static bool done = false; // @@ Stop using statics for reentrancy. Although the worst that could happen is that this stuff is precomputed multiple times.
|
m_image = image;
|
||||||
|
m_alphaMode = alphaMode;
|
||||||
if (!done)
|
|
||||||
{
|
|
||||||
done = true;
|
|
||||||
squish::FastClusterFit::DoPrecomputation();
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void nv::SlowCompressor::compressDXT1(const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions)
|
||||||
void nv::compressDXT1(const Image * image, const OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions)
|
|
||||||
{
|
{
|
||||||
const uint w = image->width();
|
const uint w = m_image->width();
|
||||||
const uint h = image->height();
|
const uint h = m_image->height();
|
||||||
|
|
||||||
ColorBlock rgba;
|
ColorBlock rgba;
|
||||||
BlockDXT1 block;
|
BlockDXT1 block;
|
||||||
|
|
||||||
doPrecomputation();
|
|
||||||
|
|
||||||
//squish::WeightedClusterFit fit;
|
//squish::WeightedClusterFit fit;
|
||||||
//squish::ClusterFit fit;
|
//squish::ClusterFit fit;
|
||||||
squish::FastClusterFit fit;
|
squish::FastClusterFit fit;
|
||||||
|
@ -229,11 +213,11 @@ void nv::compressDXT1(const Image * image, const OutputOptions::Private & output
|
||||||
for (uint y = 0; y < h; y += 4) {
|
for (uint y = 0; y < h; y += 4) {
|
||||||
for (uint x = 0; x < w; x += 4) {
|
for (uint x = 0; x < w; x += 4) {
|
||||||
|
|
||||||
rgba.init(image, x, y);
|
rgba.init(m_image, x, y);
|
||||||
|
|
||||||
if (rgba.isSingleColor())
|
if (rgba.isSingleColor())
|
||||||
{
|
{
|
||||||
QuickCompress::compressDXT1(rgba.color(0), &block);
|
OptimalCompress::compressDXT1(rgba.color(0), &block);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
@ -250,10 +234,10 @@ void nv::compressDXT1(const Image * image, const OutputOptions::Private & output
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
void nv::compressDXT1a(const Image * image, const OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions)
|
void nv::SlowCompressor::compressDXT1a(const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions)
|
||||||
{
|
{
|
||||||
const uint w = image->width();
|
const uint w = m_image->width();
|
||||||
const uint h = image->height();
|
const uint h = m_image->height();
|
||||||
|
|
||||||
ColorBlock rgba;
|
ColorBlock rgba;
|
||||||
BlockDXT1 block;
|
BlockDXT1 block;
|
||||||
|
@ -264,11 +248,20 @@ void nv::compressDXT1a(const Image * image, const OutputOptions::Private & outpu
|
||||||
for (uint y = 0; y < h; y += 4) {
|
for (uint y = 0; y < h; y += 4) {
|
||||||
for (uint x = 0; x < w; x += 4) {
|
for (uint x = 0; x < w; x += 4) {
|
||||||
|
|
||||||
rgba.init(image, x, y);
|
rgba.init(m_image, x, y);
|
||||||
|
|
||||||
if (rgba.isSingleColor())
|
bool anyAlpha = false;
|
||||||
|
bool allAlpha = true;
|
||||||
|
|
||||||
|
for (uint i = 0; i < 16; i++)
|
||||||
{
|
{
|
||||||
QuickCompress::compressDXT1a(rgba.color(0), &block);
|
if (rgba.color(i).a < 128) anyAlpha = true;
|
||||||
|
else allAlpha = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if ((!anyAlpha && rgba.isSingleColor() || allAlpha))
|
||||||
|
{
|
||||||
|
OptimalCompress::compressDXT1a(rgba.color(0), &block);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
@ -285,29 +278,37 @@ void nv::compressDXT1a(const Image * image, const OutputOptions::Private & outpu
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
void nv::compressDXT3(const Image * image, const OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions)
|
void nv::SlowCompressor::compressDXT3(const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions)
|
||||||
{
|
{
|
||||||
const uint w = image->width();
|
const uint w = m_image->width();
|
||||||
const uint h = image->height();
|
const uint h = m_image->height();
|
||||||
|
|
||||||
ColorBlock rgba;
|
ColorBlock rgba;
|
||||||
BlockDXT3 block;
|
BlockDXT3 block;
|
||||||
|
|
||||||
squish::WeightedClusterFit fit;
|
squish::WeightedClusterFit fit;
|
||||||
|
//squish::FastClusterFit fit;
|
||||||
fit.SetMetric(compressionOptions.colorWeight.x(), compressionOptions.colorWeight.y(), compressionOptions.colorWeight.z());
|
fit.SetMetric(compressionOptions.colorWeight.x(), compressionOptions.colorWeight.y(), compressionOptions.colorWeight.z());
|
||||||
|
|
||||||
for (uint y = 0; y < h; y += 4) {
|
for (uint y = 0; y < h; y += 4) {
|
||||||
for (uint x = 0; x < w; x += 4) {
|
for (uint x = 0; x < w; x += 4) {
|
||||||
|
|
||||||
rgba.init(image, x, y);
|
rgba.init(m_image, x, y);
|
||||||
|
|
||||||
// Compress explicit alpha.
|
// Compress explicit alpha.
|
||||||
QuickCompress::compressDXT3A(rgba, &block.alpha);
|
OptimalCompress::compressDXT3A(rgba, &block.alpha);
|
||||||
|
|
||||||
// Compress color.
|
// Compress color.
|
||||||
|
if (rgba.isSingleColor())
|
||||||
|
{
|
||||||
|
OptimalCompress::compressDXT1(rgba.color(0), &block.color);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
squish::ColourSet colours((uint8 *)rgba.colors(), squish::kWeightColourByAlpha);
|
squish::ColourSet colours((uint8 *)rgba.colors(), squish::kWeightColourByAlpha);
|
||||||
fit.SetColourSet(&colours, 0);
|
fit.SetColourSet(&colours, 0);
|
||||||
fit.Compress(&block.color);
|
fit.Compress(&block.color);
|
||||||
|
}
|
||||||
|
|
||||||
if (outputOptions.outputHandler != NULL) {
|
if (outputOptions.outputHandler != NULL) {
|
||||||
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
||||||
|
@ -316,10 +317,10 @@ void nv::compressDXT3(const Image * image, const OutputOptions::Private & output
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void nv::compressDXT5(const Image * image, const OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions)
|
void nv::SlowCompressor::compressDXT5(const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions)
|
||||||
{
|
{
|
||||||
const uint w = image->width();
|
const uint w = m_image->width();
|
||||||
const uint h = image->height();
|
const uint h = m_image->height();
|
||||||
|
|
||||||
ColorBlock rgba;
|
ColorBlock rgba;
|
||||||
BlockDXT5 block;
|
BlockDXT5 block;
|
||||||
|
@ -330,12 +331,12 @@ void nv::compressDXT5(const Image * image, const OutputOptions::Private & output
|
||||||
for (uint y = 0; y < h; y += 4) {
|
for (uint y = 0; y < h; y += 4) {
|
||||||
for (uint x = 0; x < w; x += 4) {
|
for (uint x = 0; x < w; x += 4) {
|
||||||
|
|
||||||
rgba.init(image, x, y);
|
rgba.init(m_image, x, y);
|
||||||
|
|
||||||
// Compress alpha.
|
// Compress alpha.
|
||||||
if (compressionOptions.quality == Quality_Highest)
|
if (compressionOptions.quality == Quality_Highest)
|
||||||
{
|
{
|
||||||
compressBlock_BruteForce(rgba, &block.alpha);
|
OptimalCompress::compressDXT5A(rgba, &block.alpha);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
@ -343,9 +344,16 @@ void nv::compressDXT5(const Image * image, const OutputOptions::Private & output
|
||||||
}
|
}
|
||||||
|
|
||||||
// Compress color.
|
// Compress color.
|
||||||
|
if (rgba.isSingleColor())
|
||||||
|
{
|
||||||
|
OptimalCompress::compressDXT1(rgba.color(0), &block.color);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
squish::ColourSet colours((uint8 *)rgba.colors(), squish::kWeightColourByAlpha);
|
squish::ColourSet colours((uint8 *)rgba.colors(), squish::kWeightColourByAlpha);
|
||||||
fit.SetColourSet(&colours, 0);
|
fit.SetColourSet(&colours, 0);
|
||||||
fit.Compress(&block.color);
|
fit.Compress(&block.color);
|
||||||
|
}
|
||||||
|
|
||||||
if (outputOptions.outputHandler != NULL) {
|
if (outputOptions.outputHandler != NULL) {
|
||||||
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
||||||
|
@ -355,28 +363,25 @@ void nv::compressDXT5(const Image * image, const OutputOptions::Private & output
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
void nv::compressDXT5n(const Image * image, const OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions)
|
void nv::SlowCompressor::compressDXT5n(const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions)
|
||||||
{
|
{
|
||||||
const uint w = image->width();
|
const uint w = m_image->width();
|
||||||
const uint h = image->height();
|
const uint h = m_image->height();
|
||||||
|
|
||||||
ColorBlock rgba;
|
ColorBlock rgba;
|
||||||
BlockDXT5 block;
|
BlockDXT5 block;
|
||||||
|
|
||||||
doPrecomputation();
|
|
||||||
|
|
||||||
for (uint y = 0; y < h; y += 4) {
|
for (uint y = 0; y < h; y += 4) {
|
||||||
for (uint x = 0; x < w; x += 4) {
|
for (uint x = 0; x < w; x += 4) {
|
||||||
|
|
||||||
rgba.init(image, x, y);
|
rgba.init(m_image, x, y);
|
||||||
|
|
||||||
// copy X coordinate to green channel and Y coordinate to alpha channel.
|
|
||||||
rgba.swizzleDXT5n();
|
rgba.swizzleDXT5n();
|
||||||
|
|
||||||
// Compress X.
|
// Compress X.
|
||||||
if (compressionOptions.quality == Quality_Highest)
|
if (compressionOptions.quality == Quality_Highest)
|
||||||
{
|
{
|
||||||
compressBlock_BruteForce(rgba, &block.alpha);
|
OptimalCompress::compressDXT5A(rgba, &block.alpha);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
@ -384,7 +389,7 @@ void nv::compressDXT5n(const Image * image, const OutputOptions::Private & outpu
|
||||||
}
|
}
|
||||||
|
|
||||||
// Compress Y.
|
// Compress Y.
|
||||||
QuickCompress::compressDXT1G(rgba, &block.color);
|
OptimalCompress::compressDXT1G(rgba, &block.color);
|
||||||
|
|
||||||
if (outputOptions.outputHandler != NULL) {
|
if (outputOptions.outputHandler != NULL) {
|
||||||
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
||||||
|
@ -394,10 +399,10 @@ void nv::compressDXT5n(const Image * image, const OutputOptions::Private & outpu
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
void nv::compressBC4(const Image * image, const nvtt::OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions)
|
void nv::SlowCompressor::compressBC4(const CompressionOptions::Private & compressionOptions, const nvtt::OutputOptions::Private & outputOptions)
|
||||||
{
|
{
|
||||||
const uint w = image->width();
|
const uint w = m_image->width();
|
||||||
const uint h = image->height();
|
const uint h = m_image->height();
|
||||||
|
|
||||||
ColorBlock rgba;
|
ColorBlock rgba;
|
||||||
AlphaBlockDXT5 block;
|
AlphaBlockDXT5 block;
|
||||||
|
@ -405,11 +410,11 @@ void nv::compressBC4(const Image * image, const nvtt::OutputOptions::Private & o
|
||||||
for (uint y = 0; y < h; y += 4) {
|
for (uint y = 0; y < h; y += 4) {
|
||||||
for (uint x = 0; x < w; x += 4) {
|
for (uint x = 0; x < w; x += 4) {
|
||||||
|
|
||||||
rgba.init(image, x, y);
|
rgba.init(m_image, x, y);
|
||||||
|
|
||||||
if (compressionOptions.quality == Quality_Highest)
|
if (compressionOptions.quality == Quality_Highest)
|
||||||
{
|
{
|
||||||
compressBlock_BruteForce(rgba, &block);
|
OptimalCompress::compressDXT5A(rgba, &block);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
@ -424,10 +429,10 @@ void nv::compressBC4(const Image * image, const nvtt::OutputOptions::Private & o
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
void nv::compressBC5(const Image * image, const nvtt::OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions)
|
void nv::SlowCompressor::compressBC5(const CompressionOptions::Private & compressionOptions, const nvtt::OutputOptions::Private & outputOptions)
|
||||||
{
|
{
|
||||||
const uint w = image->width();
|
const uint w = m_image->width();
|
||||||
const uint h = image->height();
|
const uint h = m_image->height();
|
||||||
|
|
||||||
ColorBlock xcolor;
|
ColorBlock xcolor;
|
||||||
ColorBlock ycolor;
|
ColorBlock ycolor;
|
||||||
|
@ -437,16 +442,16 @@ void nv::compressBC5(const Image * image, const nvtt::OutputOptions::Private & o
|
||||||
for (uint y = 0; y < h; y += 4) {
|
for (uint y = 0; y < h; y += 4) {
|
||||||
for (uint x = 0; x < w; x += 4) {
|
for (uint x = 0; x < w; x += 4) {
|
||||||
|
|
||||||
xcolor.init(image, x, y);
|
xcolor.init(m_image, x, y);
|
||||||
xcolor.splatX();
|
xcolor.splatX();
|
||||||
|
|
||||||
ycolor.init(image, x, y);
|
ycolor.init(m_image, x, y);
|
||||||
ycolor.splatY();
|
ycolor.splatY();
|
||||||
|
|
||||||
if (compressionOptions.quality == Quality_Highest)
|
if (compressionOptions.quality == Quality_Highest)
|
||||||
{
|
{
|
||||||
compressBlock_BruteForce(xcolor, &block.x);
|
OptimalCompress::compressDXT5A(xcolor, &block.x);
|
||||||
compressBlock_BruteForce(ycolor, &block.y);
|
OptimalCompress::compressDXT5A(ycolor, &block.y);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
|
|
@ -32,25 +32,45 @@ namespace nv
|
||||||
class Image;
|
class Image;
|
||||||
class FloatImage;
|
class FloatImage;
|
||||||
|
|
||||||
void doPrecomputation();
|
class FastCompressor
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
FastCompressor();
|
||||||
|
~FastCompressor();
|
||||||
|
|
||||||
// Fast compressors.
|
void setImage(const Image * image, nvtt::AlphaMode alphaMode);
|
||||||
void fastCompressDXT1(const Image * image, const nvtt::OutputOptions::Private & outputOptions);
|
|
||||||
void fastCompressDXT1a(const Image * image, const nvtt::OutputOptions::Private & outputOptions);
|
|
||||||
void fastCompressDXT3(const Image * image, const nvtt::OutputOptions::Private & outputOptions);
|
|
||||||
void fastCompressDXT5(const Image * image, const nvtt::OutputOptions::Private & outputOptions);
|
|
||||||
void fastCompressDXT5n(const Image * image, const nvtt::OutputOptions::Private & outputOptions);
|
|
||||||
void fastCompressBC4(const Image * image, const nvtt::OutputOptions::Private & outputOptions);
|
|
||||||
void fastCompressBC5(const Image * image, const nvtt::OutputOptions::Private & outputOptions);
|
|
||||||
|
|
||||||
// Normal compressors.
|
void compressDXT1(const nvtt::OutputOptions::Private & outputOptions);
|
||||||
void compressDXT1(const Image * image, const nvtt::OutputOptions::Private & outputOptions, const nvtt::CompressionOptions::Private & compressionOptions);
|
void compressDXT1a(const nvtt::OutputOptions::Private & outputOptions);
|
||||||
void compressDXT1a(const Image * image, const nvtt::OutputOptions::Private & outputOptions, const nvtt::CompressionOptions::Private & compressionOptions);
|
void compressDXT3(const nvtt::OutputOptions::Private & outputOptions);
|
||||||
void compressDXT3(const Image * image, const nvtt::OutputOptions::Private & outputOptions, const nvtt::CompressionOptions::Private & compressionOptions);
|
void compressDXT5(const nvtt::OutputOptions::Private & outputOptions);
|
||||||
void compressDXT5(const Image * image, const nvtt::OutputOptions::Private & outputOptions, const nvtt::CompressionOptions::Private & compressionOptions);
|
void compressDXT5n(const nvtt::OutputOptions::Private & outputOptions);
|
||||||
void compressDXT5n(const Image * image, const nvtt::OutputOptions::Private & outputOptions, const nvtt::CompressionOptions::Private & compressionOptions);
|
|
||||||
void compressBC4(const Image * image, const nvtt::OutputOptions::Private & outputOptions, const nvtt::CompressionOptions::Private & compressionOptions);
|
private:
|
||||||
void compressBC5(const Image * image, const nvtt::OutputOptions::Private & outputOptions, const nvtt::CompressionOptions::Private & compressionOptions);
|
const Image * m_image;
|
||||||
|
nvtt::AlphaMode m_alphaMode;
|
||||||
|
};
|
||||||
|
|
||||||
|
class SlowCompressor
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
SlowCompressor();
|
||||||
|
~SlowCompressor();
|
||||||
|
|
||||||
|
void setImage(const Image * image, nvtt::AlphaMode alphaMode);
|
||||||
|
|
||||||
|
void compressDXT1(const nvtt::CompressionOptions::Private & compressionOptions, const nvtt::OutputOptions::Private & outputOptions);
|
||||||
|
void compressDXT1a(const nvtt::CompressionOptions::Private & compressionOptions, const nvtt::OutputOptions::Private & outputOptions);
|
||||||
|
void compressDXT3(const nvtt::CompressionOptions::Private & compressionOptions, const nvtt::OutputOptions::Private & outputOptions);
|
||||||
|
void compressDXT5(const nvtt::CompressionOptions::Private & compressionOptions, const nvtt::OutputOptions::Private & outputOptions);
|
||||||
|
void compressDXT5n(const nvtt::CompressionOptions::Private & compressionOptions, const nvtt::OutputOptions::Private & outputOptions);
|
||||||
|
void compressBC4(const nvtt::CompressionOptions::Private & compressionOptions, const nvtt::OutputOptions::Private & outputOptions);
|
||||||
|
void compressBC5(const nvtt::CompressionOptions::Private & compressionOptions, const nvtt::OutputOptions::Private & outputOptions);
|
||||||
|
|
||||||
|
private:
|
||||||
|
const Image * m_image;
|
||||||
|
nvtt::AlphaMode m_alphaMode;
|
||||||
|
};
|
||||||
|
|
||||||
// External compressors.
|
// External compressors.
|
||||||
#if defined(HAVE_S3QUANT)
|
#if defined(HAVE_S3QUANT)
|
||||||
|
|
|
@ -41,7 +41,6 @@
|
||||||
#include "OutputOptions.h"
|
#include "OutputOptions.h"
|
||||||
|
|
||||||
#include "CompressDXT.h"
|
#include "CompressDXT.h"
|
||||||
#include "FastCompressDXT.h"
|
|
||||||
#include "CompressRGB.h"
|
#include "CompressRGB.h"
|
||||||
#include "cuda/CudaUtils.h"
|
#include "cuda/CudaUtils.h"
|
||||||
#include "cuda/CudaCompressDXT.h"
|
#include "cuda/CudaCompressDXT.h"
|
||||||
|
@ -200,7 +199,7 @@ namespace nvtt
|
||||||
AutoPtr<FloatImage> m_floatImage;
|
AutoPtr<FloatImage> m_floatImage;
|
||||||
};
|
};
|
||||||
|
|
||||||
}
|
} // nvtt namespace
|
||||||
|
|
||||||
|
|
||||||
Compressor::Compressor() : m(*new Compressor::Private())
|
Compressor::Compressor() : m(*new Compressor::Private())
|
||||||
|
@ -422,7 +421,7 @@ bool Compressor::Private::compressMipmaps(uint f, const InputOptions::Private &
|
||||||
|
|
||||||
quantizeMipmap(mipmap, compressionOptions);
|
quantizeMipmap(mipmap, compressionOptions);
|
||||||
|
|
||||||
compressMipmap(mipmap, compressionOptions, outputOptions);
|
compressMipmap(mipmap, inputOptions, compressionOptions, outputOptions);
|
||||||
|
|
||||||
// Compute extents of next mipmap:
|
// Compute extents of next mipmap:
|
||||||
w = max(1U, w / 2);
|
w = max(1U, w / 2);
|
||||||
|
@ -654,12 +653,18 @@ void Compressor::Private::quantizeMipmap(Mipmap & mipmap, const CompressionOptio
|
||||||
|
|
||||||
|
|
||||||
// Compress the given mipmap.
|
// Compress the given mipmap.
|
||||||
bool Compressor::Private::compressMipmap(const Mipmap & mipmap, const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions) const
|
bool Compressor::Private::compressMipmap(const Mipmap & mipmap, const InputOptions::Private & inputOptions, const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions) const
|
||||||
{
|
{
|
||||||
const Image * image = mipmap.asFixedImage();
|
const Image * image = mipmap.asFixedImage();
|
||||||
|
|
||||||
nvDebugCheck(image != NULL);
|
nvDebugCheck(image != NULL);
|
||||||
|
|
||||||
|
FastCompressor fast;
|
||||||
|
fast.setImage(image, inputOptions.alphaMode);
|
||||||
|
|
||||||
|
SlowCompressor slow;
|
||||||
|
slow.setImage(image, inputOptions.alphaMode);
|
||||||
|
|
||||||
|
|
||||||
if (compressionOptions.format == Format_RGBA || compressionOptions.format == Format_RGB)
|
if (compressionOptions.format == Format_RGBA || compressionOptions.format == Format_RGB)
|
||||||
{
|
{
|
||||||
compressRGB(image, outputOptions, compressionOptions);
|
compressRGB(image, outputOptions, compressionOptions);
|
||||||
|
@ -683,18 +688,19 @@ bool Compressor::Private::compressMipmap(const Mipmap & mipmap, const Compressio
|
||||||
#endif
|
#endif
|
||||||
if (compressionOptions.quality == Quality_Fastest)
|
if (compressionOptions.quality == Quality_Fastest)
|
||||||
{
|
{
|
||||||
fastCompressDXT1(image, outputOptions);
|
fast.compressDXT1(outputOptions);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
if (cudaEnabled)
|
if (cudaEnabled)
|
||||||
{
|
{
|
||||||
nvDebugCheck(cudaSupported);
|
nvDebugCheck(cudaSupported);
|
||||||
cuda->compressDXT1(image, outputOptions, compressionOptions);
|
cuda->setImage(image, inputOptions.alphaMode);
|
||||||
|
cuda->compressDXT1(compressionOptions, outputOptions);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
compressDXT1(image, outputOptions, compressionOptions);
|
slow.compressDXT1(compressionOptions, outputOptions);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -702,18 +708,18 @@ bool Compressor::Private::compressMipmap(const Mipmap & mipmap, const Compressio
|
||||||
{
|
{
|
||||||
if (compressionOptions.quality == Quality_Fastest)
|
if (compressionOptions.quality == Quality_Fastest)
|
||||||
{
|
{
|
||||||
fastCompressDXT1a(image, outputOptions);
|
fast.compressDXT1a(outputOptions);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
if (cudaEnabled)
|
if (cudaEnabled)
|
||||||
{
|
{
|
||||||
nvDebugCheck(cudaSupported);
|
nvDebugCheck(cudaSupported);
|
||||||
/*cuda*/compressDXT1a(image, outputOptions, compressionOptions);
|
/*cuda*/slow.compressDXT1a(compressionOptions, outputOptions);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
compressDXT1a(image, outputOptions, compressionOptions);
|
slow.compressDXT1a(compressionOptions, outputOptions);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -721,18 +727,19 @@ bool Compressor::Private::compressMipmap(const Mipmap & mipmap, const Compressio
|
||||||
{
|
{
|
||||||
if (compressionOptions.quality == Quality_Fastest)
|
if (compressionOptions.quality == Quality_Fastest)
|
||||||
{
|
{
|
||||||
fastCompressDXT3(image, outputOptions);
|
fast.compressDXT3(outputOptions);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
if (cudaEnabled)
|
if (cudaEnabled)
|
||||||
{
|
{
|
||||||
nvDebugCheck(cudaSupported);
|
nvDebugCheck(cudaSupported);
|
||||||
cuda->compressDXT3(image, outputOptions, compressionOptions);
|
cuda->setImage(image, inputOptions.alphaMode);
|
||||||
|
cuda->compressDXT3(compressionOptions, outputOptions);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
compressDXT3(image, outputOptions, compressionOptions);
|
slow.compressDXT3(compressionOptions, outputOptions);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -740,18 +747,19 @@ bool Compressor::Private::compressMipmap(const Mipmap & mipmap, const Compressio
|
||||||
{
|
{
|
||||||
if (compressionOptions.quality == Quality_Fastest)
|
if (compressionOptions.quality == Quality_Fastest)
|
||||||
{
|
{
|
||||||
fastCompressDXT5(image, outputOptions);
|
fast.compressDXT5(outputOptions);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
if (cudaEnabled)
|
if (cudaEnabled)
|
||||||
{
|
{
|
||||||
nvDebugCheck(cudaSupported);
|
nvDebugCheck(cudaSupported);
|
||||||
cuda->compressDXT5(image, outputOptions, compressionOptions);
|
cuda->setImage(image, inputOptions.alphaMode);
|
||||||
|
cuda->compressDXT5(compressionOptions, outputOptions);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
compressDXT5(image, outputOptions, compressionOptions);
|
slow.compressDXT5(compressionOptions, outputOptions);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -759,20 +767,20 @@ bool Compressor::Private::compressMipmap(const Mipmap & mipmap, const Compressio
|
||||||
{
|
{
|
||||||
if (compressionOptions.quality == Quality_Fastest)
|
if (compressionOptions.quality == Quality_Fastest)
|
||||||
{
|
{
|
||||||
fastCompressDXT5n(image, outputOptions);
|
fast.compressDXT5n(outputOptions);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
compressDXT5n(image, outputOptions, compressionOptions);
|
slow.compressDXT5n(compressionOptions, outputOptions);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
else if (compressionOptions.format == Format_BC4)
|
else if (compressionOptions.format == Format_BC4)
|
||||||
{
|
{
|
||||||
compressBC4(image, outputOptions, compressionOptions);
|
slow.compressBC4(compressionOptions, outputOptions);
|
||||||
}
|
}
|
||||||
else if (compressionOptions.format == Format_BC5)
|
else if (compressionOptions.format == Format_BC5)
|
||||||
{
|
{
|
||||||
compressBC5(image, outputOptions, compressionOptions);
|
slow.compressBC5(compressionOptions, outputOptions);
|
||||||
}
|
}
|
||||||
|
|
||||||
return true;
|
return true;
|
||||||
|
|
|
@ -60,7 +60,7 @@ namespace nvtt
|
||||||
void scaleMipmap(Mipmap & mipmap, const InputOptions::Private & inputOptions, uint w, uint h, uint d) const;
|
void scaleMipmap(Mipmap & mipmap, const InputOptions::Private & inputOptions, uint w, uint h, uint d) const;
|
||||||
void processInputImage(Mipmap & mipmap, const InputOptions::Private & inputOptions) const;
|
void processInputImage(Mipmap & mipmap, const InputOptions::Private & inputOptions) const;
|
||||||
void quantizeMipmap(Mipmap & mipmap, const CompressionOptions::Private & compressionOptions) const;
|
void quantizeMipmap(Mipmap & mipmap, const CompressionOptions::Private & compressionOptions) const;
|
||||||
bool compressMipmap(const Mipmap & mipmap, const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions) const;
|
bool compressMipmap(const Mipmap & mipmap, const InputOptions::Private & inputOptions, const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions) const;
|
||||||
|
|
||||||
|
|
||||||
public:
|
public:
|
||||||
|
|
|
@ -1,456 +0,0 @@
|
||||||
// Copyright NVIDIA Corporation 2007 -- Ignacio Castano <icastano@nvidia.com>
|
|
||||||
//
|
|
||||||
// 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 <nvmath/Color.h>
|
|
||||||
#include <nvimage/ColorBlock.h>
|
|
||||||
#include <nvimage/BlockDXT.h>
|
|
||||||
|
|
||||||
#include "FastCompressDXT.h"
|
|
||||||
|
|
||||||
#if defined(__SSE2__)
|
|
||||||
#include <emmintrin.h>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if defined(__SSE__)
|
|
||||||
#include <xmmintrin.h>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if defined(__MMX__)
|
|
||||||
#include <mmintrin.h>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#undef __VEC__
|
|
||||||
#if defined(__VEC__)
|
|
||||||
#include <altivec.h>
|
|
||||||
#undef bool
|
|
||||||
#endif
|
|
||||||
// Online Resources:
|
|
||||||
// - http://www.jasondorie.com/ImageLib.zip
|
|
||||||
// - http://homepage.hispeed.ch/rscheidegger/dri_experimental/s3tc_index.html
|
|
||||||
// - http://www.sjbrown.co.uk/?article=dxt
|
|
||||||
|
|
||||||
using namespace nv;
|
|
||||||
|
|
||||||
|
|
||||||
#if defined(__SSE2__) && 0
|
|
||||||
|
|
||||||
// @@ TODO
|
|
||||||
|
|
||||||
typedef __m128i VectorColor;
|
|
||||||
|
|
||||||
inline static __m128i loadColor(Color32 c)
|
|
||||||
{
|
|
||||||
return ...;
|
|
||||||
}
|
|
||||||
|
|
||||||
inline static __m128i absoluteDifference(__m128i a, __m128i b)
|
|
||||||
{
|
|
||||||
return ...;
|
|
||||||
}
|
|
||||||
|
|
||||||
inline uint colorDistance(__m128i a, __m128i b)
|
|
||||||
{
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#elif defined(__MMX__) && 0
|
|
||||||
|
|
||||||
typedef __m64 VectorColor;
|
|
||||||
|
|
||||||
inline static __m64 loadColor(Color32 c)
|
|
||||||
{
|
|
||||||
return _mm_unpacklo_pi8(_mm_cvtsi32_si64(c), _mm_setzero_si64());
|
|
||||||
}
|
|
||||||
|
|
||||||
inline static __m64 absoluteDifference(__m64 a, __m64 b)
|
|
||||||
{
|
|
||||||
// = |a-b| or |b-a|
|
|
||||||
return _mm_or_si64(_mm_subs_pu16(a, b), _mm_subs_pu16(b, a));
|
|
||||||
}
|
|
||||||
|
|
||||||
inline uint colorDistance(__m64 a, __m64 b)
|
|
||||||
{
|
|
||||||
union {
|
|
||||||
__m64 v;
|
|
||||||
uint16 part[4];
|
|
||||||
} s;
|
|
||||||
|
|
||||||
s.v = absoluteDifference(a, b);
|
|
||||||
|
|
||||||
// @@ This is very slow!
|
|
||||||
return s.part[0] + s.part[1] + s.part[2] + s.part[3];
|
|
||||||
}
|
|
||||||
|
|
||||||
#define vectorEnd _mm_empty
|
|
||||||
|
|
||||||
#elif defined(__VEC__)
|
|
||||||
|
|
||||||
typedef vector signed int VectorColor;
|
|
||||||
|
|
||||||
inline static vector signed int loadColor(Color32 c)
|
|
||||||
{
|
|
||||||
return (vector signed int) (c.r, c.g, c.b, c.a);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Get the absolute distance between the given colors.
|
|
||||||
inline static uint colorDistance(vector signed int c0, vector signed int c1)
|
|
||||||
{
|
|
||||||
int result;
|
|
||||||
vector signed int v = vec_sums(vec_abs(vec_sub(c0, c1)), (vector signed int)0);
|
|
||||||
vec_ste(vec_splat(v, 3), 0, &result);
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
inline void vectorEnd()
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
#else
|
|
||||||
|
|
||||||
typedef Color32 VectorColor;
|
|
||||||
|
|
||||||
inline static Color32 loadColor(Color32 c)
|
|
||||||
{
|
|
||||||
return c;
|
|
||||||
}
|
|
||||||
|
|
||||||
inline static Color32 premultiplyAlpha(Color32 c)
|
|
||||||
{
|
|
||||||
Color32 pm;
|
|
||||||
pm.r = (c.r * c.a) >> 8;
|
|
||||||
pm.g = (c.g * c.a) >> 8;
|
|
||||||
pm.b = (c.b * c.a) >> 8;
|
|
||||||
pm.a = c.a;
|
|
||||||
return pm;
|
|
||||||
}
|
|
||||||
|
|
||||||
inline static uint sqr(uint s)
|
|
||||||
{
|
|
||||||
return s*s;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Get the absolute distance between the given colors.
|
|
||||||
inline static uint colorDistance(Color32 c0, Color32 c1)
|
|
||||||
{
|
|
||||||
return sqr(c0.r - c1.r) + sqr(c0.g - c1.g) + sqr(c0.b - c1.b);
|
|
||||||
//return abs(c0.r - c1.r) + abs(c0.g - c1.g) + abs(c0.b - c1.b);
|
|
||||||
}
|
|
||||||
|
|
||||||
inline void vectorEnd()
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
inline static uint computeIndices(const ColorBlock & rgba, const Color32 palette[4])
|
|
||||||
{
|
|
||||||
const VectorColor vcolor0 = loadColor(palette[0]);
|
|
||||||
const VectorColor vcolor1 = loadColor(palette[1]);
|
|
||||||
const VectorColor vcolor2 = loadColor(palette[2]);
|
|
||||||
const VectorColor vcolor3 = loadColor(palette[3]);
|
|
||||||
|
|
||||||
uint indices = 0;
|
|
||||||
for(int i = 0; i < 16; i++) {
|
|
||||||
const VectorColor vcolor = loadColor(rgba.color(i));
|
|
||||||
|
|
||||||
uint d0 = colorDistance(vcolor0, vcolor);
|
|
||||||
uint d1 = colorDistance(vcolor1, vcolor);
|
|
||||||
uint d2 = colorDistance(vcolor2, vcolor);
|
|
||||||
uint d3 = colorDistance(vcolor3, vcolor);
|
|
||||||
|
|
||||||
uint b0 = d0 > d3;
|
|
||||||
uint b1 = d1 > d2;
|
|
||||||
uint b2 = d0 > d2;
|
|
||||||
uint b3 = d1 > d3;
|
|
||||||
uint b4 = d2 > d3;
|
|
||||||
|
|
||||||
uint x0 = b1 & b2;
|
|
||||||
uint x1 = b0 & b3;
|
|
||||||
uint x2 = b0 & b4;
|
|
||||||
|
|
||||||
indices |= (x2 | ((x0 | x1) << 1)) << (2 * i);
|
|
||||||
}
|
|
||||||
|
|
||||||
vectorEnd();
|
|
||||||
return indices;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// Compressor that uses bounding box.
|
|
||||||
void nv::compressBlock_BoundsRange(const ColorBlock & rgba, BlockDXT1 * block)
|
|
||||||
{
|
|
||||||
Color32 c0, c1;
|
|
||||||
rgba.boundsRange(&c1, &c0);
|
|
||||||
|
|
||||||
block->col0 = toColor16(c0);
|
|
||||||
block->col1 = toColor16(c1);
|
|
||||||
|
|
||||||
nvDebugCheck(block->col0.u > block->col1.u);
|
|
||||||
|
|
||||||
// Use 4 color mode only.
|
|
||||||
//if (block->col0.u < block->col1.u) {
|
|
||||||
// swap(block->col0.u, block->col1.u);
|
|
||||||
//}
|
|
||||||
|
|
||||||
Color32 palette[4];
|
|
||||||
block->evaluatePalette4(palette);
|
|
||||||
|
|
||||||
block->indices = computeIndices(rgba, palette);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// Encode DXT3 block.
|
|
||||||
void nv::compressBlock_BoundsRange(const ColorBlock & rgba, BlockDXT3 * block)
|
|
||||||
{
|
|
||||||
compressBlock_BoundsRange(rgba, &block->color);
|
|
||||||
compressBlock(rgba, &block->alpha);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Encode DXT3 alpha block.
|
|
||||||
void nv::compressBlock(const ColorBlock & rgba, AlphaBlockDXT3 * block)
|
|
||||||
{
|
|
||||||
block->alpha0 = rgba.color(0).a >> 4;
|
|
||||||
block->alpha1 = rgba.color(1).a >> 4;
|
|
||||||
block->alpha2 = rgba.color(2).a >> 4;
|
|
||||||
block->alpha3 = rgba.color(3).a >> 4;
|
|
||||||
block->alpha4 = rgba.color(4).a >> 4;
|
|
||||||
block->alpha5 = rgba.color(5).a >> 4;
|
|
||||||
block->alpha6 = rgba.color(6).a >> 4;
|
|
||||||
block->alpha7 = rgba.color(7).a >> 4;
|
|
||||||
block->alpha8 = rgba.color(8).a >> 4;
|
|
||||||
block->alpha9 = rgba.color(9).a >> 4;
|
|
||||||
block->alphaA = rgba.color(10).a >> 4;
|
|
||||||
block->alphaB = rgba.color(11).a >> 4;
|
|
||||||
block->alphaC = rgba.color(12).a >> 4;
|
|
||||||
block->alphaD = rgba.color(13).a >> 4;
|
|
||||||
block->alphaE = rgba.color(14).a >> 4;
|
|
||||||
block->alphaF = rgba.color(15).a >> 4;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
static uint computeAlphaIndices(const ColorBlock & rgba, AlphaBlockDXT5 * block)
|
|
||||||
{
|
|
||||||
uint8 alphas[8];
|
|
||||||
block->evaluatePalette(alphas);
|
|
||||||
|
|
||||||
uint totalError = 0;
|
|
||||||
|
|
||||||
for (uint i = 0; i < 16; i++)
|
|
||||||
{
|
|
||||||
uint8 alpha = rgba.color(i).a;
|
|
||||||
|
|
||||||
uint besterror = 256*256;
|
|
||||||
uint best = 8;
|
|
||||||
for(uint p = 0; p < 8; p++)
|
|
||||||
{
|
|
||||||
int d = alphas[p] - alpha;
|
|
||||||
uint error = d * d;
|
|
||||||
|
|
||||||
if (error < besterror)
|
|
||||||
{
|
|
||||||
besterror = error;
|
|
||||||
best = p;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
nvDebugCheck(best < 8);
|
|
||||||
|
|
||||||
totalError += besterror;
|
|
||||||
block->setIndex(i, best);
|
|
||||||
}
|
|
||||||
|
|
||||||
return totalError;
|
|
||||||
}
|
|
||||||
|
|
||||||
static uint computeAlphaError(const ColorBlock & rgba, const AlphaBlockDXT5 * block)
|
|
||||||
{
|
|
||||||
uint8 alphas[8];
|
|
||||||
block->evaluatePalette(alphas);
|
|
||||||
|
|
||||||
uint totalError = 0;
|
|
||||||
|
|
||||||
for (uint i = 0; i < 16; i++)
|
|
||||||
{
|
|
||||||
uint8 alpha = rgba.color(i).a;
|
|
||||||
|
|
||||||
uint besterror = 256*256;
|
|
||||||
uint best;
|
|
||||||
for(uint p = 0; p < 8; p++)
|
|
||||||
{
|
|
||||||
int d = alphas[p] - alpha;
|
|
||||||
uint error = d * d;
|
|
||||||
|
|
||||||
if (error < besterror)
|
|
||||||
{
|
|
||||||
besterror = error;
|
|
||||||
best = p;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
totalError += besterror;
|
|
||||||
}
|
|
||||||
|
|
||||||
return totalError;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void nv::compressBlock_BoundsRange(const ColorBlock & rgba, BlockDXT5 * block)
|
|
||||||
{
|
|
||||||
Color32 c0, c1;
|
|
||||||
rgba.boundsRangeAlpha(&c1, &c0);
|
|
||||||
|
|
||||||
block->color.col0 = toColor16(c0);
|
|
||||||
block->color.col1 = toColor16(c1);
|
|
||||||
|
|
||||||
nvDebugCheck(block->color.col0.u > block->color.col1.u);
|
|
||||||
|
|
||||||
Color32 palette[4];
|
|
||||||
block->color.evaluatePalette4(palette);
|
|
||||||
|
|
||||||
block->color.indices = computeIndices(rgba, palette);
|
|
||||||
|
|
||||||
nvDebugCheck(c0.a <= c1.a);
|
|
||||||
|
|
||||||
block->alpha.alpha0 = c0.a;
|
|
||||||
block->alpha.alpha1 = c1.a;
|
|
||||||
|
|
||||||
computeAlphaIndices(rgba, &block->alpha);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
uint nv::compressBlock_BoundsRange(const ColorBlock & rgba, AlphaBlockDXT5 * block)
|
|
||||||
{
|
|
||||||
uint8 alpha0 = 0;
|
|
||||||
uint8 alpha1 = 255;
|
|
||||||
|
|
||||||
// Get min/max alpha.
|
|
||||||
for (uint i = 0; i < 16; i++)
|
|
||||||
{
|
|
||||||
uint8 alpha = rgba.color(i).a;
|
|
||||||
alpha0 = max(alpha0, alpha);
|
|
||||||
alpha1 = min(alpha1, alpha);
|
|
||||||
}
|
|
||||||
|
|
||||||
alpha0 = alpha0 - (alpha0 - alpha1) / 32;
|
|
||||||
alpha1 = alpha1 + (alpha0 - alpha1) / 32;
|
|
||||||
|
|
||||||
AlphaBlockDXT5 block0;
|
|
||||||
block0.alpha0 = alpha0;
|
|
||||||
block0.alpha1 = alpha1;
|
|
||||||
uint error0 = computeAlphaIndices(rgba, &block0);
|
|
||||||
|
|
||||||
AlphaBlockDXT5 block1;
|
|
||||||
block1.alpha0 = alpha1;
|
|
||||||
block1.alpha1 = alpha0;
|
|
||||||
uint error1 = computeAlphaIndices(rgba, &block1);
|
|
||||||
|
|
||||||
if (error0 < error1)
|
|
||||||
{
|
|
||||||
*block = block0;
|
|
||||||
return error0;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
*block = block1;
|
|
||||||
return error1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
uint nv::compressBlock_BruteForce(const ColorBlock & rgba, AlphaBlockDXT5 * block)
|
|
||||||
{
|
|
||||||
uint8 mina = 255;
|
|
||||||
uint8 maxa = 0;
|
|
||||||
|
|
||||||
// Get min/max alpha.
|
|
||||||
for (uint i = 0; i < 16; i++)
|
|
||||||
{
|
|
||||||
uint8 alpha = rgba.color(i).a;
|
|
||||||
mina = min(mina, alpha);
|
|
||||||
maxa = max(maxa, alpha);
|
|
||||||
}
|
|
||||||
|
|
||||||
block->alpha0 = maxa;
|
|
||||||
block->alpha1 = mina;
|
|
||||||
|
|
||||||
/*int centroidDist = 256;
|
|
||||||
int centroid;
|
|
||||||
|
|
||||||
// Get the closest to the centroid.
|
|
||||||
for (uint i = 0; i < 16; i++)
|
|
||||||
{
|
|
||||||
uint8 alpha = rgba.color(i).a;
|
|
||||||
int dist = abs(alpha - (maxa + mina) / 2);
|
|
||||||
if (dist < centroidDist)
|
|
||||||
{
|
|
||||||
centroidDist = dist;
|
|
||||||
centroid = alpha;
|
|
||||||
}
|
|
||||||
}*/
|
|
||||||
|
|
||||||
if (maxa - mina > 8)
|
|
||||||
{
|
|
||||||
int besterror = computeAlphaError(rgba, block);
|
|
||||||
int besta0 = maxa;
|
|
||||||
int besta1 = mina;
|
|
||||||
|
|
||||||
for (int a0 = mina+9; a0 < maxa; a0++)
|
|
||||||
{
|
|
||||||
for (int a1 = mina; a1 < a0-8; a1++)
|
|
||||||
//for (int a1 = mina; a1 < maxa; a1++)
|
|
||||||
{
|
|
||||||
//nvCheck(abs(a1-a0) > 8);
|
|
||||||
|
|
||||||
//if (abs(a0 - a1) < 8) continue;
|
|
||||||
//if ((maxa-a0) + (a1-mina) + min(abs(centroid-a0), abs(centroid-a1)) > besterror)
|
|
||||||
if ((maxa-a0) + (a1-mina) > besterror)
|
|
||||||
continue;
|
|
||||||
|
|
||||||
block->alpha0 = a0;
|
|
||||||
block->alpha1 = a1;
|
|
||||||
int error = computeAlphaError(rgba, block);
|
|
||||||
|
|
||||||
if (error < besterror)
|
|
||||||
{
|
|
||||||
besterror = error;
|
|
||||||
besta0 = a0;
|
|
||||||
besta1 = a1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
block->alpha0 = besta0;
|
|
||||||
block->alpha1 = besta1;
|
|
||||||
}
|
|
||||||
|
|
||||||
return computeAlphaIndices(rgba, block);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
|
@ -1,84 +0,0 @@
|
||||||
// Copyright NVIDIA Corporation 2007 -- Ignacio Castano <icastano@nvidia.com>
|
|
||||||
//
|
|
||||||
// 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.
|
|
||||||
|
|
||||||
#ifndef NV_TT_FASTCOMPRESSDXT_H
|
|
||||||
#define NV_TT_FASTCOMPRESSDXT_H
|
|
||||||
|
|
||||||
#include <nvimage/nvimage.h>
|
|
||||||
|
|
||||||
namespace nv
|
|
||||||
{
|
|
||||||
struct ColorBlock;
|
|
||||||
struct BlockDXT1;
|
|
||||||
struct BlockDXT3;
|
|
||||||
struct BlockDXT5;
|
|
||||||
struct AlphaBlockDXT3;
|
|
||||||
struct AlphaBlockDXT5;
|
|
||||||
|
|
||||||
// Color compression:
|
|
||||||
|
|
||||||
// Compressor that uses the extremes of the luminance axis.
|
|
||||||
// void compressBlock_DiameterAxis(const ColorBlock & rgba, BlockDXT1 * block);
|
|
||||||
|
|
||||||
// Compressor that uses the extremes of the luminance axis.
|
|
||||||
// void compressBlock_LuminanceAxis(const ColorBlock & rgba, BlockDXT1 * block);
|
|
||||||
|
|
||||||
// Compressor that uses bounding box.
|
|
||||||
void compressBlock_BoundsRange(const ColorBlock & rgba, BlockDXT1 * block);
|
|
||||||
|
|
||||||
// Compressor that uses bounding box and takes alpha into account.
|
|
||||||
// void compressBlock_BoundsRangeAlpha(const ColorBlock & rgba, BlockDXT1 * block);
|
|
||||||
|
|
||||||
|
|
||||||
// Simple, but slow compressor that tests all color pairs.
|
|
||||||
// void compressBlock_TestAllPairs(const ColorBlock & rgba, BlockDXT1 * block);
|
|
||||||
|
|
||||||
// Brute force 6d search along the best fit axis.
|
|
||||||
// void compressBlock_AnalyzeBestFitAxis(const ColorBlock & rgba, BlockDXT1 * block);
|
|
||||||
|
|
||||||
// Spatial greedy search.
|
|
||||||
// void refineSolution_1dSearch(const ColorBlock & rgba, BlockDXT1 * block);
|
|
||||||
// void refineSolution_3dSearch(const ColorBlock & rgba, BlockDXT1 * block);
|
|
||||||
// void refineSolution_6dSearch(const ColorBlock & rgba, BlockDXT1 * block);
|
|
||||||
|
|
||||||
// Brute force compressor for DXT5n
|
|
||||||
// void compressGreenBlock_BruteForce(const ColorBlock & rgba, BlockDXT1 * block);
|
|
||||||
|
|
||||||
// Minimize error of the endpoints.
|
|
||||||
// void optimizeEndPoints(const ColorBlock & rgba, BlockDXT1 * block);
|
|
||||||
|
|
||||||
// uint blockError(const ColorBlock & rgba, const BlockDXT1 & block);
|
|
||||||
// uint blockError(const ColorBlock & rgba, const AlphaBlockDXT5 & block);
|
|
||||||
|
|
||||||
// Alpha compression:
|
|
||||||
void compressBlock(const ColorBlock & rgba, AlphaBlockDXT3 * block);
|
|
||||||
void compressBlock_BoundsRange(const ColorBlock & rgba, BlockDXT3 * block);
|
|
||||||
void compressBlock_BoundsRange(const ColorBlock & rgba, BlockDXT5 * block);
|
|
||||||
|
|
||||||
uint compressBlock_BoundsRange(const ColorBlock & rgba, AlphaBlockDXT5 * block);
|
|
||||||
uint compressBlock_BruteForce(const ColorBlock & rgba, AlphaBlockDXT5 * block);
|
|
||||||
// uint compressBlock_Iterative(const ColorBlock & rgba, AlphaBlockDXT5 * block);
|
|
||||||
|
|
||||||
} // nv namespace
|
|
||||||
|
|
||||||
#endif // NV_TT_FASTCOMPRESSDXT_H
|
|
368
src/nvtt/OptimalCompressDXT.cpp
Normal file
368
src/nvtt/OptimalCompressDXT.cpp
Normal file
|
@ -0,0 +1,368 @@
|
||||||
|
// Copyright NVIDIA Corporation 2007 -- Ignacio Castano <icastano@nvidia.com>
|
||||||
|
//
|
||||||
|
// 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 <nvcore/Containers.h> // swap
|
||||||
|
|
||||||
|
#include <nvmath/Color.h>
|
||||||
|
|
||||||
|
#include <nvimage/ColorBlock.h>
|
||||||
|
#include <nvimage/BlockDXT.h>
|
||||||
|
|
||||||
|
#include "OptimalCompressDXT.h"
|
||||||
|
#include "SingleColorLookup.h"
|
||||||
|
|
||||||
|
|
||||||
|
using namespace nv;
|
||||||
|
using namespace OptimalCompress;
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
namespace
|
||||||
|
{
|
||||||
|
static int computeGreenError(const ColorBlock & rgba, const BlockDXT1 * block)
|
||||||
|
{
|
||||||
|
nvDebugCheck(block != NULL);
|
||||||
|
|
||||||
|
int palette[4];
|
||||||
|
palette[0] = (block->col0.g << 2) | (block->col0.g >> 4);
|
||||||
|
palette[1] = (block->col1.g << 2) | (block->col1.g >> 4);
|
||||||
|
palette[2] = (2 * palette[0] + palette[1]) / 3;
|
||||||
|
palette[3] = (2 * palette[1] + palette[0]) / 3;
|
||||||
|
|
||||||
|
int totalError = 0;
|
||||||
|
|
||||||
|
for (int i = 0; i < 16; i++)
|
||||||
|
{
|
||||||
|
const int green = rgba.color(i).g;
|
||||||
|
|
||||||
|
int error = abs(green - palette[0]);
|
||||||
|
error = min(error, abs(green - palette[1]));
|
||||||
|
error = min(error, abs(green - palette[2]));
|
||||||
|
error = min(error, abs(green - palette[3]));
|
||||||
|
|
||||||
|
totalError += error;
|
||||||
|
}
|
||||||
|
|
||||||
|
return totalError;
|
||||||
|
}
|
||||||
|
|
||||||
|
static uint computeGreenIndices(const ColorBlock & rgba, const Color32 palette[4])
|
||||||
|
{
|
||||||
|
const int color0 = palette[0].g;
|
||||||
|
const int color1 = palette[1].g;
|
||||||
|
const int color2 = palette[2].g;
|
||||||
|
const int color3 = palette[3].g;
|
||||||
|
|
||||||
|
uint indices = 0;
|
||||||
|
for (int i = 0; i < 16; i++)
|
||||||
|
{
|
||||||
|
const int color = rgba.color(i).g;
|
||||||
|
|
||||||
|
uint d0 = abs(color0 - color);
|
||||||
|
uint d1 = abs(color1 - color);
|
||||||
|
uint d2 = abs(color2 - color);
|
||||||
|
uint d3 = abs(color3 - color);
|
||||||
|
|
||||||
|
uint b0 = d0 > d3;
|
||||||
|
uint b1 = d1 > d2;
|
||||||
|
uint b2 = d0 > d2;
|
||||||
|
uint b3 = d1 > d3;
|
||||||
|
uint b4 = d2 > d3;
|
||||||
|
|
||||||
|
uint x0 = b1 & b2;
|
||||||
|
uint x1 = b0 & b3;
|
||||||
|
uint x2 = b0 & b4;
|
||||||
|
|
||||||
|
indices |= (x2 | ((x0 | x1) << 1)) << (2 * i);
|
||||||
|
}
|
||||||
|
|
||||||
|
return indices;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Choose quantized color that produces less error. Used by DXT3 compressor.
|
||||||
|
inline static uint quantize4(uint8 a)
|
||||||
|
{
|
||||||
|
int q0 = (a >> 4) - 1;
|
||||||
|
int q1 = (a >> 4);
|
||||||
|
int q2 = (a >> 4) + 1;
|
||||||
|
|
||||||
|
q0 = (q0 << 4) | q0;
|
||||||
|
q1 = (q1 << 4) | q1;
|
||||||
|
q2 = (q2 << 4) | q2;
|
||||||
|
|
||||||
|
int d0 = abs(q0 - a);
|
||||||
|
int d1 = abs(q1 - a);
|
||||||
|
int d2 = abs(q2 - a);
|
||||||
|
|
||||||
|
if (d0 < d1 && d0 < d2) return q0 >> 4;
|
||||||
|
if (d1 < d2) return q1 >> 4;
|
||||||
|
return q2 >> 4;
|
||||||
|
}
|
||||||
|
|
||||||
|
static uint computeAlphaError(const ColorBlock & rgba, const AlphaBlockDXT5 * block)
|
||||||
|
{
|
||||||
|
uint8 alphas[8];
|
||||||
|
block->evaluatePalette(alphas);
|
||||||
|
|
||||||
|
uint totalError = 0;
|
||||||
|
|
||||||
|
for (uint i = 0; i < 16; i++)
|
||||||
|
{
|
||||||
|
uint8 alpha = rgba.color(i).a;
|
||||||
|
|
||||||
|
uint besterror = 256*256;
|
||||||
|
uint best;
|
||||||
|
for (uint p = 0; p < 8; p++)
|
||||||
|
{
|
||||||
|
int d = alphas[p] - alpha;
|
||||||
|
uint error = d * d;
|
||||||
|
|
||||||
|
if (error < besterror)
|
||||||
|
{
|
||||||
|
besterror = error;
|
||||||
|
best = p;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
totalError += besterror;
|
||||||
|
}
|
||||||
|
|
||||||
|
return totalError;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void computeAlphaIndices(const ColorBlock & rgba, AlphaBlockDXT5 * block)
|
||||||
|
{
|
||||||
|
uint8 alphas[8];
|
||||||
|
block->evaluatePalette(alphas);
|
||||||
|
|
||||||
|
for (uint i = 0; i < 16; i++)
|
||||||
|
{
|
||||||
|
uint8 alpha = rgba.color(i).a;
|
||||||
|
|
||||||
|
uint besterror = 256*256;
|
||||||
|
uint best = 8;
|
||||||
|
for(uint p = 0; p < 8; p++)
|
||||||
|
{
|
||||||
|
int d = alphas[p] - alpha;
|
||||||
|
uint error = d * d;
|
||||||
|
|
||||||
|
if (error < besterror)
|
||||||
|
{
|
||||||
|
besterror = error;
|
||||||
|
best = p;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
nvDebugCheck(best < 8);
|
||||||
|
|
||||||
|
block->setIndex(i, best);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
// Single color compressor, based on:
|
||||||
|
// https://mollyrocket.com/forums/viewtopic.php?t=392
|
||||||
|
void OptimalCompress::compressDXT1(Color32 c, BlockDXT1 * dxtBlock)
|
||||||
|
{
|
||||||
|
dxtBlock->col0.r = OMatch5[c.r][0];
|
||||||
|
dxtBlock->col0.g = OMatch6[c.g][0];
|
||||||
|
dxtBlock->col0.b = OMatch5[c.b][0];
|
||||||
|
dxtBlock->col1.r = OMatch5[c.r][1];
|
||||||
|
dxtBlock->col1.g = OMatch6[c.g][1];
|
||||||
|
dxtBlock->col1.b = OMatch5[c.b][1];
|
||||||
|
dxtBlock->indices = 0xaaaaaaaa;
|
||||||
|
|
||||||
|
if (dxtBlock->col0.u < dxtBlock->col1.u)
|
||||||
|
{
|
||||||
|
swap(dxtBlock->col0.u, dxtBlock->col1.u);
|
||||||
|
dxtBlock->indices ^= 0x55555555;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void OptimalCompress::compressDXT1a(Color32 rgba, BlockDXT1 * dxtBlock)
|
||||||
|
{
|
||||||
|
if (rgba.a < 128)
|
||||||
|
{
|
||||||
|
dxtBlock->col0.u = 0;
|
||||||
|
dxtBlock->col1.u = 0;
|
||||||
|
dxtBlock->indices = 0xFFFFFFFF;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
compressDXT1(rgba, dxtBlock);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// Brute force green channel compressor
|
||||||
|
void OptimalCompress::compressDXT1G(const ColorBlock & rgba, BlockDXT1 * block)
|
||||||
|
{
|
||||||
|
nvDebugCheck(block != NULL);
|
||||||
|
|
||||||
|
uint8 ming = 63;
|
||||||
|
uint8 maxg = 0;
|
||||||
|
|
||||||
|
// Get min/max green.
|
||||||
|
for (uint i = 0; i < 16; i++)
|
||||||
|
{
|
||||||
|
uint8 green = rgba.color(i).g >> 2;
|
||||||
|
ming = min(ming, green);
|
||||||
|
maxg = max(maxg, green);
|
||||||
|
}
|
||||||
|
|
||||||
|
block->col0.r = 31;
|
||||||
|
block->col1.r = 31;
|
||||||
|
block->col0.g = maxg;
|
||||||
|
block->col1.g = ming;
|
||||||
|
block->col0.b = 0;
|
||||||
|
block->col1.b = 0;
|
||||||
|
|
||||||
|
if (maxg - ming > 4)
|
||||||
|
{
|
||||||
|
int besterror = computeGreenError(rgba, block);
|
||||||
|
int bestg0 = maxg;
|
||||||
|
int bestg1 = ming;
|
||||||
|
|
||||||
|
for (int g0 = ming+5; g0 < maxg; g0++)
|
||||||
|
{
|
||||||
|
for (int g1 = ming; g1 < g0-4; g1++)
|
||||||
|
{
|
||||||
|
if ((maxg-g0) + (g1-ming) > besterror)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
block->col0.g = g0;
|
||||||
|
block->col1.g = g1;
|
||||||
|
int error = computeGreenError(rgba, block);
|
||||||
|
|
||||||
|
if (error < besterror)
|
||||||
|
{
|
||||||
|
besterror = error;
|
||||||
|
bestg0 = g0;
|
||||||
|
bestg1 = g1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
block->col0.g = bestg0;
|
||||||
|
block->col1.g = bestg1;
|
||||||
|
}
|
||||||
|
|
||||||
|
Color32 palette[4];
|
||||||
|
block->evaluatePalette(palette);
|
||||||
|
block->indices = computeGreenIndices(rgba, palette);
|
||||||
|
}
|
||||||
|
|
||||||
|
void OptimalCompress::compressDXT3A(const ColorBlock & rgba, AlphaBlockDXT3 * dxtBlock)
|
||||||
|
{
|
||||||
|
dxtBlock->alpha0 = quantize4(rgba.color(0).a);
|
||||||
|
dxtBlock->alpha1 = quantize4(rgba.color(1).a);
|
||||||
|
dxtBlock->alpha2 = quantize4(rgba.color(2).a);
|
||||||
|
dxtBlock->alpha3 = quantize4(rgba.color(3).a);
|
||||||
|
dxtBlock->alpha4 = quantize4(rgba.color(4).a);
|
||||||
|
dxtBlock->alpha5 = quantize4(rgba.color(5).a);
|
||||||
|
dxtBlock->alpha6 = quantize4(rgba.color(6).a);
|
||||||
|
dxtBlock->alpha7 = quantize4(rgba.color(7).a);
|
||||||
|
dxtBlock->alpha8 = quantize4(rgba.color(8).a);
|
||||||
|
dxtBlock->alpha9 = quantize4(rgba.color(9).a);
|
||||||
|
dxtBlock->alphaA = quantize4(rgba.color(10).a);
|
||||||
|
dxtBlock->alphaB = quantize4(rgba.color(11).a);
|
||||||
|
dxtBlock->alphaC = quantize4(rgba.color(12).a);
|
||||||
|
dxtBlock->alphaD = quantize4(rgba.color(13).a);
|
||||||
|
dxtBlock->alphaE = quantize4(rgba.color(14).a);
|
||||||
|
dxtBlock->alphaF = quantize4(rgba.color(15).a);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void OptimalCompress::compressDXT5A(const ColorBlock & rgba, AlphaBlockDXT5 * dxtBlock)
|
||||||
|
{
|
||||||
|
uint8 mina = 255;
|
||||||
|
uint8 maxa = 0;
|
||||||
|
|
||||||
|
// Get min/max alpha.
|
||||||
|
for (uint i = 0; i < 16; i++)
|
||||||
|
{
|
||||||
|
uint8 alpha = rgba.color(i).a;
|
||||||
|
mina = min(mina, alpha);
|
||||||
|
maxa = max(maxa, alpha);
|
||||||
|
}
|
||||||
|
|
||||||
|
dxtBlock->alpha0 = maxa;
|
||||||
|
dxtBlock->alpha1 = mina;
|
||||||
|
|
||||||
|
/*int centroidDist = 256;
|
||||||
|
int centroid;
|
||||||
|
|
||||||
|
// Get the closest to the centroid.
|
||||||
|
for (uint i = 0; i < 16; i++)
|
||||||
|
{
|
||||||
|
uint8 alpha = rgba.color(i).a;
|
||||||
|
int dist = abs(alpha - (maxa + mina) / 2);
|
||||||
|
if (dist < centroidDist)
|
||||||
|
{
|
||||||
|
centroidDist = dist;
|
||||||
|
centroid = alpha;
|
||||||
|
}
|
||||||
|
}*/
|
||||||
|
|
||||||
|
if (maxa - mina > 8)
|
||||||
|
{
|
||||||
|
int besterror = computeAlphaError(rgba, dxtBlock);
|
||||||
|
int besta0 = maxa;
|
||||||
|
int besta1 = mina;
|
||||||
|
|
||||||
|
for (int a0 = mina+9; a0 < maxa; a0++)
|
||||||
|
{
|
||||||
|
for (int a1 = mina; a1 < a0-8; a1++)
|
||||||
|
//for (int a1 = mina; a1 < maxa; a1++)
|
||||||
|
{
|
||||||
|
//nvCheck(abs(a1-a0) > 8);
|
||||||
|
|
||||||
|
//if (abs(a0 - a1) < 8) continue;
|
||||||
|
//if ((maxa-a0) + (a1-mina) + min(abs(centroid-a0), abs(centroid-a1)) > besterror)
|
||||||
|
if ((maxa-a0) + (a1-mina) > besterror)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
dxtBlock->alpha0 = a0;
|
||||||
|
dxtBlock->alpha1 = a1;
|
||||||
|
int error = computeAlphaError(rgba, dxtBlock);
|
||||||
|
|
||||||
|
if (error < besterror)
|
||||||
|
{
|
||||||
|
besterror = error;
|
||||||
|
besta0 = a0;
|
||||||
|
besta1 = a1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
dxtBlock->alpha0 = besta0;
|
||||||
|
dxtBlock->alpha1 = besta1;
|
||||||
|
}
|
||||||
|
|
||||||
|
computeAlphaIndices(rgba, dxtBlock);
|
||||||
|
}
|
||||||
|
|
49
src/nvtt/OptimalCompressDXT.h
Normal file
49
src/nvtt/OptimalCompressDXT.h
Normal file
|
@ -0,0 +1,49 @@
|
||||||
|
// Copyright NVIDIA Corporation 2008 -- Ignacio Castano <icastano@nvidia.com>
|
||||||
|
//
|
||||||
|
// 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.
|
||||||
|
|
||||||
|
#ifndef NV_TT_OPTIMALCOMPRESSDXT_H
|
||||||
|
#define NV_TT_OPTIMALCOMPRESSDXT_H
|
||||||
|
|
||||||
|
#include <nvimage/nvimage.h>
|
||||||
|
|
||||||
|
namespace nv
|
||||||
|
{
|
||||||
|
struct ColorBlock;
|
||||||
|
struct BlockDXT1;
|
||||||
|
struct BlockDXT3;
|
||||||
|
struct BlockDXT5;
|
||||||
|
struct AlphaBlockDXT3;
|
||||||
|
struct AlphaBlockDXT5;
|
||||||
|
|
||||||
|
namespace OptimalCompress
|
||||||
|
{
|
||||||
|
void compressDXT1(Color32 rgba, BlockDXT1 * dxtBlock);
|
||||||
|
void compressDXT1a(Color32 rgba, BlockDXT1 * dxtBlock);
|
||||||
|
|
||||||
|
void compressDXT1G(const ColorBlock & rgba, BlockDXT1 * block);
|
||||||
|
void compressDXT3A(const ColorBlock & rgba, AlphaBlockDXT3 * dxtBlock);
|
||||||
|
void compressDXT5A(const ColorBlock & rgba, AlphaBlockDXT5 * dxtBlock);
|
||||||
|
}
|
||||||
|
} // nv namespace
|
||||||
|
|
||||||
|
#endif // NV_TT_OPTIMALCOMPRESSDXT_H
|
|
@ -27,7 +27,7 @@
|
||||||
#include <nvimage/BlockDXT.h>
|
#include <nvimage/BlockDXT.h>
|
||||||
|
|
||||||
#include "QuickCompressDXT.h"
|
#include "QuickCompressDXT.h"
|
||||||
#include "SingleColorLookup.h"
|
#include "OptimalCompressDXT.h"
|
||||||
|
|
||||||
|
|
||||||
using namespace nv;
|
using namespace nv;
|
||||||
|
@ -288,91 +288,6 @@ static void optimizeEndPoints4(Vector3 block[16], BlockDXT1 * dxtBlock)
|
||||||
dxtBlock->indices = computeIndices3(block, a, b);
|
dxtBlock->indices = computeIndices3(block, a, b);
|
||||||
}*/
|
}*/
|
||||||
|
|
||||||
// Choose quantized color that produces less error. Used by DXT3 compressor.
|
|
||||||
inline static uint quantize4(uint8 a)
|
|
||||||
{
|
|
||||||
int q0 = (a >> 4) - 1;
|
|
||||||
int q1 = (a >> 4);
|
|
||||||
int q2 = (a >> 4) + 1;
|
|
||||||
|
|
||||||
q0 = (q0 << 4) | q0;
|
|
||||||
q1 = (q1 << 4) | q1;
|
|
||||||
q2 = (q2 << 4) | q2;
|
|
||||||
|
|
||||||
int d0 = abs(q0 - a);
|
|
||||||
int d1 = abs(q1 - a);
|
|
||||||
int d2 = abs(q2 - a);
|
|
||||||
|
|
||||||
if (d0 < d1 && d0 < d2) return q0 >> 4;
|
|
||||||
if (d1 < d2) return q1 >> 4;
|
|
||||||
return q2 >> 4;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
namespace
|
|
||||||
{
|
|
||||||
static int computeGreenError(const ColorBlock & rgba, const BlockDXT1 * block)
|
|
||||||
{
|
|
||||||
nvDebugCheck(block != NULL);
|
|
||||||
|
|
||||||
int palette[4];
|
|
||||||
palette[0] = (block->col0.g << 2) | (block->col0.g >> 4);
|
|
||||||
palette[1] = (block->col1.g << 2) | (block->col1.g >> 4);
|
|
||||||
palette[2] = (2 * palette[0] + palette[1]) / 3;
|
|
||||||
palette[3] = (2 * palette[1] + palette[0]) / 3;
|
|
||||||
|
|
||||||
int totalError = 0;
|
|
||||||
|
|
||||||
for (int i = 0; i < 16; i++)
|
|
||||||
{
|
|
||||||
const int green = rgba.color(i).g;
|
|
||||||
|
|
||||||
int error = abs(green - palette[0]);
|
|
||||||
error = min(error, abs(green - palette[1]));
|
|
||||||
error = min(error, abs(green - palette[2]));
|
|
||||||
error = min(error, abs(green - palette[3]));
|
|
||||||
|
|
||||||
totalError += error;
|
|
||||||
}
|
|
||||||
|
|
||||||
return totalError;
|
|
||||||
}
|
|
||||||
|
|
||||||
static uint computeGreenIndices(const ColorBlock & rgba, const Color32 palette[4])
|
|
||||||
{
|
|
||||||
const int color0 = palette[0].g;
|
|
||||||
const int color1 = palette[1].g;
|
|
||||||
const int color2 = palette[2].g;
|
|
||||||
const int color3 = palette[3].g;
|
|
||||||
|
|
||||||
uint indices = 0;
|
|
||||||
for (int i = 0; i < 16; i++)
|
|
||||||
{
|
|
||||||
const int color = rgba.color(i).g;
|
|
||||||
|
|
||||||
uint d0 = abs(color0 - color);
|
|
||||||
uint d1 = abs(color1 - color);
|
|
||||||
uint d2 = abs(color2 - color);
|
|
||||||
uint d3 = abs(color3 - color);
|
|
||||||
|
|
||||||
uint b0 = d0 > d3;
|
|
||||||
uint b1 = d1 > d2;
|
|
||||||
uint b2 = d0 > d2;
|
|
||||||
uint b3 = d1 > d3;
|
|
||||||
uint b4 = d2 > d3;
|
|
||||||
|
|
||||||
uint x0 = b1 & b2;
|
|
||||||
uint x1 = b0 & b3;
|
|
||||||
uint x2 = b0 & b4;
|
|
||||||
|
|
||||||
indices |= (x2 | ((x0 | x1) << 1)) << (2 * i);
|
|
||||||
}
|
|
||||||
|
|
||||||
return indices;
|
|
||||||
}
|
|
||||||
|
|
||||||
} // namespace
|
|
||||||
|
|
||||||
namespace
|
namespace
|
||||||
{
|
{
|
||||||
|
|
||||||
|
@ -524,29 +439,14 @@ namespace
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// Single color compressor, based on:
|
|
||||||
// https://mollyrocket.com/forums/viewtopic.php?t=392
|
|
||||||
void QuickCompress::compressDXT1(Color32 c, BlockDXT1 * dxtBlock)
|
|
||||||
{
|
|
||||||
dxtBlock->col0.r = OMatch5[c.r][0];
|
|
||||||
dxtBlock->col0.g = OMatch6[c.g][0];
|
|
||||||
dxtBlock->col0.b = OMatch5[c.b][0];
|
|
||||||
dxtBlock->col1.r = OMatch5[c.r][1];
|
|
||||||
dxtBlock->col1.g = OMatch6[c.g][1];
|
|
||||||
dxtBlock->col1.b = OMatch5[c.b][1];
|
|
||||||
dxtBlock->indices = 0xaaaaaaaa;
|
|
||||||
|
|
||||||
if (dxtBlock->col0.u < dxtBlock->col1.u)
|
|
||||||
{
|
|
||||||
swap(dxtBlock->col0.u, dxtBlock->col1.u);
|
|
||||||
dxtBlock->indices ^= 0x55555555;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void QuickCompress::compressDXT1(const ColorBlock & rgba, BlockDXT1 * dxtBlock)
|
void QuickCompress::compressDXT1(const ColorBlock & rgba, BlockDXT1 * dxtBlock)
|
||||||
{
|
{
|
||||||
|
if (rgba.isSingleColor())
|
||||||
|
{
|
||||||
|
OptimalCompress::compressDXT1(rgba.color(0), dxtBlock);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
// read block
|
// read block
|
||||||
Vector3 block[16];
|
Vector3 block[16];
|
||||||
extractColorBlockRGB(rgba, block);
|
extractColorBlockRGB(rgba, block);
|
||||||
|
@ -573,29 +473,28 @@ void QuickCompress::compressDXT1(const ColorBlock & rgba, BlockDXT1 * dxtBlock)
|
||||||
dxtBlock->indices = computeIndices4(block, maxColor, minColor);
|
dxtBlock->indices = computeIndices4(block, maxColor, minColor);
|
||||||
|
|
||||||
optimizeEndPoints4(block, dxtBlock);
|
optimizeEndPoints4(block, dxtBlock);
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void QuickCompress::compressDXT1a(Color32 rgba, BlockDXT1 * dxtBlock)
|
|
||||||
{
|
|
||||||
if (rgba.a == 0)
|
|
||||||
{
|
|
||||||
dxtBlock->col0.u = 0;
|
|
||||||
dxtBlock->col1.u = 0;
|
|
||||||
dxtBlock->indices = 0xFFFFFFFF;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
compressDXT1(rgba, dxtBlock);
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
void QuickCompress::compressDXT1a(const ColorBlock & rgba, BlockDXT1 * dxtBlock)
|
void QuickCompress::compressDXT1a(const ColorBlock & rgba, BlockDXT1 * dxtBlock)
|
||||||
{
|
{
|
||||||
if (!rgba.hasAlpha())
|
bool hasAlpha = false;
|
||||||
|
|
||||||
|
for (uint i = 0; i < 16; i++)
|
||||||
|
{
|
||||||
|
if (rgba.color(i).a < 128) {
|
||||||
|
hasAlpha = true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!hasAlpha)
|
||||||
{
|
{
|
||||||
compressDXT1(rgba, dxtBlock);
|
compressDXT1(rgba, dxtBlock);
|
||||||
}
|
}
|
||||||
|
// @@ Handle single RGB, with varying alpha? We need tables for single color compressor in 3 color mode.
|
||||||
|
//else if (rgba.isSingleColorNoAlpha()) { ... }
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
// read block
|
// read block
|
||||||
|
@ -628,92 +527,14 @@ void QuickCompress::compressDXT1a(const ColorBlock & rgba, BlockDXT1 * dxtBlock)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
// Brute force green channel compressor
|
|
||||||
void QuickCompress::compressDXT1G(const ColorBlock & rgba, BlockDXT1 * block)
|
|
||||||
{
|
|
||||||
nvDebugCheck(block != NULL);
|
|
||||||
|
|
||||||
uint8 ming = 63;
|
|
||||||
uint8 maxg = 0;
|
|
||||||
|
|
||||||
// Get min/max green.
|
|
||||||
for (uint i = 0; i < 16; i++)
|
|
||||||
{
|
|
||||||
uint8 green = rgba.color(i).g >> 2;
|
|
||||||
ming = min(ming, green);
|
|
||||||
maxg = max(maxg, green);
|
|
||||||
}
|
|
||||||
|
|
||||||
block->col0.r = 31;
|
|
||||||
block->col1.r = 31;
|
|
||||||
block->col0.g = maxg;
|
|
||||||
block->col1.g = ming;
|
|
||||||
block->col0.b = 0;
|
|
||||||
block->col1.b = 0;
|
|
||||||
|
|
||||||
if (maxg - ming > 4)
|
|
||||||
{
|
|
||||||
int besterror = computeGreenError(rgba, block);
|
|
||||||
int bestg0 = maxg;
|
|
||||||
int bestg1 = ming;
|
|
||||||
|
|
||||||
for (int g0 = ming+5; g0 < maxg; g0++)
|
|
||||||
{
|
|
||||||
for (int g1 = ming; g1 < g0-4; g1++)
|
|
||||||
{
|
|
||||||
if ((maxg-g0) + (g1-ming) > besterror)
|
|
||||||
continue;
|
|
||||||
|
|
||||||
block->col0.g = g0;
|
|
||||||
block->col1.g = g1;
|
|
||||||
int error = computeGreenError(rgba, block);
|
|
||||||
|
|
||||||
if (error < besterror)
|
|
||||||
{
|
|
||||||
besterror = error;
|
|
||||||
bestg0 = g0;
|
|
||||||
bestg1 = g1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
block->col0.g = bestg0;
|
|
||||||
block->col1.g = bestg1;
|
|
||||||
}
|
|
||||||
|
|
||||||
Color32 palette[4];
|
|
||||||
block->evaluatePalette(palette);
|
|
||||||
block->indices = computeGreenIndices(rgba, palette);
|
|
||||||
}
|
|
||||||
|
|
||||||
void QuickCompress::compressDXT3A(const ColorBlock & rgba, AlphaBlockDXT3 * dxtBlock)
|
|
||||||
{
|
|
||||||
dxtBlock->alpha0 = quantize4(rgba.color(0).a);
|
|
||||||
dxtBlock->alpha1 = quantize4(rgba.color(1).a);
|
|
||||||
dxtBlock->alpha2 = quantize4(rgba.color(2).a);
|
|
||||||
dxtBlock->alpha3 = quantize4(rgba.color(3).a);
|
|
||||||
dxtBlock->alpha4 = quantize4(rgba.color(4).a);
|
|
||||||
dxtBlock->alpha5 = quantize4(rgba.color(5).a);
|
|
||||||
dxtBlock->alpha6 = quantize4(rgba.color(6).a);
|
|
||||||
dxtBlock->alpha7 = quantize4(rgba.color(7).a);
|
|
||||||
dxtBlock->alpha8 = quantize4(rgba.color(8).a);
|
|
||||||
dxtBlock->alpha9 = quantize4(rgba.color(9).a);
|
|
||||||
dxtBlock->alphaA = quantize4(rgba.color(10).a);
|
|
||||||
dxtBlock->alphaB = quantize4(rgba.color(11).a);
|
|
||||||
dxtBlock->alphaC = quantize4(rgba.color(12).a);
|
|
||||||
dxtBlock->alphaD = quantize4(rgba.color(13).a);
|
|
||||||
dxtBlock->alphaE = quantize4(rgba.color(14).a);
|
|
||||||
dxtBlock->alphaF = quantize4(rgba.color(15).a);
|
|
||||||
}
|
|
||||||
|
|
||||||
void QuickCompress::compressDXT3(const ColorBlock & rgba, BlockDXT3 * dxtBlock)
|
void QuickCompress::compressDXT3(const ColorBlock & rgba, BlockDXT3 * dxtBlock)
|
||||||
{
|
{
|
||||||
compressDXT1(rgba, &dxtBlock->color);
|
compressDXT1(rgba, &dxtBlock->color);
|
||||||
compressDXT3A(rgba, &dxtBlock->alpha);
|
OptimalCompress::compressDXT3A(rgba, &dxtBlock->alpha);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
void QuickCompress::compressDXT5A(const ColorBlock & rgba, AlphaBlockDXT5 * dxtBlock)
|
void QuickCompress::compressDXT5A(const ColorBlock & rgba, AlphaBlockDXT5 * dxtBlock, int iterationCount/*=8*/)
|
||||||
{
|
{
|
||||||
uint8 alpha0 = 0;
|
uint8 alpha0 = 0;
|
||||||
uint8 alpha1 = 255;
|
uint8 alpha1 = 255;
|
||||||
|
@ -733,7 +554,7 @@ void QuickCompress::compressDXT5A(const ColorBlock & rgba, AlphaBlockDXT5 * dxtB
|
||||||
|
|
||||||
AlphaBlockDXT5 bestblock = block;
|
AlphaBlockDXT5 bestblock = block;
|
||||||
|
|
||||||
while(true)
|
for (int i = 0; i < iterationCount; i++)
|
||||||
{
|
{
|
||||||
optimizeAlpha8(rgba, &block);
|
optimizeAlpha8(rgba, &block);
|
||||||
uint error = computeAlphaIndices(rgba, &block);
|
uint error = computeAlphaIndices(rgba, &block);
|
||||||
|
@ -757,9 +578,8 @@ void QuickCompress::compressDXT5A(const ColorBlock & rgba, AlphaBlockDXT5 * dxtB
|
||||||
*dxtBlock = bestblock;
|
*dxtBlock = bestblock;
|
||||||
}
|
}
|
||||||
|
|
||||||
void QuickCompress::compressDXT5(const ColorBlock & rgba, BlockDXT5 * dxtBlock)
|
void QuickCompress::compressDXT5(const ColorBlock & rgba, BlockDXT5 * dxtBlock, int iterationCount/*=8*/)
|
||||||
{
|
{
|
||||||
compressDXT1(rgba, &dxtBlock->color);
|
compressDXT1(rgba, &dxtBlock->color);
|
||||||
compressDXT5A(rgba, &dxtBlock->alpha);
|
compressDXT5A(rgba, &dxtBlock->alpha, iterationCount);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -37,17 +37,13 @@ namespace nv
|
||||||
|
|
||||||
namespace QuickCompress
|
namespace QuickCompress
|
||||||
{
|
{
|
||||||
void compressDXT1(Color32 rgba, BlockDXT1 * dxtBlock);
|
|
||||||
void compressDXT1(const ColorBlock & rgba, BlockDXT1 * dxtBlock);
|
void compressDXT1(const ColorBlock & rgba, BlockDXT1 * dxtBlock);
|
||||||
void compressDXT1a(Color32 rgba, BlockDXT1 * dxtBlock);
|
|
||||||
void compressDXT1a(const ColorBlock & rgba, BlockDXT1 * dxtBlock);
|
void compressDXT1a(const ColorBlock & rgba, BlockDXT1 * dxtBlock);
|
||||||
void compressDXT1G(const ColorBlock & rgba, BlockDXT1 * block);
|
|
||||||
|
|
||||||
void compressDXT3A(const ColorBlock & rgba, AlphaBlockDXT3 * dxtBlock);
|
|
||||||
void compressDXT3(const ColorBlock & rgba, BlockDXT3 * dxtBlock);
|
void compressDXT3(const ColorBlock & rgba, BlockDXT3 * dxtBlock);
|
||||||
|
|
||||||
void compressDXT5A(const ColorBlock & rgba, AlphaBlockDXT5 * dxtBlock);
|
void compressDXT5A(const ColorBlock & rgba, AlphaBlockDXT5 * dxtBlock, int iterationCount=8);
|
||||||
void compressDXT5(const ColorBlock & rgba, BlockDXT5 * dxtBlock);
|
void compressDXT5(const ColorBlock & rgba, BlockDXT5 * dxtBlock, int iterationCount=8);
|
||||||
}
|
}
|
||||||
} // nv namespace
|
} // nv namespace
|
||||||
|
|
||||||
|
|
|
@ -159,7 +159,7 @@ __device__ void loadColorBlock(const uint * image, float3 colors[16], float3 sum
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
__device__ void loadColorBlock(const uint * image, float3 colors[16], float3 sums[16], float weights[16], int xrefs[16])
|
__device__ void loadColorBlock(const uint * image, float3 colors[16], float3 sums[16], float weights[16], int xrefs[16], int * sameColor)
|
||||||
{
|
{
|
||||||
const int bid = blockIdx.x;
|
const int bid = blockIdx.x;
|
||||||
const int idx = threadIdx.x;
|
const int idx = threadIdx.x;
|
||||||
|
@ -189,6 +189,8 @@ __device__ void loadColorBlock(const uint * image, float3 colors[16], float3 sum
|
||||||
colorSums(colors, sums);
|
colorSums(colors, sums);
|
||||||
float3 axis = bestFitLine(colors, sums[0], kColorMetric);
|
float3 axis = bestFitLine(colors, sums[0], kColorMetric);
|
||||||
|
|
||||||
|
*sameColor = (axis == make_float3(0, 0, 0));
|
||||||
|
|
||||||
dps[idx] = dot(rawColors[idx], axis);
|
dps[idx] = dot(rawColors[idx], axis);
|
||||||
|
|
||||||
#if __DEVICE_EMULATION__
|
#if __DEVICE_EMULATION__
|
||||||
|
@ -798,6 +800,39 @@ __global__ void compressDXT1(const uint * permutations, const uint * image, uint
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
__global__ void compressLevel4DXT1(const uint * permutations, const uint * image, uint2 * result)
|
||||||
|
{
|
||||||
|
__shared__ float3 colors[16];
|
||||||
|
__shared__ float3 sums[16];
|
||||||
|
__shared__ int xrefs[16];
|
||||||
|
__shared__ int sameColor;
|
||||||
|
|
||||||
|
loadColorBlock(image, colors, sums, xrefs, &sameColor);
|
||||||
|
|
||||||
|
__syncthreads();
|
||||||
|
|
||||||
|
if (sameColor)
|
||||||
|
{
|
||||||
|
if (threadIdx.x == 0) saveSingleColorBlockDXT1(colors[0], result);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
ushort bestStart, bestEnd;
|
||||||
|
uint bestPermutation;
|
||||||
|
|
||||||
|
__shared__ float errors[NUM_THREADS];
|
||||||
|
|
||||||
|
evalLevel4Permutations(colors, sums[0], permutations, bestStart, bestEnd, bestPermutation, errors);
|
||||||
|
|
||||||
|
// Use a parallel reduction to find minimum error.
|
||||||
|
const int minIdx = findMinError(errors);
|
||||||
|
|
||||||
|
// Only write the result of the winner thread.
|
||||||
|
if (threadIdx.x == minIdx)
|
||||||
|
{
|
||||||
|
saveBlockDXT1(bestStart, bestEnd, bestPermutation, xrefs, result);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
__global__ void compressWeightedDXT1(const uint * permutations, const uint * image, uint2 * result)
|
__global__ void compressWeightedDXT1(const uint * permutations, const uint * image, uint2 * result)
|
||||||
{
|
{
|
||||||
|
@ -805,11 +840,18 @@ __global__ void compressWeightedDXT1(const uint * permutations, const uint * ima
|
||||||
__shared__ float3 sums[16];
|
__shared__ float3 sums[16];
|
||||||
__shared__ float weights[16];
|
__shared__ float weights[16];
|
||||||
__shared__ int xrefs[16];
|
__shared__ int xrefs[16];
|
||||||
|
__shared__ int sameColor;
|
||||||
|
|
||||||
loadColorBlock(image, colors, sums, weights, xrefs);
|
loadColorBlock(image, colors, sums, weights, xrefs, &sameColor);
|
||||||
|
|
||||||
__syncthreads();
|
__syncthreads();
|
||||||
|
|
||||||
|
if (sameColor)
|
||||||
|
{
|
||||||
|
if (threadIdx.x == 0) saveSingleColorBlockDXT1(colors[0], result);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
ushort bestStart, bestEnd;
|
ushort bestStart, bestEnd;
|
||||||
uint bestPermutation;
|
uint bestPermutation;
|
||||||
|
|
||||||
|
@ -1033,6 +1075,11 @@ extern "C" void compressKernelDXT1(uint blockNum, uint * d_data, uint * d_result
|
||||||
compressDXT1<<<blockNum, NUM_THREADS>>>(d_bitmaps, d_data, (uint2 *)d_result);
|
compressDXT1<<<blockNum, NUM_THREADS>>>(d_bitmaps, d_data, (uint2 *)d_result);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
extern "C" void compressKernelDXT1_Level4(uint blockNum, uint * d_data, uint * d_result, uint * d_bitmaps)
|
||||||
|
{
|
||||||
|
compressLevel4DXT1<<<blockNum, NUM_THREADS>>>(d_bitmaps, d_data, (uint2 *)d_result);
|
||||||
|
}
|
||||||
|
|
||||||
extern "C" void compressWeightedKernelDXT1(uint blockNum, uint * d_data, uint * d_result, uint * d_bitmaps)
|
extern "C" void compressWeightedKernelDXT1(uint blockNum, uint * d_data, uint * d_result, uint * d_bitmaps)
|
||||||
{
|
{
|
||||||
compressWeightedDXT1<<<blockNum, NUM_THREADS>>>(d_bitmaps, d_data, (uint2 *)d_result);
|
compressWeightedDXT1<<<blockNum, NUM_THREADS>>>(d_bitmaps, d_data, (uint2 *)d_result);
|
||||||
|
|
|
@ -30,6 +30,7 @@
|
||||||
#include <nvtt/CompressionOptions.h>
|
#include <nvtt/CompressionOptions.h>
|
||||||
#include <nvtt/OutputOptions.h>
|
#include <nvtt/OutputOptions.h>
|
||||||
#include <nvtt/QuickCompressDXT.h>
|
#include <nvtt/QuickCompressDXT.h>
|
||||||
|
#include <nvtt/OptimalCompressDXT.h>
|
||||||
|
|
||||||
#include "CudaCompressDXT.h"
|
#include "CudaCompressDXT.h"
|
||||||
#include "CudaUtils.h"
|
#include "CudaUtils.h"
|
||||||
|
@ -52,6 +53,7 @@ using namespace nvtt;
|
||||||
|
|
||||||
extern "C" void setupCompressKernel(const float weights[3]);
|
extern "C" void setupCompressKernel(const float weights[3]);
|
||||||
extern "C" void compressKernelDXT1(uint blockNum, uint * d_data, uint * d_result, uint * d_bitmaps);
|
extern "C" void compressKernelDXT1(uint blockNum, uint * d_data, uint * d_result, uint * d_bitmaps);
|
||||||
|
extern "C" void compressKernelDXT1_Level4(uint blockNum, uint * d_data, uint * d_result, uint * d_bitmaps);
|
||||||
extern "C" void compressWeightedKernelDXT1(uint blockNum, uint * d_data, uint * d_result, uint * d_bitmaps);
|
extern "C" void compressWeightedKernelDXT1(uint blockNum, uint * d_data, uint * d_result, uint * d_bitmaps);
|
||||||
|
|
||||||
#include "Bitmaps.h" // @@ Rename to BitmapTable.h
|
#include "Bitmaps.h" // @@ Rename to BitmapTable.h
|
||||||
|
@ -118,20 +120,25 @@ bool CudaCompressor::isValid() const
|
||||||
|
|
||||||
// @@ This code is very repetitive and needs to be cleaned up.
|
// @@ This code is very repetitive and needs to be cleaned up.
|
||||||
|
|
||||||
|
void CudaCompressor::setImage(const Image * image, nvtt::AlphaMode alphaMode)
|
||||||
|
{
|
||||||
|
m_image = image;
|
||||||
|
m_alphaMode = alphaMode;
|
||||||
|
}
|
||||||
|
|
||||||
/// Compress image using CUDA.
|
/// Compress image using CUDA.
|
||||||
void CudaCompressor::compressDXT1(const Image * image, const OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions)
|
void CudaCompressor::compressDXT1(const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions)
|
||||||
{
|
{
|
||||||
nvDebugCheck(cuda::isHardwarePresent());
|
nvDebugCheck(cuda::isHardwarePresent());
|
||||||
#if defined HAVE_CUDA
|
#if defined HAVE_CUDA
|
||||||
|
|
||||||
// Image size in blocks.
|
// Image size in blocks.
|
||||||
const uint w = (image->width() + 3) / 4;
|
const uint w = (m_image->width() + 3) / 4;
|
||||||
const uint h = (image->height() + 3) / 4;
|
const uint h = (m_image->height() + 3) / 4;
|
||||||
|
|
||||||
uint imageSize = w * h * 16 * sizeof(Color32);
|
uint imageSize = w * h * 16 * sizeof(Color32);
|
||||||
uint * blockLinearImage = (uint *) malloc(imageSize);
|
uint * blockLinearImage = (uint *) malloc(imageSize);
|
||||||
convertToBlockLinear(image, blockLinearImage); // @@ Do this in parallel with the GPU, or in the GPU!
|
convertToBlockLinear(m_image, blockLinearImage); // @@ Do this in parallel with the GPU, or in the GPU!
|
||||||
|
|
||||||
const uint blockNum = w * h;
|
const uint blockNum = w * h;
|
||||||
const uint compressedSize = blockNum * 8;
|
const uint compressedSize = blockNum * 8;
|
||||||
|
@ -176,7 +183,7 @@ void CudaCompressor::compressDXT1(const Image * image, const OutputOptions::Priv
|
||||||
}
|
}
|
||||||
|
|
||||||
clock_t end = clock();
|
clock_t end = clock();
|
||||||
printf("\rCUDA time taken: %.3f seconds\n", float(end-start) / CLOCKS_PER_SEC);
|
//printf("\rCUDA time taken: %.3f seconds\n", float(end-start) / CLOCKS_PER_SEC);
|
||||||
|
|
||||||
free(blockLinearImage);
|
free(blockLinearImage);
|
||||||
|
|
||||||
|
@ -190,18 +197,18 @@ void CudaCompressor::compressDXT1(const Image * image, const OutputOptions::Priv
|
||||||
|
|
||||||
|
|
||||||
/// Compress image using CUDA.
|
/// Compress image using CUDA.
|
||||||
void CudaCompressor::compressDXT3(const Image * image, const OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions)
|
void CudaCompressor::compressDXT3(const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions)
|
||||||
{
|
{
|
||||||
nvDebugCheck(cuda::isHardwarePresent());
|
nvDebugCheck(cuda::isHardwarePresent());
|
||||||
#if defined HAVE_CUDA
|
#if defined HAVE_CUDA
|
||||||
|
|
||||||
// Image size in blocks.
|
// Image size in blocks.
|
||||||
const uint w = (image->width() + 3) / 4;
|
const uint w = (m_image->width() + 3) / 4;
|
||||||
const uint h = (image->height() + 3) / 4;
|
const uint h = (m_image->height() + 3) / 4;
|
||||||
|
|
||||||
uint imageSize = w * h * 16 * sizeof(Color32);
|
uint imageSize = w * h * 16 * sizeof(Color32);
|
||||||
uint * blockLinearImage = (uint *) malloc(imageSize);
|
uint * blockLinearImage = (uint *) malloc(imageSize);
|
||||||
convertToBlockLinear(image, blockLinearImage);
|
convertToBlockLinear(m_image, blockLinearImage);
|
||||||
|
|
||||||
const uint blockNum = w * h;
|
const uint blockNum = w * h;
|
||||||
const uint compressedSize = blockNum * 8;
|
const uint compressedSize = blockNum * 8;
|
||||||
|
@ -221,13 +228,20 @@ void CudaCompressor::compressDXT3(const Image * image, const OutputOptions::Priv
|
||||||
cudaMemcpy(m_data, blockLinearImage + bn * 16, count * 64, cudaMemcpyHostToDevice);
|
cudaMemcpy(m_data, blockLinearImage + bn * 16, count * 64, cudaMemcpyHostToDevice);
|
||||||
|
|
||||||
// Launch kernel.
|
// Launch kernel.
|
||||||
|
if (m_alphaMode == AlphaMode_Transparency)
|
||||||
|
{
|
||||||
compressWeightedKernelDXT1(count, m_data, m_result, m_bitmapTable);
|
compressWeightedKernelDXT1(count, m_data, m_result, m_bitmapTable);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
compressKernelDXT1_Level4(count, m_data, m_result, m_bitmapTable);
|
||||||
|
}
|
||||||
|
|
||||||
// Compress alpha in parallel with the GPU.
|
// Compress alpha in parallel with the GPU.
|
||||||
for (uint i = 0; i < count; i++)
|
for (uint i = 0; i < count; i++)
|
||||||
{
|
{
|
||||||
ColorBlock rgba(blockLinearImage + (bn + i) * 16);
|
ColorBlock rgba(blockLinearImage + (bn + i) * 16);
|
||||||
QuickCompress::compressDXT3A(rgba, alphaBlocks + i);
|
OptimalCompress::compressDXT3A(rgba, alphaBlocks + i);
|
||||||
}
|
}
|
||||||
|
|
||||||
// Check for errors.
|
// Check for errors.
|
||||||
|
@ -259,7 +273,7 @@ void CudaCompressor::compressDXT3(const Image * image, const OutputOptions::Priv
|
||||||
}
|
}
|
||||||
|
|
||||||
clock_t end = clock();
|
clock_t end = clock();
|
||||||
printf("\rCUDA time taken: %.3f seconds\n", float(end-start) / CLOCKS_PER_SEC);
|
//printf("\rCUDA time taken: %.3f seconds\n", float(end-start) / CLOCKS_PER_SEC);
|
||||||
|
|
||||||
free(alphaBlocks);
|
free(alphaBlocks);
|
||||||
free(blockLinearImage);
|
free(blockLinearImage);
|
||||||
|
@ -274,18 +288,18 @@ void CudaCompressor::compressDXT3(const Image * image, const OutputOptions::Priv
|
||||||
|
|
||||||
|
|
||||||
/// Compress image using CUDA.
|
/// Compress image using CUDA.
|
||||||
void CudaCompressor::compressDXT5(const Image * image, const OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions)
|
void CudaCompressor::compressDXT5(const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions)
|
||||||
{
|
{
|
||||||
nvDebugCheck(cuda::isHardwarePresent());
|
nvDebugCheck(cuda::isHardwarePresent());
|
||||||
#if defined HAVE_CUDA
|
#if defined HAVE_CUDA
|
||||||
|
|
||||||
// Image size in blocks.
|
// Image size in blocks.
|
||||||
const uint w = (image->width() + 3) / 4;
|
const uint w = (m_image->width() + 3) / 4;
|
||||||
const uint h = (image->height() + 3) / 4;
|
const uint h = (m_image->height() + 3) / 4;
|
||||||
|
|
||||||
uint imageSize = w * h * 16 * sizeof(Color32);
|
uint imageSize = w * h * 16 * sizeof(Color32);
|
||||||
uint * blockLinearImage = (uint *) malloc(imageSize);
|
uint * blockLinearImage = (uint *) malloc(imageSize);
|
||||||
convertToBlockLinear(image, blockLinearImage);
|
convertToBlockLinear(m_image, blockLinearImage);
|
||||||
|
|
||||||
const uint blockNum = w * h;
|
const uint blockNum = w * h;
|
||||||
const uint compressedSize = blockNum * 8;
|
const uint compressedSize = blockNum * 8;
|
||||||
|
@ -305,7 +319,14 @@ void CudaCompressor::compressDXT5(const Image * image, const OutputOptions::Priv
|
||||||
cudaMemcpy(m_data, blockLinearImage + bn * 16, count * 64, cudaMemcpyHostToDevice);
|
cudaMemcpy(m_data, blockLinearImage + bn * 16, count * 64, cudaMemcpyHostToDevice);
|
||||||
|
|
||||||
// Launch kernel.
|
// Launch kernel.
|
||||||
|
if (m_alphaMode == AlphaMode_Transparency)
|
||||||
|
{
|
||||||
compressWeightedKernelDXT1(count, m_data, m_result, m_bitmapTable);
|
compressWeightedKernelDXT1(count, m_data, m_result, m_bitmapTable);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
compressKernelDXT1_Level4(count, m_data, m_result, m_bitmapTable);
|
||||||
|
}
|
||||||
|
|
||||||
// Compress alpha in parallel with the GPU.
|
// Compress alpha in parallel with the GPU.
|
||||||
for (uint i = 0; i < count; i++)
|
for (uint i = 0; i < count; i++)
|
||||||
|
@ -343,7 +364,7 @@ void CudaCompressor::compressDXT5(const Image * image, const OutputOptions::Priv
|
||||||
}
|
}
|
||||||
|
|
||||||
clock_t end = clock();
|
clock_t end = clock();
|
||||||
printf("\rCUDA time taken: %.3f seconds\n", float(end-start) / CLOCKS_PER_SEC);
|
//printf("\rCUDA time taken: %.3f seconds\n", float(end-start) / CLOCKS_PER_SEC);
|
||||||
|
|
||||||
free(alphaBlocks);
|
free(alphaBlocks);
|
||||||
free(blockLinearImage);
|
free(blockLinearImage);
|
||||||
|
@ -357,185 +378,3 @@ void CudaCompressor::compressDXT5(const Image * image, const OutputOptions::Priv
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#if 0
|
|
||||||
|
|
||||||
class Task
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
explicit Task(uint numBlocks) : blockMaxCount(numBlocks), blockCount(0)
|
|
||||||
{
|
|
||||||
// System memory allocations.
|
|
||||||
blockLinearImage = new uint[blockMaxCount * 16];
|
|
||||||
xrefs = new uint[blockMaxCount * 16];
|
|
||||||
|
|
||||||
// Device memory allocations.
|
|
||||||
cudaMalloc((void**) &d_blockLinearImage, blockMaxCount * 16 * sizeof(uint));
|
|
||||||
cudaMalloc((void**) &d_compressedImage, blockMaxCount * 8U);
|
|
||||||
|
|
||||||
// @@ Check for allocation errors.
|
|
||||||
}
|
|
||||||
|
|
||||||
~Task()
|
|
||||||
{
|
|
||||||
delete [] blockLinearImage;
|
|
||||||
delete [] xrefs;
|
|
||||||
|
|
||||||
cudaFree(d_blockLinearImage);
|
|
||||||
cudaFree(d_compressedImage);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
void addColorBlock(const ColorBlock & rgba)
|
|
||||||
{
|
|
||||||
nvDebugCheck(!isFull());
|
|
||||||
|
|
||||||
// @@ Count unique colors?
|
|
||||||
/*
|
|
||||||
// Convert colors to vectors.
|
|
||||||
Array<Vector3> pointArray(16);
|
|
||||||
|
|
||||||
for(int i = 0; i < 16; i++) {
|
|
||||||
const Color32 color = rgba.color(i);
|
|
||||||
pointArray.append(Vector3(color.r, color.g, color.b));
|
|
||||||
}
|
|
||||||
|
|
||||||
// Find best fit line.
|
|
||||||
const Vector3 axis = Fit::bestLine(pointArray).direction();
|
|
||||||
|
|
||||||
// Project points to axis.
|
|
||||||
float dps[16];
|
|
||||||
uint * order = &xrefs[blockCount * 16];
|
|
||||||
|
|
||||||
for (uint i = 0; i < 16; ++i)
|
|
||||||
{
|
|
||||||
dps[i] = dot(pointArray[i], axis);
|
|
||||||
order[i] = i;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Sort them.
|
|
||||||
for (uint i = 0; i < 16; ++i)
|
|
||||||
{
|
|
||||||
for (uint j = i; j > 0 && dps[j] < dps[j - 1]; --j)
|
|
||||||
{
|
|
||||||
swap(dps[j], dps[j - 1]);
|
|
||||||
swap(order[j], order[j - 1]);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
// Write sorted colors to blockLinearImage.
|
|
||||||
for(uint i = 0; i < 16; ++i)
|
|
||||||
{
|
|
||||||
// blockLinearImage[blockCount * 16 + i] = rgba.color(order[i]);
|
|
||||||
blockLinearImage[blockCount * 16 + i] = rgba.color(i);
|
|
||||||
}
|
|
||||||
|
|
||||||
++blockCount;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool isFull()
|
|
||||||
{
|
|
||||||
nvDebugCheck(blockCount <= blockMaxCount);
|
|
||||||
return blockCount == blockMaxCount;
|
|
||||||
}
|
|
||||||
|
|
||||||
void flush(const OutputOptions::Private & outputOptions)
|
|
||||||
{
|
|
||||||
if (blockCount == 0)
|
|
||||||
{
|
|
||||||
// Nothing to do.
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Copy input color blocks.
|
|
||||||
cudaMemcpy(d_blockLinearImage, blockLinearImage, blockCount * 64, cudaMemcpyHostToDevice);
|
|
||||||
|
|
||||||
// Launch kernel.
|
|
||||||
compressKernelDXT1(blockCount, d_blockLinearImage, d_compressedImage, d_bitmaps);
|
|
||||||
|
|
||||||
// Check for errors.
|
|
||||||
cudaError_t err = cudaGetLastError();
|
|
||||||
if (err != cudaSuccess)
|
|
||||||
{
|
|
||||||
nvDebug("CUDA Error: %s\n", cudaGetErrorString(err));
|
|
||||||
|
|
||||||
if (outputOptions.errorHandler != NULL)
|
|
||||||
{
|
|
||||||
outputOptions.errorHandler->error(Error_CudaError);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Copy result to host, overwrite swizzled image.
|
|
||||||
uint * compressedImage = blockLinearImage;
|
|
||||||
cudaMemcpy(compressedImage, d_compressedImage, blockCount * 8, cudaMemcpyDeviceToHost);
|
|
||||||
|
|
||||||
// @@ Sort block indices.
|
|
||||||
|
|
||||||
// Output result.
|
|
||||||
if (outputOptions.outputHandler != NULL)
|
|
||||||
{
|
|
||||||
// outputOptions.outputHandler->writeData(compressedImage, blockCount * 8);
|
|
||||||
}
|
|
||||||
|
|
||||||
blockCount = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
|
|
||||||
const uint blockMaxCount;
|
|
||||||
uint blockCount;
|
|
||||||
|
|
||||||
uint * blockLinearImage;
|
|
||||||
uint * xrefs;
|
|
||||||
|
|
||||||
uint * d_blockLinearImage;
|
|
||||||
uint * d_compressedImage;
|
|
||||||
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
void nv::cudaCompressDXT1_2(const Image * image, const OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions)
|
|
||||||
{
|
|
||||||
#if defined HAVE_CUDA
|
|
||||||
const uint w = image->width();
|
|
||||||
const uint h = image->height();
|
|
||||||
|
|
||||||
const uint blockNum = ((w + 3) / 4) * ((h + 3) / 4);
|
|
||||||
const uint blockMax = 32768; // 49152, 65535
|
|
||||||
|
|
||||||
setupCompressKernelDXT1(compressionOptions.colorWeight.ptr());
|
|
||||||
|
|
||||||
ColorBlock rgba;
|
|
||||||
Task task(min(blockNum, blockMax));
|
|
||||||
|
|
||||||
clock_t start = clock();
|
|
||||||
|
|
||||||
for (uint y = 0; y < h; y += 4) {
|
|
||||||
for (uint x = 0; x < w; x += 4) {
|
|
||||||
|
|
||||||
rgba.init(image, x, y);
|
|
||||||
|
|
||||||
task.addColorBlock(rgba);
|
|
||||||
|
|
||||||
if (task.isFull())
|
|
||||||
{
|
|
||||||
task.flush(outputOptions);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
task.flush(outputOptions);
|
|
||||||
|
|
||||||
clock_t end = clock();
|
|
||||||
printf("\rCUDA time taken: %.3f seconds\n", float(end-start) / CLOCKS_PER_SEC);
|
|
||||||
|
|
||||||
#else
|
|
||||||
if (outputOptions.errorHandler != NULL)
|
|
||||||
{
|
|
||||||
outputOptions.errorHandler->error(Error_CudaError);
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif // 0
|
|
||||||
|
|
|
@ -39,15 +39,20 @@ namespace nv
|
||||||
|
|
||||||
bool isValid() const;
|
bool isValid() const;
|
||||||
|
|
||||||
void compressDXT1(const Image * image, const nvtt::OutputOptions::Private & outputOptions, const nvtt::CompressionOptions::Private & compressionOptions);
|
void setImage(const Image * image, nvtt::AlphaMode alphaMode);
|
||||||
void compressDXT3(const Image * image, const nvtt::OutputOptions::Private & outputOptions, const nvtt::CompressionOptions::Private & compressionOptions);
|
|
||||||
void compressDXT5(const Image * image, const nvtt::OutputOptions::Private & outputOptions, const nvtt::CompressionOptions::Private & compressionOptions);
|
void compressDXT1(const nvtt::CompressionOptions::Private & compressionOptions, const nvtt::OutputOptions::Private & outputOptions);
|
||||||
|
void compressDXT3(const nvtt::CompressionOptions::Private & compressionOptions, const nvtt::OutputOptions::Private & outputOptions);
|
||||||
|
void compressDXT5(const nvtt::CompressionOptions::Private & compressionOptions, const nvtt::OutputOptions::Private & outputOptions);
|
||||||
|
|
||||||
private:
|
private:
|
||||||
|
|
||||||
uint * m_bitmapTable;
|
uint * m_bitmapTable;
|
||||||
uint * m_data;
|
uint * m_data;
|
||||||
uint * m_result;
|
uint * m_result;
|
||||||
|
|
||||||
|
const Image * m_image;
|
||||||
|
nvtt::AlphaMode m_alphaMode;
|
||||||
};
|
};
|
||||||
|
|
||||||
} // nv namespace
|
} // nv namespace
|
||||||
|
|
|
@ -74,7 +74,7 @@ bool nv::cuda::isHardwarePresent()
|
||||||
{
|
{
|
||||||
#if defined HAVE_CUDA
|
#if defined HAVE_CUDA
|
||||||
#if NV_OS_WIN32
|
#if NV_OS_WIN32
|
||||||
if (isWindowsVista()) return false;
|
//if (isWindowsVista()) return false;
|
||||||
//if (isWindowsVista() || !isWow32()) return false;
|
//if (isWindowsVista() || !isWow32()) return false;
|
||||||
#endif
|
#endif
|
||||||
int count = deviceCount();
|
int count = deviceCount();
|
||||||
|
|
|
@ -29,6 +29,8 @@
|
||||||
#include "colourblock.h"
|
#include "colourblock.h"
|
||||||
#include <cfloat>
|
#include <cfloat>
|
||||||
|
|
||||||
|
#include "fastclusterlookup.inl"
|
||||||
|
|
||||||
namespace squish {
|
namespace squish {
|
||||||
|
|
||||||
FastClusterFit::FastClusterFit()
|
FastClusterFit::FastClusterFit()
|
||||||
|
@ -97,91 +99,6 @@ void FastClusterFit::SetColourSet( ColourSet const* colours, int flags )
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
struct Precomp {
|
|
||||||
float alpha2_sum;
|
|
||||||
float beta2_sum;
|
|
||||||
float alphabeta_sum;
|
|
||||||
float factor;
|
|
||||||
};
|
|
||||||
|
|
||||||
static SQUISH_ALIGN_16 Precomp s_threeElement[153];
|
|
||||||
static SQUISH_ALIGN_16 Precomp s_fourElement[969];
|
|
||||||
|
|
||||||
void FastClusterFit::DoPrecomputation()
|
|
||||||
{
|
|
||||||
int i = 0;
|
|
||||||
|
|
||||||
// Three element clusters:
|
|
||||||
for( int c0 = 0; c0 <= 16; c0++) // At least two clusters.
|
|
||||||
{
|
|
||||||
for( int c1 = 0; c1 <= 16-c0; c1++)
|
|
||||||
{
|
|
||||||
int c2 = 16 - c0 - c1;
|
|
||||||
|
|
||||||
/*if (c2 == 16) {
|
|
||||||
// a = b = x2 / 16
|
|
||||||
s_threeElement[i].alpha2_sum = 0;
|
|
||||||
s_threeElement[i].beta2_sum = 16;
|
|
||||||
s_threeElement[i].alphabeta_sum = -16;
|
|
||||||
s_threeElement[i].factor = 1.0f / 256.0f;
|
|
||||||
}
|
|
||||||
else if (c0 == 16) {
|
|
||||||
// a = b = x0 / 16
|
|
||||||
s_threeElement[i].alpha2_sum = 16;
|
|
||||||
s_threeElement[i].beta2_sum = 0;
|
|
||||||
s_threeElement[i].alphabeta_sum = -16;
|
|
||||||
s_threeElement[i].factor = 1.0f / 256.0f;
|
|
||||||
}
|
|
||||||
else*/ {
|
|
||||||
s_threeElement[i].alpha2_sum = c0 + c1 * 0.25f;
|
|
||||||
s_threeElement[i].beta2_sum = c2 + c1 * 0.25f;
|
|
||||||
s_threeElement[i].alphabeta_sum = c1 * 0.25f;
|
|
||||||
s_threeElement[i].factor = 1.0f / (s_threeElement[i].alpha2_sum * s_threeElement[i].beta2_sum - s_threeElement[i].alphabeta_sum * s_threeElement[i].alphabeta_sum);
|
|
||||||
}
|
|
||||||
|
|
||||||
i++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
//printf("%d three cluster elements\n", i);
|
|
||||||
|
|
||||||
// Four element clusters:
|
|
||||||
i = 0;
|
|
||||||
for( int c0 = 0; c0 <= 16; c0++)
|
|
||||||
{
|
|
||||||
for( int c1 = 0; c1 <= 16-c0; c1++)
|
|
||||||
{
|
|
||||||
for( int c2 = 0; c2 <= 16-c0-c1; c2++)
|
|
||||||
{
|
|
||||||
int c3 = 16 - c0 - c1 - c2;
|
|
||||||
|
|
||||||
/*if (c3 == 16) {
|
|
||||||
// a = b = x3 / 16
|
|
||||||
s_fourElement[i].alpha2_sum = 16.0f;
|
|
||||||
s_fourElement[i].beta2_sum = 0.0f;
|
|
||||||
s_fourElement[i].alphabeta_sum = -16.0f;
|
|
||||||
s_fourElement[i].factor = 1.0f / 256.0f;
|
|
||||||
}
|
|
||||||
else if (c0 == 16) {
|
|
||||||
// a = b = x0 / 16
|
|
||||||
s_fourElement[i].alpha2_sum = 0.0f;
|
|
||||||
s_fourElement[i].beta2_sum = 16.0f;
|
|
||||||
s_fourElement[i].alphabeta_sum = -16.0f;
|
|
||||||
s_fourElement[i].factor = 1.0f / 256.0f;
|
|
||||||
}
|
|
||||||
else*/ {
|
|
||||||
s_fourElement[i].alpha2_sum = c0 + c1 * (4.0f/9.0f) + c2 * (1.0f/9.0f);
|
|
||||||
s_fourElement[i].beta2_sum = c3 + c2 * (4.0f/9.0f) + c1 * (1.0f/9.0f);
|
|
||||||
s_fourElement[i].alphabeta_sum = (c1 + c2) * (2.0f/9.0f);
|
|
||||||
s_fourElement[i].factor = 1.0f / (s_fourElement[i].alpha2_sum * s_fourElement[i].beta2_sum - s_fourElement[i].alphabeta_sum * s_fourElement[i].alphabeta_sum);
|
|
||||||
}
|
|
||||||
|
|
||||||
i++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
//printf("%d four cluster elements\n", i);
|
|
||||||
}
|
|
||||||
|
|
||||||
void FastClusterFit::SetMetric(float r, float g, float b)
|
void FastClusterFit::SetMetric(float r, float g, float b)
|
||||||
{
|
{
|
||||||
#if SQUISH_USE_SIMD
|
#if SQUISH_USE_SIMD
|
||||||
|
|
|
@ -44,8 +44,6 @@ public:
|
||||||
void SetMetric(float r, float g, float b);
|
void SetMetric(float r, float g, float b);
|
||||||
float GetBestError() const;
|
float GetBestError() const;
|
||||||
|
|
||||||
static void DoPrecomputation();
|
|
||||||
|
|
||||||
// Make them public
|
// Make them public
|
||||||
virtual void Compress3( void* block );
|
virtual void Compress3( void* block );
|
||||||
virtual void Compress4( void* block );
|
virtual void Compress4( void* block );
|
||||||
|
|
1135
src/nvtt/squish/fastclusterlookup.inl
Normal file
1135
src/nvtt/squish/fastclusterlookup.inl
Normal file
File diff suppressed because it is too large
Load Diff
|
@ -42,11 +42,11 @@ struct MyOutputHandler : public nvtt::OutputHandler
|
||||||
MyOutputHandler(const char * name) : total(0), progress(0), percentage(0), stream(new nv::StdOutputStream(name)) {}
|
MyOutputHandler(const char * name) : total(0), progress(0), percentage(0), stream(new nv::StdOutputStream(name)) {}
|
||||||
virtual ~MyOutputHandler() { delete stream; }
|
virtual ~MyOutputHandler() { delete stream; }
|
||||||
|
|
||||||
virtual void setTotal(int64 t)
|
void setTotal(int64 t)
|
||||||
{
|
{
|
||||||
total = t + 128;
|
total = t + 128;
|
||||||
}
|
}
|
||||||
virtual void setDisplayProgress(bool b)
|
void setDisplayProgress(bool b)
|
||||||
{
|
{
|
||||||
verbose = b;
|
verbose = b;
|
||||||
}
|
}
|
||||||
|
|
Loading…
Reference in New Issue
Block a user