Set executable property to dll

Make sure FreeImage declarations are not used when FreeImage is not available.

ChangeLog

@@ -1,3 +1,9 @@
+NVIDIA Texture Tools version 2.0.3
+ * 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.
+
 NVIDIA Texture Tools version 2.0.2
  * Fix copy ctor error reported by Richard Sim.
  * Fix indexMirror error reported by Chris Lambert.

VERSION

@@ -1 +1 @@
-2.0.2
+2.0.3

project/vc8/nvtt/nvtt.rc

@@ -53,8 +53,8 @@ END
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 2,0,2,0
- PRODUCTVERSION 2,0,2,0
+ FILEVERSION 2,0,3,0
+ PRODUCTVERSION 2,0,3,0
  FILEFLAGSMASK 0x17L
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -71,12 +71,12 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "NVIDIA Corporation"
             VALUE "FileDescription", "NVIDIA Texture Tools Dynamic Link Library"
-            VALUE "FileVersion", "2, 0, 2, 0"
+            VALUE "FileVersion", "2, 0, 3, 0"
             VALUE "InternalName", "nvtt"
             VALUE "LegalCopyright", "Copyright (C) 2007"
             VALUE "OriginalFilename", "nvtt.dll"
             VALUE "ProductName", "NVIDIA Texture Tools Dynamic Link Library"
-            VALUE "ProductVersion", "2, 0, 2, 0"
+            VALUE "ProductVersion", "2, 0, 3, 0"
         END
     END
     BLOCK "VarFileInfo"

project/vc8/nvtt/nvtt.vcproj

@@ -711,7 +711,7 @@
 					>
 					<Tool
 						Name="VCCustomBuildTool"
-						CommandLine="&quot;$(CUDA_BIN_PATH)\nvcc.exe&quot; -m32 -ccbin &quot;$(VCInstallDir)bin&quot; -c -DNDEBUG -DWIN32 -D_CONSOLE -D_MBCS -Xcompiler /EHsc,/W3,/nologo,/Wp64,/O2,/Zi,/MD -I&quot;$(CUDA_INC_PATH)&quot; -I./ -o $(IntDir)\$(InputName).obj ..\\..\\..\\src\\nvtt\\cuda\\CompressKernel.cu"
+						CommandLine="&quot;$(CUDA_BIN_PATH)\nvcc.exe&quot; -m32 -ccbin &quot;$(VCInstallDir)bin&quot; -c -DNDEBUG -DWIN32 -D_CONSOLE -D_MBCS -Xcompiler /EHsc,/W3,/nologo,/Wp64,/O2,/Zi,/MD -I&quot;$(CUDA_INC_PATH)&quot; -I./ -o $(IntDir)\$(InputName).obj ..\\..\\..\\src\\nvtt\\cuda\\CompressKernel.cu&#x0D;&#x0A;"
 						AdditionalDependencies="CudaMath.h"
 						Outputs="$(IntDir)\$(InputName).obj"
 					/>
@@ -849,10 +849,6 @@
 				RelativePath="..\..\..\src\nvtt\cuda\CudaUtils.cpp"
 				>
 			</File>
-			<File
-				RelativePath="..\..\..\src\nvtt\FastCompressDXT.cpp"
-				>
-			</File>
 			<File
 				RelativePath="..\..\..\src\nvtt\InputOptions.cpp"
 				>
@@ -865,6 +861,10 @@
 				RelativePath="..\..\..\src\nvtt\nvtt_wrapper.cpp"
 				>
 			</File>
+			<File
+				RelativePath="..\..\..\src\nvtt\OptimalCompressDXT.cpp"
+				>
+			</File>
 			<File
 				RelativePath="..\..\..\src\nvtt\OutputOptions.cpp"
 				>
@@ -911,10 +911,6 @@
 				RelativePath="..\..\..\src\nvtt\cuda\CudaUtils.h"
 				>
 			</File>
-			<File
-				RelativePath="..\..\..\src\nvtt\FastCompressDXT.h"
-				>
-			</File>
 			<File
 				RelativePath="..\..\..\src\nvtt\InputOptions.h"
 				>
@@ -927,6 +923,10 @@
 				RelativePath="..\..\..\src\nvtt\nvtt_wrapper.h"
 				>
 			</File>
+			<File
+				RelativePath="..\..\..\src\nvtt\OptimalCompressDXT.h"
+				>
+			</File>
 			<File
 				RelativePath="..\..\..\src\nvtt\OutputOptions.h"
 				>

src/nvimage/DirectDrawSurface.cpp

@@ -532,7 +532,7 @@ DDSHeader::DDSHeader()
 
 	// Store version information on the reserved header attributes.
 	this->reserved[9] = MAKEFOURCC('N', 'V', 'T', 'T');
-	this->reserved[10] = (2 << 16) | (0 << 8) | (2);	// major.minor.revision
+	this->reserved[10] = (2 << 16) | (0 << 8) | (3);	// major.minor.revision
 
 	this->pf.size = 32;
 	this->pf.flags = 0;

src/nvimage/FloatImage.cpp

@@ -376,7 +376,7 @@ FloatImage * FloatImage::fastDownSample() const
 	{
 		const uint n = w * h;
 		
-		if (n & 1)
+		if ((m_width * m_height) & 1)
 		{
 			const float scale = 1.0f / (2 * n + 1);
 			

src/nvtt/CMakeLists.txt

@@ -13,10 +13,10 @@ SET(NVTT_SRCS
 	CompressDXT.cpp
 	CompressRGB.h
 	CompressRGB.cpp
-	FastCompressDXT.h
-	FastCompressDXT.cpp
 	QuickCompressDXT.h
 	QuickCompressDXT.cpp
+	OptimalCompressDXT.h
+	OptimalCompressDXT.cpp
 	SingleColorLookup.h
 	CompressionOptions.h
 	CompressionOptions.cpp
@@ -84,7 +84,7 @@ TARGET_LINK_LIBRARIES(nvzoom nvcore nvmath nvimage)
 
 INSTALL(TARGETS nvcompress nvdecompress nvddsinfo nvimgdiff nvassemble nvzoom DESTINATION bin)
 
-# UI tools
+# UI tools
 IF(QT4_FOUND AND NOT MSVC)
 	SET(QT_USE_QTOPENGL TRUE)
 	INCLUDE_DIRECTORIES(${QT_INCLUDE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
@@ -106,7 +106,7 @@ IF(QT4_FOUND AND NOT MSVC)
 
 	ADD_EXECUTABLE(nvcompressui MACOSX_BUNDLE ${SRCS} ${UICS} ${MOCS})
 	TARGET_LINK_LIBRARIES(nvcompressui ${LIBS})
-
+
 ENDIF(QT4_FOUND AND NOT MSVC)
 
 

src/nvtt/CompressDXT.cpp

@@ -29,8 +29,8 @@
 
 #include "nvtt.h"
 #include "CompressDXT.h"
-#include "FastCompressDXT.h"
 #include "QuickCompressDXT.h"
+#include "OptimalCompressDXT.h"
 #include "CompressionOptions.h"
 #include "OutputOptions.h"
 
@@ -57,26 +57,33 @@ using namespace nv;
 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;
 	BlockDXT1 block;
 
 	for (uint y = 0; y < h; y += 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) {
 				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 h = image->height();
+	const uint w = m_image->width();
+	const uint h = m_image->height();
 	
 	ColorBlock rgba;
 	BlockDXT1 block;
 
 	for (uint y = 0; y < h; y += 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) {
 				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 h = image->height();
+	const uint w = m_image->width();
+	const uint h = m_image->height();
 	
 	ColorBlock rgba;
 	BlockDXT3 block;
 
 	for (uint y = 0; y < h; y += 4) {
 		for (uint x = 0; x < w; x += 4) {
-			rgba.init(image, x, y);
+			rgba.init(m_image, x, y);
+
 			QuickCompress::compressDXT3(rgba, &block);
 			
 			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 h = image->height();
+	const uint w = m_image->width();
+	const uint h = m_image->height();
 	
 	ColorBlock rgba;
 	BlockDXT5 block;
 
 	for (uint y = 0; y < h; y += 4) {
 		for (uint x = 0; x < w; x += 4) {
-			rgba.init(image, x, y);
-			//QuickCompress::compressDXT5(rgba, &block);	// @@ Use fast version!!
-			nv::compressBlock_BoundsRange(rgba, &block);
+			rgba.init(m_image, x, y);
+			
+			QuickCompress::compressDXT5(rgba, &block, 0);
 			
 			if (outputOptions.outputHandler != NULL) {
 				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 h = image->height();
+	const uint w = m_image->width();
+	const uint h = m_image->height();
 	
 	ColorBlock rgba;
 	BlockDXT5 block;
 
 	for (uint y = 0; y < h; y += 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();
 
-			//QuickCompress::compressDXT5(rgba, &block);	// @@ Use fast version!!
-			nv::compressBlock_BoundsRange(rgba, &block);
+			QuickCompress::compressDXT5(rgba, &block, 0);
 			
 			if (outputOptions.outputHandler != NULL) {
 				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)
 }
 
-
-void nv::fastCompressBC5(const Image * image, const nvtt::OutputOptions::Private & outputOptions)
+nv::SlowCompressor::~SlowCompressor()
 {
-	// @@ TODO
-	// compress red, green channels (X,Y)
 }
 
-
-void nv::doPrecomputation()
+void nv::SlowCompressor::setImage(const Image * image, nvtt::AlphaMode alphaMode)
 {
-	static bool done = false;	// @@ Stop using statics for reentrancy. Although the worst that could happen is that this stuff is precomputed multiple times.
-	
-	if (!done)
-	{
-		done = true;
-		squish::FastClusterFit::DoPrecomputation();
-	}
+	m_image = image;
+	m_alphaMode = alphaMode;
 }
 
-
-void nv::compressDXT1(const Image * image, const OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions)
+void nv::SlowCompressor::compressDXT1(const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions)
 {
-	const uint w = image->width();
-	const uint h = image->height();
+	const uint w = m_image->width();
+	const uint h = m_image->height();
 	
 	ColorBlock rgba;
 	BlockDXT1 block;
 
-	doPrecomputation();
-
 	//squish::WeightedClusterFit fit;
 	//squish::ClusterFit 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 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);
+				OptimalCompress::compressDXT1(rgba.color(0), &block);
 			}
 			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 h = image->height();
+	const uint w = m_image->width();
+	const uint h = m_image->height();
 	
 	ColorBlock rgba;
 	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 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
 			{
@@ -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 h = image->height();
+	const uint w = m_image->width();
+	const uint h = m_image->height();
 	
 	ColorBlock rgba;
 	BlockDXT3 block;
 	
 	squish::WeightedClusterFit fit;
+	//squish::FastClusterFit fit;
 	fit.SetMetric(compressionOptions.colorWeight.x(), compressionOptions.colorWeight.y(), compressionOptions.colorWeight.z());
 
 	for (uint y = 0; y < h; y += 4) {
 		for (uint x = 0; x < w; x += 4) {
 			
-			rgba.init(image, x, y);
+			rgba.init(m_image, x, y);
 			
 			// Compress explicit alpha.
-			QuickCompress::compressDXT3A(rgba, &block.alpha);
-			
+			OptimalCompress::compressDXT3A(rgba, &block.alpha);
+
 			// Compress color.
-			squish::ColourSet colours((uint8 *)rgba.colors(), squish::kWeightColourByAlpha);
-			fit.SetColourSet(&colours, 0);
-			fit.Compress(&block.color);
+			if (rgba.isSingleColor())
+			{
+				OptimalCompress::compressDXT1(rgba.color(0), &block.color);
+			}
+			else
+			{
+				squish::ColourSet colours((uint8 *)rgba.colors(), squish::kWeightColourByAlpha);
+				fit.SetColourSet(&colours, 0);
+				fit.Compress(&block.color);
+			}
 			
 			if (outputOptions.outputHandler != NULL) {
 				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 h = image->height();
+	const uint w = m_image->width();
+	const uint h = m_image->height();
 	
 	ColorBlock rgba;
 	BlockDXT5 block;
@@ -330,22 +331,29 @@ void nv::compressDXT5(const Image * image, const OutputOptions::Private & output
 	for (uint y = 0; y < h; y += 4) {
 		for (uint x = 0; x < w; x += 4) {
 			
-			rgba.init(image, x, y);
+			rgba.init(m_image, x, y);
 
 			// Compress alpha.
 			if (compressionOptions.quality == Quality_Highest)
 			{
-				compressBlock_BruteForce(rgba, &block.alpha);
+				OptimalCompress::compressDXT5A(rgba, &block.alpha);
 			}
 			else
 			{
 				QuickCompress::compressDXT5A(rgba, &block.alpha);
 			}
-
+		
 			// Compress color.
-			squish::ColourSet colours((uint8 *)rgba.colors(), squish::kWeightColourByAlpha);
-			fit.SetColourSet(&colours, 0);
-			fit.Compress(&block.color);
+			if (rgba.isSingleColor())
+			{
+				OptimalCompress::compressDXT1(rgba.color(0), &block.color);
+			}
+			else
+			{
+				squish::ColourSet colours((uint8 *)rgba.colors(), squish::kWeightColourByAlpha);
+				fit.SetColourSet(&colours, 0);
+				fit.Compress(&block.color);
+			}
 			
 			if (outputOptions.outputHandler != NULL) {
 				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 h = image->height();
+	const uint w = m_image->width();
+	const uint h = m_image->height();
 	
 	ColorBlock rgba;
 	BlockDXT5 block;
 	
-	doPrecomputation();
-
 	for (uint y = 0; y < h; y += 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();			
 			
 			// Compress X.
 			if (compressionOptions.quality == Quality_Highest)
 			{
-				compressBlock_BruteForce(rgba, &block.alpha);
+				OptimalCompress::compressDXT5A(rgba, &block.alpha);
 			}
 			else
 			{
@@ -384,7 +389,7 @@ void nv::compressDXT5n(const Image * image, const OutputOptions::Private & outpu
 			}
 			
 			// Compress Y.
-			QuickCompress::compressDXT1G(rgba, &block.color);
+			OptimalCompress::compressDXT1G(rgba, &block.color);
 			
 			if (outputOptions.outputHandler != NULL) {
 				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 h = image->height();
+	const uint w = m_image->width();
+	const uint h = m_image->height();
 	
 	ColorBlock rgba;
 	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 x = 0; x < w; x += 4) {
 			
-			rgba.init(image, x, y);
+			rgba.init(m_image, x, y);
 
 			if (compressionOptions.quality == Quality_Highest)
 			{
-				compressBlock_BruteForce(rgba, &block);
+				OptimalCompress::compressDXT5A(rgba, &block);
 			}
 			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 h = image->height();
+	const uint w = m_image->width();
+	const uint h = m_image->height();
 
 	ColorBlock xcolor;
 	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 x = 0; x < w; x += 4) {
 			
-			xcolor.init(image, x, y);
+			xcolor.init(m_image, x, y);
 			xcolor.splatX();
 			
-			ycolor.init(image, x, y);
+			ycolor.init(m_image, x, y);
 			ycolor.splatY();
 
 			if (compressionOptions.quality == Quality_Highest)
 			{
-				compressBlock_BruteForce(xcolor, &block.x);
-				compressBlock_BruteForce(ycolor, &block.y);
+				OptimalCompress::compressDXT5A(xcolor, &block.x);
+				OptimalCompress::compressDXT5A(ycolor, &block.y);
 			}
 			else
 			{

src/nvtt/CompressDXT.h

@@ -32,26 +32,46 @@ namespace nv
 	class Image;
 	class FloatImage;
 
-	void doPrecomputation();
-	
-	// Fast compressors.
-	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);
+	class FastCompressor
+	{
+	public:
+		FastCompressor();
+		~FastCompressor();
+
+		void setImage(const Image * image, nvtt::AlphaMode alphaMode);
+
+		void compressDXT1(const nvtt::OutputOptions::Private & outputOptions);
+		void compressDXT1a(const nvtt::OutputOptions::Private & outputOptions);
+		void compressDXT3(const nvtt::OutputOptions::Private & outputOptions);
+		void compressDXT5(const nvtt::OutputOptions::Private & outputOptions);
+		void compressDXT5n(const nvtt::OutputOptions::Private & outputOptions);
+
+	private:
+		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;
+	};
 
-	// Normal compressors.
-	void compressDXT1(const Image * image, const nvtt::OutputOptions::Private & outputOptions, const nvtt::CompressionOptions::Private & compressionOptions);
-	void compressDXT1a(const Image * image, const nvtt::OutputOptions::Private & outputOptions, const nvtt::CompressionOptions::Private & compressionOptions);
-	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 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);
-	void compressBC5(const Image * image, const nvtt::OutputOptions::Private & outputOptions, const nvtt::CompressionOptions::Private & compressionOptions);
-	
 	// External compressors.
 #if defined(HAVE_S3QUANT)
 	void s3CompressDXT1(const Image * image, const nvtt::OutputOptions::Private & outputOptions);

src/nvtt/Compressor.cpp

@@ -41,7 +41,6 @@
 #include "OutputOptions.h"
 
 #include "CompressDXT.h"
-#include "FastCompressDXT.h"
 #include "CompressRGB.h"
 #include "cuda/CudaUtils.h"
 #include "cuda/CudaCompressDXT.h"
@@ -200,7 +199,7 @@ namespace nvtt
 		AutoPtr<FloatImage> m_floatImage;
 	};
 
-}
+} // nvtt namespace
 
 
 Compressor::Compressor() : m(*new Compressor::Private())
@@ -422,7 +421,7 @@ bool Compressor::Private::compressMipmaps(uint f, const InputOptions::Private &
 		
 		quantizeMipmap(mipmap, compressionOptions);
 
-		compressMipmap(mipmap, compressionOptions, outputOptions);
+		compressMipmap(mipmap, inputOptions, compressionOptions, outputOptions);
 
 		// Compute extents of next mipmap:
 		w = max(1U, w / 2);
@@ -654,12 +653,18 @@ void Compressor::Private::quantizeMipmap(Mipmap & mipmap, const CompressionOptio
 
 
 // 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();
-
 	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)
 	{
 		compressRGB(image, outputOptions, compressionOptions);
@@ -683,18 +688,19 @@ bool Compressor::Private::compressMipmap(const Mipmap & mipmap, const Compressio
 #endif
 		if (compressionOptions.quality == Quality_Fastest)
 		{
-			fastCompressDXT1(image, outputOptions);
+			fast.compressDXT1(outputOptions);
 		}
 		else
 		{
 			if (cudaEnabled)
 			{
 				nvDebugCheck(cudaSupported);
-				cuda->compressDXT1(image, outputOptions, compressionOptions);
+				cuda->setImage(image, inputOptions.alphaMode);
+				cuda->compressDXT1(compressionOptions, outputOptions);
 			}
 			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)
 		{
-			fastCompressDXT1a(image, outputOptions);
+			fast.compressDXT1a(outputOptions);
 		}
 		else
 		{
 			if (cudaEnabled)
 			{
 				nvDebugCheck(cudaSupported);
-				/*cuda*/compressDXT1a(image, outputOptions, compressionOptions);
+				/*cuda*/slow.compressDXT1a(compressionOptions, outputOptions);
 			}
 			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)
 		{
-			fastCompressDXT3(image, outputOptions);
+			fast.compressDXT3(outputOptions);
 		}
 		else
 		{
 			if (cudaEnabled)
 			{
 				nvDebugCheck(cudaSupported);
-				cuda->compressDXT3(image, outputOptions, compressionOptions);
+				cuda->setImage(image, inputOptions.alphaMode);
+				cuda->compressDXT3(compressionOptions, outputOptions);
 			}
 			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)
 		{
-			fastCompressDXT5(image, outputOptions);
+			fast.compressDXT5(outputOptions);
 		}
 		else
 		{
 			if (cudaEnabled)
 			{
 				nvDebugCheck(cudaSupported);
-				cuda->compressDXT5(image, outputOptions, compressionOptions);
+				cuda->setImage(image, inputOptions.alphaMode);
+				cuda->compressDXT5(compressionOptions, outputOptions);
 			}
 			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)
 		{
-			fastCompressDXT5n(image, outputOptions);
+			fast.compressDXT5n(outputOptions);
 		}
 		else
 		{
-			compressDXT5n(image, outputOptions, compressionOptions);
+			slow.compressDXT5n(compressionOptions, outputOptions);
 		}
 	}
 	else if (compressionOptions.format == Format_BC4)
 	{
-		compressBC4(image, outputOptions, compressionOptions);
+		slow.compressBC4(compressionOptions, outputOptions);
 	}
 	else if (compressionOptions.format == Format_BC5)
 	{
-		compressBC5(image, outputOptions, compressionOptions);
+		slow.compressBC5(compressionOptions, outputOptions);
 	}
 
 	return true;

src/nvtt/Compressor.h

@@ -60,7 +60,7 @@ namespace nvtt
 		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 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:

src/nvtt/FastCompressDXT.cpp

@@ -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);
-}
-
-
-

src/nvtt/FastCompressDXT.h

@@ -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

src/nvtt/OptimalCompressDXT.cpp

@@ -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);
+}
+

src/nvtt/OptimalCompressDXT.h

@@ -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

src/nvtt/QuickCompressDXT.cpp

@@ -27,7 +27,7 @@
 #include <nvimage/BlockDXT.h>
 
 #include "QuickCompressDXT.h"
-#include "SingleColorLookup.h"
+#include "OptimalCompressDXT.h"
 
 
 using namespace nv;
@@ -288,70 +288,6 @@ static void optimizeEndPoints4(Vector3 block[16], BlockDXT1 * dxtBlock)
 	dxtBlock->indices = computeIndices3(block, a, b);
 }*/
 
-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
 {
 
@@ -503,79 +439,63 @@ 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)
 {
-	// read block
-	Vector3 block[16];
-	extractColorBlockRGB(rgba, block);
-	
-	// find min and max colors
-	Vector3 maxColor, minColor;
-	findMinMaxColorsBox(block, 16, &maxColor, &minColor);
-	
-	selectDiagonal(block, 16, &maxColor, &minColor);
-	
-	insetBBox(&maxColor, &minColor);
-	
-	uint16 color0 = roundAndExpand(&maxColor);
-	uint16 color1 = roundAndExpand(&minColor);
-
-	if (color0 < color1)
+	if (rgba.isSingleColor())
 	{
-		swap(maxColor, minColor);
-		swap(color0, color1);
-	}
-
-	dxtBlock->col0 = Color16(color0);
-	dxtBlock->col1 = Color16(color1);
-	dxtBlock->indices = computeIndices4(block, maxColor, minColor);
-
-	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;
+		OptimalCompress::compressDXT1(rgba.color(0), dxtBlock);
 	}
 	else
 	{
-		compressDXT1(rgba, dxtBlock);
+		// read block
+		Vector3 block[16];
+		extractColorBlockRGB(rgba, block);
+		
+		// find min and max colors
+		Vector3 maxColor, minColor;
+		findMinMaxColorsBox(block, 16, &maxColor, &minColor);
+		
+		selectDiagonal(block, 16, &maxColor, &minColor);
+		
+		insetBBox(&maxColor, &minColor);
+		
+		uint16 color0 = roundAndExpand(&maxColor);
+		uint16 color1 = roundAndExpand(&minColor);
+
+		if (color0 < color1)
+		{
+			swap(maxColor, minColor);
+			swap(color0, color1);
+		}
+
+		dxtBlock->col0 = Color16(color0);
+		dxtBlock->col1 = Color16(color1);
+		dxtBlock->indices = computeIndices4(block, maxColor, minColor);
+
+		optimizeEndPoints4(block, 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);
 	}
-	else
+	// @@ Handle single RGB, with varying alpha? We need tables for single color compressor in 3 color mode.
+	//else if (rgba.isSingleColorNoAlpha()) { ... }
+	else 
 	{
 		// read block
 		Vector3 block[16];
@@ -607,95 +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)
-{
-	// @@ Round instead of truncate. When rounding take into account bit expansion.
-	dxtBlock->alpha0 = rgba.color(0).a >> 4;
-	dxtBlock->alpha1 = rgba.color(1).a >> 4;
-	dxtBlock->alpha2 = rgba.color(2).a >> 4;
-	dxtBlock->alpha3 = rgba.color(3).a >> 4;
-	dxtBlock->alpha4 = rgba.color(4).a >> 4;
-	dxtBlock->alpha5 = rgba.color(5).a >> 4;
-	dxtBlock->alpha6 = rgba.color(6).a >> 4;
-	dxtBlock->alpha7 = rgba.color(7).a >> 4;
-	dxtBlock->alpha8 = rgba.color(8).a >> 4;
-	dxtBlock->alpha9 = rgba.color(9).a >> 4;
-	dxtBlock->alphaA = rgba.color(10).a >> 4;
-	dxtBlock->alphaB = rgba.color(11).a >> 4;
-	dxtBlock->alphaC = rgba.color(12).a >> 4;
-	dxtBlock->alphaD = rgba.color(13).a >> 4;
-	dxtBlock->alphaE = rgba.color(14).a >> 4;
-	dxtBlock->alphaF = rgba.color(15).a >> 4;
-}
-
 void QuickCompress::compressDXT3(const ColorBlock & rgba, BlockDXT3 * dxtBlock)
 {
 	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 alpha1 = 255;
@@ -714,8 +553,8 @@ void QuickCompress::compressDXT5A(const ColorBlock & rgba, AlphaBlockDXT5 * dxtB
 	uint besterror = computeAlphaIndices(rgba, &block);
 	
 	AlphaBlockDXT5 bestblock = block;
-	
-	while(true)
+
+	for (int i = 0; i < iterationCount; i++)
 	{
 		optimizeAlpha8(rgba, &block);
 		uint error = computeAlphaIndices(rgba, &block);
@@ -739,9 +578,8 @@ void QuickCompress::compressDXT5A(const ColorBlock & rgba, AlphaBlockDXT5 * dxtB
 	*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);
-	compressDXT5A(rgba, &dxtBlock->alpha);
+	compressDXT5A(rgba, &dxtBlock->alpha, iterationCount);
 }
-

src/nvtt/QuickCompressDXT.h

@@ -37,17 +37,13 @@ namespace nv
 
 	namespace QuickCompress
 	{
-		void compressDXT1(Color32 rgba, BlockDXT1 * dxtBlock);
 		void compressDXT1(const ColorBlock & rgba, BlockDXT1 * dxtBlock);
-		void compressDXT1a(Color32 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 compressDXT5A(const ColorBlock & rgba, AlphaBlockDXT5 * dxtBlock);
-		void compressDXT5(const ColorBlock & rgba, BlockDXT5 * dxtBlock);
+		void compressDXT5A(const ColorBlock & rgba, AlphaBlockDXT5 * dxtBlock, int iterationCount=8);
+		void compressDXT5(const ColorBlock & rgba, BlockDXT5 * dxtBlock, int iterationCount=8);
 	}
 } // nv namespace
 

src/nvtt/cuda/CompressKernel.cu

@@ -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 idx = threadIdx.x;
@@ -189,6 +189,8 @@ __device__ void loadColorBlock(const uint * image, float3 colors[16], float3 sum
 		colorSums(colors, sums);
 		float3 axis = bestFitLine(colors, sums[0], kColorMetric);
 
+		*sameColor = (axis == make_float3(0, 0, 0));
+
 		dps[idx] = dot(rawColors[idx], axis);
 		
 #if __DEVICE_EMULATION__
@@ -592,6 +594,40 @@ __device__ void evalAllPermutations(const float3 * colors, const float * weights
 }
 */
 
+__device__ void evalLevel4Permutations(const float3 * colors, float3 colorSum, const uint * permutations, ushort & bestStart, ushort & bestEnd, uint & bestPermutation, float * errors)
+{
+	const int idx = threadIdx.x;
+	
+	float bestError = FLT_MAX;
+	
+	for(int i = 0; i < 16; i++)
+	{
+		int pidx = idx + NUM_THREADS * i;
+		if (pidx >= 992) break;
+		
+		ushort start, end;
+		uint permutation = permutations[pidx];
+
+		float error = evalPermutation4(colors, colorSum, permutation, &start, &end);
+		
+		if (error < bestError)
+		{
+			bestError = error;
+			bestPermutation = permutation;
+			bestStart = start;
+			bestEnd = end;
+		}
+	}
+
+	if (bestStart < bestEnd)
+	{
+		swap(bestEnd, bestStart);
+		bestPermutation ^= 0x55555555;	// Flip indices.
+	}
+
+	errors[idx] = bestError;
+}
+
 __device__ void evalLevel4Permutations(const float3 * colors, const float * weights, float3 colorSum, const uint * permutations, ushort & bestStart, ushort & bestEnd, uint & bestPermutation, float * errors)
 {
 	const int idx = threadIdx.x;
@@ -627,7 +663,6 @@ __device__ void evalLevel4Permutations(const float3 * colors, const float * weig
 }
 
 
-
 ////////////////////////////////////////////////////////////////////////////////
 // Find index with minimum error
 ////////////////////////////////////////////////////////////////////////////////
@@ -798,6 +833,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)
 {
@@ -805,11 +873,18 @@ __global__ void compressWeightedDXT1(const uint * permutations, const uint * ima
 	__shared__ float3 sums[16];
 	__shared__ float weights[16];
 	__shared__ int xrefs[16];
+	__shared__ int sameColor;
 	
-	loadColorBlock(image, colors, sums, weights, xrefs);
+	loadColorBlock(image, colors, sums, weights, xrefs, &sameColor);
 	
 	__syncthreads();
 
+	if (sameColor)
+	{
+		if (threadIdx.x == 0) saveSingleColorBlockDXT1(colors[0], result);
+		return;
+	}
+
 	ushort bestStart, bestEnd;
 	uint bestPermutation;
 
@@ -1033,6 +1108,11 @@ extern "C" void compressKernelDXT1(uint blockNum, uint * d_data, uint * 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)
 {
 	compressWeightedDXT1<<<blockNum, NUM_THREADS>>>(d_bitmaps, d_data, (uint2 *)d_result);

src/nvtt/cuda/CudaCompressDXT.cpp

@@ -30,6 +30,7 @@
 #include <nvtt/CompressionOptions.h>
 #include <nvtt/OutputOptions.h>
 #include <nvtt/QuickCompressDXT.h>
+#include <nvtt/OptimalCompressDXT.h>
 
 #include "CudaCompressDXT.h"
 #include "CudaUtils.h"
@@ -52,6 +53,7 @@ using namespace nvtt;
 
 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_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);
 
 #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.
 
+void CudaCompressor::setImage(const Image * image, nvtt::AlphaMode alphaMode)
+{
+	m_image = image;
+	m_alphaMode = alphaMode;
+}
 
 /// 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());
 #if defined HAVE_CUDA
 
 	// Image size in blocks.
-	const uint w = (image->width() + 3) / 4;
-	const uint h = (image->height() + 3) / 4;
+	const uint w = (m_image->width() + 3) / 4;
+	const uint h = (m_image->height() + 3) / 4;
 
 	uint imageSize = w * h * 16 * sizeof(Color32);
     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 compressedSize = blockNum * 8;
@@ -176,7 +183,7 @@ void CudaCompressor::compressDXT1(const Image * image, const OutputOptions::Priv
 	}
 
 	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);
 
@@ -190,18 +197,18 @@ void CudaCompressor::compressDXT1(const Image * image, const OutputOptions::Priv
 
 
 /// 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());
 #if defined HAVE_CUDA
 
 	// Image size in blocks.
-	const uint w = (image->width() + 3) / 4;
-	const uint h = (image->height() + 3) / 4;
+	const uint w = (m_image->width() + 3) / 4;
+	const uint h = (m_image->height() + 3) / 4;
 
 	uint imageSize = w * h * 16 * sizeof(Color32);
     uint * blockLinearImage = (uint *) malloc(imageSize);
-	convertToBlockLinear(image, blockLinearImage);
+	convertToBlockLinear(m_image, blockLinearImage);
 
 	const uint blockNum = w * h;
 	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);
 
 		// Launch kernel.
-		compressWeightedKernelDXT1(count, m_data, m_result, m_bitmapTable);
+		if (m_alphaMode == AlphaMode_Transparency)
+		{
+			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.
 		for (uint i = 0; i < count; i++)
 		{
 			ColorBlock rgba(blockLinearImage + (bn + i) * 16);
-			QuickCompress::compressDXT3A(rgba, alphaBlocks + i);
+			OptimalCompress::compressDXT3A(rgba, alphaBlocks + i);
 		}
 
 		// Check for errors.
@@ -259,7 +273,7 @@ void CudaCompressor::compressDXT3(const Image * image, const OutputOptions::Priv
 	}
 
 	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(blockLinearImage);
@@ -274,18 +288,18 @@ void CudaCompressor::compressDXT3(const Image * image, const OutputOptions::Priv
 
 
 /// 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());
 #if defined HAVE_CUDA
 
 	// Image size in blocks.
-	const uint w = (image->width() + 3) / 4;
-	const uint h = (image->height() + 3) / 4;
+	const uint w = (m_image->width() + 3) / 4;
+	const uint h = (m_image->height() + 3) / 4;
 
 	uint imageSize = w * h * 16 * sizeof(Color32);
     uint * blockLinearImage = (uint *) malloc(imageSize);
-	convertToBlockLinear(image, blockLinearImage);
+	convertToBlockLinear(m_image, blockLinearImage);
 
 	const uint blockNum = w * h;
 	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);
 
 		// Launch kernel.
-		compressWeightedKernelDXT1(count, m_data, m_result, m_bitmapTable);
+		if (m_alphaMode == AlphaMode_Transparency)
+		{
+			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.
 		for (uint i = 0; i < count; i++)
@@ -343,7 +364,7 @@ void CudaCompressor::compressDXT5(const Image * image, const OutputOptions::Priv
 	}
 
 	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(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

src/nvtt/cuda/CudaCompressDXT.h

@@ -39,15 +39,20 @@ namespace nv
 
 		bool isValid() const;
 
-		void compressDXT1(const Image * image, const nvtt::OutputOptions::Private & outputOptions, const nvtt::CompressionOptions::Private & compressionOptions);
-		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 setImage(const Image * image, nvtt::AlphaMode alphaMode);
+
+		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:
 
 		uint * m_bitmapTable;
 		uint * m_data;
 		uint * m_result;
+		
+		const Image * m_image;
+		nvtt::AlphaMode m_alphaMode;
 	};
 
 } // nv namespace

src/nvtt/cuda/CudaUtils.cpp

@@ -74,7 +74,7 @@ bool nv::cuda::isHardwarePresent()
 {
 #if defined HAVE_CUDA
 #if NV_OS_WIN32
-	if (isWindowsVista()) return false;
+	//if (isWindowsVista()) return false;
 	//if (isWindowsVista() || !isWow32()) return false;
 #endif
 	int count = deviceCount();

src/nvtt/squish/fastclusterfit.cpp

@@ -29,6 +29,8 @@
 #include "colourblock.h"
 #include <cfloat>
 
+#include "fastclusterlookup.inl"
+
 namespace squish {
 
 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)
 {
 #if SQUISH_USE_SIMD

src/nvtt/squish/fastclusterfit.h

@@ -44,8 +44,6 @@ public:
 	void SetMetric(float r, float g, float b);
 	float GetBestError() const;
 
-	static void DoPrecomputation();
-
 	// Make them public
 	virtual void Compress3( void* block );
 	virtual void Compress4( void* block );

src/nvtt/tools/compress.cpp

@@ -42,11 +42,11 @@ struct MyOutputHandler : public nvtt::OutputHandler
 	MyOutputHandler(const char * name) : total(0), progress(0), percentage(0), stream(new nv::StdOutputStream(name)) {}
 	virtual ~MyOutputHandler() { delete stream; }
 	
-	virtual void setTotal(int64 t)
+	void setTotal(int64 t)
 	{
 		total = t + 128;
 	}
-	virtual void setDisplayProgress(bool b)
+	void setDisplayProgress(bool b)
 	{
 		verbose = b;
 	}