drewcassidy/nvidia-texture-tools
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: drewcassidy:2.0.7
Branches Tags
drewcassidy:master drewcassidy:wiki drewcassidy:2.0
drewcassidy:2.1.2 drewcassidy:2.1.1 drewcassidy:2.1.0 drewcassidy:2.0.8 drewcassidy:2.0.7 drewcassidy:2.0.6 drewcassidy:2.0.5 drewcassidy:2.0.4 drewcassidy:2.0.3 drewcassidy:2.0.2 drewcassidy:2.0.1 drewcassidy:2.0.0
..
compare: drewcassidy:2.0.6
Branches Tags
drewcassidy:master drewcassidy:wiki drewcassidy:2.0
drewcassidy:2.1.2 drewcassidy:2.1.1 drewcassidy:2.1.0 drewcassidy:2.0.8 drewcassidy:2.0.7 drewcassidy:2.0.6 drewcassidy:2.0.5 drewcassidy:2.0.4 drewcassidy:2.0.3 drewcassidy:2.0.2 drewcassidy:2.0.1 drewcassidy:2.0.0

1 Commits
2.0.7 ... 2.0.6

Author SHA1 Message Date
castano
de8f0153c0 Tag 2.0.6 for release. 2009-03-19 19:06:30 +00:00
20 changed files with 879 additions and 987 deletions
Expand all files Collapse all files

7
ChangeLog
View File

@ -1,10 +1,3 @@
NVIDIA Texture Tools version 2.0.7
* Output correct exit codes. Fixes issue 92.
* Fix thread-safety errors. Fixes issue 90.
* Add SIMD power method. Fixes issue 94.
* Interact better with applications that already use CUDA.
* Faster CPU compression.
NVIDIA Texture Tools version 2.0.6 NVIDIA Texture Tools version 2.0.6
* Fix dll version checking. * Fix dll version checking.
* Detect CUDA 2.1 and future CUDA versions correctly. * Detect CUDA 2.1 and future CUDA versions correctly.

2
VERSION
View File

@ -1 +1 @@
2.0.7 2.0.6

3
src/CMakeLists.txt
View File

@ -105,8 +105,7 @@ ENDIF(OPENEXR_FOUND)
FIND_PACKAGE(Qt4) FIND_PACKAGE(Qt4)
# Threads # Threads
FIND_PACKAGE(Threads REQUIRED) FIND_PACKAGE(Threads)
MESSAGE(STATUS "Use thread library: ${CMAKE_THREAD_LIBS_INIT}")
# configuration file # configuration file
INCLUDE(CheckIncludeFiles) INCLUDE(CheckIncludeFiles)

2
src/nvcore/Debug.cpp
View File

@ -38,7 +38,7 @@
# include <unistd.h> // getpid # include <unistd.h> // getpid
# include <sys/types.h> # include <sys/types.h>
# include <sys/sysctl.h> // sysctl # include <sys/sysctl.h> // sysctl
# include <sys/ucontext.h> # include <ucontext.h>
# undef HAVE_EXECINFO_H # undef HAVE_EXECINFO_H
# if defined(HAVE_EXECINFO_H) // only after OSX 10.5 # if defined(HAVE_EXECINFO_H) // only after OSX 10.5
# include <execinfo.h> // backtrace # include <execinfo.h> // backtrace

1
src/nvcore/Debug.h
View File

@ -115,7 +115,6 @@ namespace nv
{ {
NVCORE_API void dumpInfo(); NVCORE_API void dumpInfo();
// These functions are not thread safe.
NVCORE_API void setMessageHandler( MessageHandler * messageHandler ); NVCORE_API void setMessageHandler( MessageHandler * messageHandler );
NVCORE_API void resetMessageHandler(); NVCORE_API void resetMessageHandler();

14
src/nvcore/StrLib.cpp
View File

@ -545,6 +545,8 @@ const char * Path::extension(const char * str)
} }
// static
String String::s_null(String::null);
/// Clone this string /// Clone this string
String String::clone() const String String::clone() const
@ -555,13 +557,13 @@ String String::clone() const
void String::setString(const char * str) void String::setString(const char * str)
{ {
if (str == NULL) { if( str == NULL ) {
data = NULL; data = s_null.data;
} }
else { else {
allocString( str ); allocString( str );
addRef();
} }
addRef();
} }
void String::setString(const char * str, int length) void String::setString(const char * str, int length)
@ -574,11 +576,11 @@ void String::setString(const char * str, int length)
void String::setString(const StringBuilder & str) void String::setString(const StringBuilder & str)
{ {
if (str.str() == NULL) { if( str.str() == NULL ) {
data = NULL; data = s_null.data;
} }
else { else {
allocString(str); allocString(str);
addRef();
} }
addRef();
} }

71
src/nvcore/StrLib.h
View File

@ -151,14 +151,15 @@ namespace nv
/// Constructs a null string. @sa isNull() /// Constructs a null string. @sa isNull()
String() String()
{ {
data = NULL; data = s_null.data;
addRef();
} }
/// Constructs a shared copy of str. /// Constructs a shared copy of str.
String(const String & str) String(const String & str)
{ {
data = str.data; data = str.data;
if (data != NULL) addRef(); addRef();
} }
/// Constructs a shared string from a standard string. /// Constructs a shared string from a standard string.
@ -182,6 +183,7 @@ namespace nv
/// Dtor. /// Dtor.
~String() ~String()
{ {
nvDebugCheck(data != NULL);
release(); release();
} }
@ -218,49 +220,43 @@ namespace nv
/// Equal operator. /// Equal operator.
bool operator==( const String & str ) const bool operator==( const String & str ) const
{ {
nvDebugCheck(data != NULL);
nvDebugCheck(str.data != NULL);
if( str.data == data ) { if( str.data == data ) {
return true; return true;
} }
if ((data == NULL) != (str.data == NULL)) {
return false;
}
return strcmp(data, str.data) == 0; return strcmp(data, str.data) == 0;
} }
/// Equal operator. /// Equal operator.
bool operator==( const char * str ) const bool operator==( const char * str ) const
{ {
nvDebugCheck(data != NULL);
nvCheck(str != NULL); // Use isNull! nvCheck(str != NULL); // Use isNull!
if (data == NULL) {
return false;
}
return strcmp(data, str) == 0; return strcmp(data, str) == 0;
} }
/// Not equal operator. /// Not equal operator.
bool operator!=( const String & str ) const bool operator!=( const String & str ) const
{ {
nvDebugCheck(data != NULL);
nvDebugCheck(str.data != NULL);
if( str.data == data ) { if( str.data == data ) {
return false; return false;
} }
if ((data == NULL) != (str.data == NULL)) {
return true;
}
return strcmp(data, str.data) != 0; return strcmp(data, str.data) != 0;
} }
/// Not equal operator. /// Not equal operator.
bool operator!=( const char * str ) const bool operator!=( const char * str ) const
{ {
nvDebugCheck(data != NULL);
nvCheck(str != NULL); // Use isNull! nvCheck(str != NULL); // Use isNull!
if (data == NULL) {
return false;
}
return strcmp(data, str) != 0; return strcmp(data, str) != 0;
} }
/// Returns true if this string is the null string. /// Returns true if this string is the null string.
bool isNull() const { return data == NULL; } bool isNull() const { nvDebugCheck(data != NULL); return data == s_null.data; }
/// Return the exact length. /// Return the exact length.
uint length() const { nvDebugCheck(data != NULL); return uint(strlen(data)); } uint length() const { nvDebugCheck(data != NULL); return uint(strlen(data)); }
@ -269,45 +265,44 @@ namespace nv
uint hash() const { nvDebugCheck(data != NULL); return strHash(data); } uint hash() const { nvDebugCheck(data != NULL); return strHash(data); }
/// const char * cast operator. /// const char * cast operator.
operator const char * () const { return data; } operator const char * () const { nvDebugCheck(data != NULL); return data; }
/// Get string pointer. /// Get string pointer.
const char * str() const { return data; } const char * str() const { nvDebugCheck(data != NULL); return data; }
private: private:
enum null_t { null };
// Private constructor for null string.
String(null_t) {
setString("");
}
// Add reference count. // Add reference count.
void addRef() void addRef() {
{ nvDebugCheck(data != NULL);
if (data != NULL) setRefCount(getRefCount() + 1);
{
setRefCount(getRefCount() + 1);
}
} }
// Decrease reference count. // Decrease reference count.
void release() void release() {
{ nvDebugCheck(data != NULL);
if (data != NULL)
{ const uint16 count = getRefCount();
const uint16 count = getRefCount(); setRefCount(count - 1);
setRefCount(count - 1); if( count - 1 == 0 ) {
if (count - 1 == 0) { mem::free(data - 2);
mem::free(data - 2); data = NULL;
data = NULL;
}
} }
} }
uint16 getRefCount() const uint16 getRefCount() const {
{
nvDebugCheck(data != NULL);
return *reinterpret_cast<const uint16 *>(data - 2); return *reinterpret_cast<const uint16 *>(data - 2);
} }
void setRefCount(uint16 count) { void setRefCount(uint16 count) {
nvDebugCheck(data != NULL);
nvCheck(count < 0xFFFF); nvCheck(count < 0xFFFF);
*reinterpret_cast<uint16 *>(const_cast<char *>(data - 2)) = uint16(count); *reinterpret_cast<uint16 *>(const_cast<char *>(data - 2)) = uint16(count);
} }
@ -346,6 +341,8 @@ namespace nv
private: private:
NVCORE_API static String s_null;
const char * data; const char * data;
}; };

2
src/nvimage/DirectDrawSurface.cpp
View File

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

2
src/nvimage/Image.cpp
View File

@ -78,7 +78,7 @@ void Image::unwrap()
void Image::free() void Image::free()
{ {
nv::mem::free(m_data); ::free(m_data);
m_data = NULL; m_data = NULL;
} }

2
src/nvmath/Matrix.h
View File

@ -332,7 +332,7 @@ inline Matrix transpose(Matrix::Arg m)
Matrix r; Matrix r;
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
{ {
for (int j = 0; j < 4; j++) for (int j = 0; j < 4; i++)
{ {
r(i, j) = m(j, i); r(i, j) = m(j, i);
} }

6
src/nvtt/CompressDXT.cpp
View File

@ -205,9 +205,9 @@ void nv::SlowCompressor::compressDXT1(const CompressionOptions::Private & compre
ColorBlock rgba; ColorBlock rgba;
BlockDXT1 block; BlockDXT1 block;
squish::WeightedClusterFit fit; //squish::WeightedClusterFit fit;
//squish::ClusterFit fit; //squish::ClusterFit fit;
//squish::FastClusterFit 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) {
@ -221,7 +221,7 @@ void nv::SlowCompressor::compressDXT1(const CompressionOptions::Private & compre
} }
else else
{ {
squish::ColourSet colours((uint8 *)rgba.colors(), 0, true); squish::ColourSet colours((uint8 *)rgba.colors(), 0);
fit.SetColourSet(&colours, squish::kDxt1); fit.SetColourSet(&colours, squish::kDxt1);
fit.Compress(&block); fit.Compress(&block);
} }

156
src/nvtt/Compressor.cpp
View File

@ -53,7 +53,7 @@ using namespace nvtt;
namespace namespace
{ {
static int blockSize(Format format) static int blockSize(Format format)
{ {
if (format == Format_DXT1 || format == Format_DXT1a) { if (format == Format_DXT1 || format == Format_DXT1a) {
@ -121,7 +121,7 @@ namespace nvtt
m_fixedImage = NULL; m_fixedImage = NULL;
m_floatImage = image; m_floatImage = image;
} }
// Convert linear float image to fixed image ready for compression. // Convert linear float image to fixed image ready for compression.
void toFixedImage(const InputOptions::Private & inputOptions) void toFixedImage(const InputOptions::Private & inputOptions)
@ -153,7 +153,7 @@ namespace nvtt
if (inputOptions.isNormalMap) if (inputOptions.isNormalMap)
{ {
// Expand normals to [-1, 1] range. // Expand normals to [-1, 1] range.
// floatImage->expandNormals(0); // floatImage->expandNormals(0);
} }
else if (inputOptions.inputGamma != 1.0f) else if (inputOptions.inputGamma != 1.0f)
{ {
@ -193,7 +193,7 @@ namespace nvtt
return m_fixedImage.ptr(); return m_fixedImage.ptr();
} }
private: private:
const Image * m_inputImage; const Image * m_inputImage;
AutoPtr<Image> m_fixedImage; AutoPtr<Image> m_fixedImage;
@ -207,16 +207,28 @@ Compressor::Compressor() : m(*new Compressor::Private())
{ {
// CUDA initialization. // CUDA initialization.
m.cudaSupported = cuda::isHardwarePresent(); m.cudaSupported = cuda::isHardwarePresent();
m.cudaEnabled = false; m.cudaEnabled = m.cudaSupported;
m.cudaDevice = -1;
enableCudaAcceleration(m.cudaSupported); if (m.cudaEnabled)
{
// Select fastest CUDA device.
int device = cuda::getFastestDevice();
cuda::setDevice(device);
m.cuda = new CudaCompressor();
if (!m.cuda->isValid())
{
m.cudaEnabled = false;
m.cuda = NULL;
}
}
} }
Compressor::~Compressor() Compressor::~Compressor()
{ {
enableCudaAcceleration(false);
delete &m; delete &m;
cuda::exit();
} }
@ -225,33 +237,21 @@ void Compressor::enableCudaAcceleration(bool enable)
{ {
if (m.cudaSupported) if (m.cudaSupported)
{ {
if (m.cudaEnabled && !enable) m.cudaEnabled = enable;
}
if (m.cudaEnabled && m.cuda == NULL)
{
// Select fastest CUDA device.
int device = cuda::getFastestDevice();
cuda::setDevice(device);
m.cuda = new CudaCompressor();
if (!m.cuda->isValid())
{ {
m.cudaEnabled = false; m.cudaEnabled = false;
m.cuda = NULL; m.cuda = NULL;
if (m.cudaDevice != -1)
{
// Exit device.
cuda::exitDevice();
}
}
else if (!m.cudaEnabled && enable)
{
// Init the CUDA device. This may return -1 if CUDA was already initialized by the app.
m.cudaEnabled = cuda::initDevice(&m.cudaDevice);
if (m.cudaEnabled)
{
// Create compressor if initialization succeeds.
m.cuda = new CudaCompressor();
// But cleanup if failed.
if (!m.cuda->isValid())
{
enableCudaAcceleration(false);
}
}
} }
} }
} }
@ -292,9 +292,9 @@ bool Compressor::Private::compress(const InputOptions::Private & inputOptions, c
if (outputOptions.errorHandler) outputOptions.errorHandler->error(Error_FileOpen); if (outputOptions.errorHandler) outputOptions.errorHandler->error(Error_FileOpen);
return false; return false;
} }
inputOptions.computeTargetExtents(); inputOptions.computeTargetExtents();
// Output DDS header. // Output DDS header.
if (!outputHeader(inputOptions, compressionOptions, outputOptions)) if (!outputHeader(inputOptions, compressionOptions, outputOptions))
{ {
@ -310,7 +310,7 @@ bool Compressor::Private::compress(const InputOptions::Private & inputOptions, c
} }
outputOptions.closeFile(); outputOptions.closeFile();
return true; return true;
} }
@ -325,15 +325,15 @@ bool Compressor::Private::outputHeader(const InputOptions::Private & inputOption
} }
DDSHeader header; DDSHeader header;
header.setWidth(inputOptions.targetWidth); header.setWidth(inputOptions.targetWidth);
header.setHeight(inputOptions.targetHeight); header.setHeight(inputOptions.targetHeight);
int mipmapCount = inputOptions.realMipmapCount(); int mipmapCount = inputOptions.realMipmapCount();
nvDebugCheck(mipmapCount > 0); nvDebugCheck(mipmapCount > 0);
header.setMipmapCount(mipmapCount); header.setMipmapCount(mipmapCount);
if (inputOptions.textureType == TextureType_2D) { if (inputOptions.textureType == TextureType_2D) {
header.setTexture2D(); header.setTexture2D();
} }
@ -341,10 +341,10 @@ bool Compressor::Private::outputHeader(const InputOptions::Private & inputOption
header.setTextureCube(); header.setTextureCube();
} }
/*else if (inputOptions.textureType == TextureType_3D) { /*else if (inputOptions.textureType == TextureType_3D) {
header.setTexture3D(); header.setTexture3D();
header.setDepth(inputOptions.targetDepth); header.setDepth(inputOptions.targetDepth);
}*/ }*/
if (compressionOptions.format == Format_RGBA) if (compressionOptions.format == Format_RGBA)
{ {
header.setPitch(computePitch(inputOptions.targetWidth, compressionOptions.bitcount)); header.setPitch(computePitch(inputOptions.targetWidth, compressionOptions.bitcount));
@ -353,7 +353,7 @@ bool Compressor::Private::outputHeader(const InputOptions::Private & inputOption
else else
{ {
header.setLinearSize(computeImageSize(inputOptions.targetWidth, inputOptions.targetHeight, inputOptions.targetDepth, compressionOptions.bitcount, compressionOptions.format)); header.setLinearSize(computeImageSize(inputOptions.targetWidth, inputOptions.targetHeight, inputOptions.targetDepth, compressionOptions.bitcount, compressionOptions.format));
if (compressionOptions.format == Format_DXT1 || compressionOptions.format == Format_DXT1a) { if (compressionOptions.format == Format_DXT1 || compressionOptions.format == Format_DXT1a) {
header.setFourCC('D', 'X', 'T', '1'); header.setFourCC('D', 'X', 'T', '1');
if (inputOptions.isNormalMap) header.setNormalFlag(true); if (inputOptions.isNormalMap) header.setNormalFlag(true);
@ -376,10 +376,10 @@ bool Compressor::Private::outputHeader(const InputOptions::Private & inputOption
if (inputOptions.isNormalMap) header.setNormalFlag(true); if (inputOptions.isNormalMap) header.setNormalFlag(true);
} }
} }
// Swap bytes if necessary. // Swap bytes if necessary.
header.swapBytes(); header.swapBytes();
uint headerSize = 128; uint headerSize = 128;
if (header.hasDX10Header()) if (header.hasDX10Header())
{ {
@ -392,7 +392,7 @@ bool Compressor::Private::outputHeader(const InputOptions::Private & inputOption
{ {
outputOptions.errorHandler->error(Error_FileWrite); outputOptions.errorHandler->error(Error_FileWrite);
} }
return writeSucceed; return writeSucceed;
} }
@ -428,7 +428,7 @@ bool Compressor::Private::compressMipmaps(uint f, const InputOptions::Private &
return false; return false;
} }
} }
quantizeMipmap(mipmap, compressionOptions); quantizeMipmap(mipmap, compressionOptions);
compressMipmap(mipmap, inputOptions, compressionOptions, outputOptions); compressMipmap(mipmap, inputOptions, compressionOptions, outputOptions);
@ -438,7 +438,7 @@ bool Compressor::Private::compressMipmaps(uint f, const InputOptions::Private &
h = max(1U, h / 2); h = max(1U, h / 2);
d = max(1U, d / 2); d = max(1U, d / 2);
} }
return true; return true;
} }
@ -489,7 +489,7 @@ int Compressor::Private::findExactMipmap(const InputOptions::Private & inputOpti
{ {
int idx = f * inputOptions.mipmapCount + m; int idx = f * inputOptions.mipmapCount + m;
const InputOptions::Private::InputImage & inputImage = inputOptions.images[idx]; const InputOptions::Private::InputImage & inputImage = inputOptions.images[idx];
if (inputImage.width == int(w) && inputImage.height == int(h) && inputImage.depth == int(d)) if (inputImage.width == int(w) && inputImage.height == int(h) && inputImage.depth == int(d))
{ {
if (inputImage.data != NULL) if (inputImage.data != NULL)
@ -544,7 +544,7 @@ void Compressor::Private::downsampleMipmap(Mipmap & mipmap, const InputOptions::
mipmap.toFloatImage(inputOptions); mipmap.toFloatImage(inputOptions);
const FloatImage * floatImage = mipmap.asFloatImage(); const FloatImage * floatImage = mipmap.asFloatImage();
if (inputOptions.mipmapFilter == MipmapFilter_Box) if (inputOptions.mipmapFilter == MipmapFilter_Box)
{ {
// Use fast downsample. // Use fast downsample.
@ -562,7 +562,7 @@ void Compressor::Private::downsampleMipmap(Mipmap & mipmap, const InputOptions::
filter.setParameters(inputOptions.kaiserAlpha, inputOptions.kaiserStretch); filter.setParameters(inputOptions.kaiserAlpha, inputOptions.kaiserStretch);
mipmap.setImage(floatImage->downSample(filter, (FloatImage::WrapMode)inputOptions.wrapMode)); mipmap.setImage(floatImage->downSample(filter, (FloatImage::WrapMode)inputOptions.wrapMode));
} }
// Normalize mipmap. // Normalize mipmap.
if ((inputOptions.isNormalMap || inputOptions.convertToNormalMap) && inputOptions.normalizeMipmaps) if ((inputOptions.isNormalMap || inputOptions.convertToNormalMap) && inputOptions.normalizeMipmaps)
{ {
@ -590,7 +590,7 @@ void Compressor::Private::processInputImage(Mipmap & mipmap, const InputOptions:
if (inputOptions.convertToNormalMap) if (inputOptions.convertToNormalMap)
{ {
mipmap.toFixedImage(inputOptions); mipmap.toFixedImage(inputOptions);
Vector4 heightScale = inputOptions.heightFactors; Vector4 heightScale = inputOptions.heightFactors;
mipmap.setImage(createNormalMap(mipmap.asFixedImage(), (FloatImage::WrapMode)inputOptions.wrapMode, heightScale, inputOptions.bumpFrequencyScale)); mipmap.setImage(createNormalMap(mipmap.asFixedImage(), (FloatImage::WrapMode)inputOptions.wrapMode, heightScale, inputOptions.bumpFrequencyScale));
} }
@ -715,29 +715,29 @@ bool Compressor::Private::compressMipmap(const Mipmap & mipmap, const InputOptio
#endif #endif
#if defined(HAVE_ATITC) #if defined(HAVE_ATITC)
if (compressionOptions.externalCompressor == "ati") if (compressionOptions.externalCompressor == "ati")
{
atiCompressDXT1(image, outputOptions);
}
else
#endif
if (compressionOptions.quality == Quality_Fastest)
{
fast.compressDXT1(outputOptions);
}
else
{
if (useCuda)
{ {
atiCompressDXT1(image, outputOptions); nvDebugCheck(cudaSupported);
cuda->setImage(image, inputOptions.alphaMode);
cuda->compressDXT1(compressionOptions, outputOptions);
} }
else else
#endif {
if (compressionOptions.quality == Quality_Fastest) slow.compressDXT1(compressionOptions, outputOptions);
{ }
fast.compressDXT1(outputOptions); }
}
else
{
if (useCuda)
{
nvDebugCheck(cudaSupported);
cuda->setImage(image, inputOptions.alphaMode);
cuda->compressDXT1(compressionOptions, outputOptions);
}
else
{
slow.compressDXT1(compressionOptions, outputOptions);
}
}
} }
else if (compressionOptions.format == Format_DXT1a) else if (compressionOptions.format == Format_DXT1a)
{ {
@ -828,27 +828,27 @@ int Compressor::Private::estimateSize(const InputOptions::Private & inputOptions
const uint bitCount = compressionOptions.bitcount; const uint bitCount = compressionOptions.bitcount;
inputOptions.computeTargetExtents(); inputOptions.computeTargetExtents();
uint mipmapCount = inputOptions.realMipmapCount(); uint mipmapCount = inputOptions.realMipmapCount();
int size = 0; int size = 0;
for (uint f = 0; f < inputOptions.faceCount; f++) for (uint f = 0; f < inputOptions.faceCount; f++)
{ {
uint w = inputOptions.targetWidth; uint w = inputOptions.targetWidth;
uint h = inputOptions.targetHeight; uint h = inputOptions.targetHeight;
uint d = inputOptions.targetDepth; uint d = inputOptions.targetDepth;
for (uint m = 0; m < mipmapCount; m++) for (uint m = 0; m < mipmapCount; m++)
{ {
size += computeImageSize(w, h, d, bitCount, format); size += computeImageSize(w, h, d, bitCount, format);
// Compute extents of next mipmap: // Compute extents of next mipmap:
w = max(1U, w / 2); w = max(1U, w / 2);
h = max(1U, h / 2); h = max(1U, h / 2);
d = max(1U, d / 2); d = max(1U, d / 2);
} }
} }
return size; return size;
} }

2
src/nvtt/Compressor.h
View File

@ -63,12 +63,10 @@ namespace nvtt
bool compressMipmap(const Mipmap & mipmap, const InputOptions::Private & inputOptions, 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:
bool cudaSupported; bool cudaSupported;
bool cudaEnabled; bool cudaEnabled;
int cudaDevice;
nv::AutoPtr<nv::CudaCompressor> cuda; nv::AutoPtr<nv::CudaCompressor> cuda;

2
src/nvtt/InputOptions.cpp
View File

@ -94,7 +94,7 @@ void InputOptions::reset()
m.textureType = TextureType_2D; m.textureType = TextureType_2D;
m.inputFormat = InputFormat_BGRA_8UB; m.inputFormat = InputFormat_BGRA_8UB;
m.alphaMode = AlphaMode_None; m.alphaMode = AlphaMode_Transparency;
m.inputGamma = 2.2f; m.inputGamma = 2.2f;
m.outputGamma = 2.2f; m.outputGamma = 2.2f;

539
src/nvtt/cuda/CudaUtils.cpp
View File

@ -1,300 +1,239 @@
// Copyright NVIDIA Corporation 2007 -- Ignacio Castano <icastano@nvidia.com> // Copyright NVIDIA Corporation 2007 -- Ignacio Castano <icastano@nvidia.com>
// //
// Permission is hereby granted, free of charge, to any person // Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation // obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without // files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use, // restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell // copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the // copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following // Software is furnished to do so, subject to the following
// conditions: // conditions:
// //
// The above copyright notice and this permission notice shall be // The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software. // included in all copies or substantial portions of the Software.
// //
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE. // OTHER DEALINGS IN THE SOFTWARE.
#include <nvcore/Debug.h> #include <nvcore/Debug.h>
#include <nvcore/Library.h> #include <nvcore/Library.h>
#include "CudaUtils.h" #include "CudaUtils.h"
#if defined HAVE_CUDA #if defined HAVE_CUDA
#include <cuda.h> #include <cuda.h>
#include <cuda_runtime_api.h> #include <cuda_runtime_api.h>
#endif #endif
using namespace nv; using namespace nv;
using namespace cuda; using namespace cuda;
/* @@ Move this to win32 utils or somewhere else. /* @@ Move this to win32 utils or somewhere else.
#if NV_OS_WIN32 #if NV_OS_WIN32
#define WINDOWS_LEAN_AND_MEAN #define WINDOWS_LEAN_AND_MEAN
#include <windows.h> #include <windows.h>
static bool isWindowsVista() static bool isWindowsVista()
{ {
OSVERSIONINFO osvi; OSVERSIONINFO osvi;
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
::GetVersionEx(&osvi); ::GetVersionEx(&osvi);
return osvi.dwMajorVersion >= 6; return osvi.dwMajorVersion >= 6;
} }
typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL); typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL);
static bool isWow32() static bool isWow32()
{ {
LPFN_ISWOW64PROCESS fnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress(GetModuleHandle("kernel32"), "IsWow64Process"); LPFN_ISWOW64PROCESS fnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress(GetModuleHandle("kernel32"), "IsWow64Process");
BOOL bIsWow64 = FALSE; BOOL bIsWow64 = FALSE;
if (NULL != fnIsWow64Process) if (NULL != fnIsWow64Process)
{ {
if (!fnIsWow64Process(GetCurrentProcess(), &bIsWow64)) if (!fnIsWow64Process(GetCurrentProcess(), &bIsWow64))
{ {
// Assume 32 bits. // Assume 32 bits.
return true; return true;
} }
} }
return !bIsWow64; return !bIsWow64;
} }
#endif #endif
*/ */
static bool isCudaDriverAvailable(int version) static bool isCudaDriverAvailable(int version)
{ {
#if defined HAVE_CUDA #if defined HAVE_CUDA
#if NV_OS_WIN32 #if NV_OS_WIN32
Library nvcuda("nvcuda.dll"); Library nvcuda("nvcuda.dll");
#else #else
Library nvcuda(NV_LIBRARY_NAME(cuda)); Library nvcuda(NV_LIBRARY_NAME(cuda));
#endif #endif
if (!nvcuda.isValid()) if (!nvcuda.isValid())
{ {
nvDebug("*** CUDA driver not found.\n"); nvDebug("*** CUDA driver not found.\n");
return false; return false;
} }
if (version >= 2000) if (version >= 2000)
{ {
void * address = nvcuda.bindSymbol("cuStreamCreate"); void * address = nvcuda.bindSymbol("cuStreamCreate");
if (address == NULL) { if (address == NULL) {
nvDebug("*** CUDA driver version < 2.0.\n"); nvDebug("*** CUDA driver version < 2.0.\n");
return false; return false;
} }
} }
if (version >= 2010) if (version >= 2010)
{ {
void * address = nvcuda.bindSymbol("cuModuleLoadDataEx"); void * address = nvcuda.bindSymbol("cuModuleLoadDataEx");
if (address == NULL) { if (address == NULL) {
nvDebug("*** CUDA driver version < 2.1.\n"); nvDebug("*** CUDA driver version < 2.1.\n");
return false; return false;
} }
} }
if (version >= 2020) if (version >= 2020)
{ {
typedef CUresult (CUDAAPI * PFCU_DRIVERGETVERSION)(int * version); typedef CUresult (CUDAAPI * PFCU_DRIVERGETVERSION)(int * version);
PFCU_DRIVERGETVERSION driverGetVersion = (PFCU_DRIVERGETVERSION)nvcuda.bindSymbol("cuDriverGetVersion"); PFCU_DRIVERGETVERSION driverGetVersion = (PFCU_DRIVERGETVERSION)nvcuda.bindSymbol("cuDriverGetVersion");
if (driverGetVersion == NULL) { if (driverGetVersion == NULL) {
nvDebug("*** CUDA driver version < 2.2.\n"); nvDebug("*** CUDA driver version < 2.2.\n");
return false; return false;
} }
int driverVersion; int driverVersion;
CUresult err = driverGetVersion(&driverVersion); CUresult err = driverGetVersion(&driverVersion);
if (err != CUDA_SUCCESS) { if (err != CUDA_SUCCESS) {
nvDebug("*** Error querying driver version: '%s'.\n", cudaGetErrorString((cudaError_t)err)); nvDebug("*** Error querying driver version: '%s'.\n", cudaGetErrorString((cudaError_t)err));
return false; return false;
} }
return driverVersion >= version; return driverVersion >= version;
} }
#endif // HAVE_CUDA #endif // HAVE_CUDA
return true; return true;
} }
/// Determine if CUDA is available. /// Determine if CUDA is available.
bool nv::cuda::isHardwarePresent() bool nv::cuda::isHardwarePresent()
{ {
#if defined HAVE_CUDA #if defined HAVE_CUDA
// Make sure that CUDA driver matches CUDA runtime. // Make sure that CUDA driver matches CUDA runtime.
if (!isCudaDriverAvailable(CUDART_VERSION)) if (!isCudaDriverAvailable(CUDART_VERSION))
{ {
nvDebug("CUDA driver not available for CUDA runtime %d\n", CUDART_VERSION); nvDebug("CUDA driver not available for CUDA runtime %d\n", CUDART_VERSION);
return false; return false;
} }
int count = deviceCount(); int count = deviceCount();
if (count == 1) if (count == 1)
{ {
// Make sure it's not an emulation device. // Make sure it's not an emulation device.
cudaDeviceProp deviceProp; cudaDeviceProp deviceProp;
cudaGetDeviceProperties(&deviceProp, 0); cudaGetDeviceProperties(&deviceProp, 0);
// deviceProp.name != Device Emulation (CPU) // deviceProp.name != Device Emulation (CPU)
if (deviceProp.major == -1 || deviceProp.minor == -1) if (deviceProp.major == -1 || deviceProp.minor == -1)
{ {
return false; return false;
} }
} }
// @@ Make sure that warp size == 32 // @@ Make sure that warp size == 32
// @@ Make sure available GPU is faster than the CPU. return count > 0;
#else
return count > 0; return false;
#else #endif
return false; }
#endif
} /// Get number of CUDA enabled devices.
int nv::cuda::deviceCount()
/// Get number of CUDA enabled devices. {
int nv::cuda::deviceCount() #if defined HAVE_CUDA
{ int gpuCount = 0;
#if defined HAVE_CUDA
int gpuCount = 0; cudaError_t result = cudaGetDeviceCount(&gpuCount);
cudaError_t result = cudaGetDeviceCount(&gpuCount); if (result == cudaSuccess)
{
if (result == cudaSuccess) return gpuCount;
{ }
return gpuCount; #endif
} return 0;
#endif }
return 0;
} int nv::cuda::getFastestDevice()
{
int max_gflops_device = 0;
// Make sure device meets requirements: #if defined HAVE_CUDA
// - Not an emulation device. int max_gflops = 0;
// - Not an integrated device?
// - Faster than CPU. const int device_count = deviceCount();
bool nv::cuda::isValidDevice(int i) int current_device = 0;
{ while (current_device < device_count)
#if defined HAVE_CUDA {
cudaDeviceProp device_properties;
cudaDeviceProp device_properties; cudaGetDeviceProperties(&device_properties, current_device);
cudaGetDeviceProperties(&device_properties, i); int gflops = device_properties.multiProcessorCount * device_properties.clockRate;
int gflops = device_properties.multiProcessorCount * device_properties.clockRate;
if (device_properties.major != -1 && device_properties.minor != -1)
if (device_properties.major == -1 || device_properties.minor == -1) { {
// Emulation device. if( gflops > max_gflops )
return false; {
} max_gflops = gflops;
max_gflops_device = current_device;
#if CUDART_VERSION >= 2030 // 2.3 }
/*if (device_properties.integrated) }
{
// Integrated devices. current_device++;
return false; }
}*/ #endif
#endif return max_gflops_device;
}
return true;
#else
return false; /// Activate the given devices.
#endif bool nv::cuda::setDevice(int i)
} {
nvCheck(i < deviceCount());
int nv::cuda::getFastestDevice() #if defined HAVE_CUDA
{ cudaError_t result = cudaSetDevice(i);
int max_gflops_device = -1;
#if defined HAVE_CUDA if (result != cudaSuccess) {
int max_gflops = 0; nvDebug("*** CUDA Error: %s\n", cudaGetErrorString(result));
}
const int device_count = deviceCount();
for (int i = 0; i < device_count; i++) return result == cudaSuccess;
{ #else
if (isValidDevice(i)) return false;
{ #endif
cudaDeviceProp device_properties; }
cudaGetDeviceProperties(&device_properties, i);
int gflops = device_properties.multiProcessorCount * device_properties.clockRate; void nv::cuda::exit()
{
if (gflops > max_gflops) #if defined HAVE_CUDA
{ cudaError_t result = cudaThreadExit();
max_gflops = gflops;
max_gflops_device = i; if (result != cudaSuccess) {
} nvDebug("*** CUDA Error: %s\n", cudaGetErrorString(result));
} }
} #endif
#endif }
return max_gflops_device;
}
/// Activate the given devices.
bool nv::cuda::initDevice(int * device_ptr)
{
nvDebugCheck(device_ptr != NULL);
#if defined HAVE_CUDA
#if CUDART_VERSION >= 2030 // 2.3
// Set device flags to yield in order to play nice with other threads and to find out if CUDA was already active.
cudaError_t resul = cudaSetDeviceFlags(cudaDeviceScheduleYield);
#endif
int device = getFastestDevice();
if (device == -1)
{
// No device is fast enough.
*device_ptr = -1;
return false;
}
// Select CUDA device.
cudaError_t result = cudaSetDevice(device);
if (result == cudaErrorSetOnActiveProcess)
{
int device;
result = cudaGetDevice(&device);
*device_ptr = -1; // No device to cleanup.
return isValidDevice(device); // Return true if device is valid.
}
else if (result != cudaSuccess)
{
nvDebug("*** CUDA Error: %s\n", cudaGetErrorString(result));
*device_ptr = -1;
return false;
}
*device_ptr = device;
return true;
#else
return false;
#endif
}
void nv::cuda::exitDevice()
{
#if defined HAVE_CUDA
cudaError_t result = cudaThreadExit();
if (result != cudaSuccess) {
nvDebug("*** CUDA Error: %s\n", cudaGetErrorString(result));
}
#endif
}

6
src/nvtt/cuda/CudaUtils.h
View File

@ -32,10 +32,8 @@ namespace nv
bool isHardwarePresent(); bool isHardwarePresent();
int deviceCount(); int deviceCount();
int getFastestDevice(); int getFastestDevice();
bool isValidDevice(int i); bool setDevice(int i);
void exit();
bool initDevice(int * device_ptr);
void exitDevice();
}; };
} // nv namespace } // nv namespace

4
src/nvtt/nvtt.h
View File

@ -73,7 +73,7 @@ namespace nvtt
Format_DXT1a, // DXT1 with binary alpha. Format_DXT1a, // DXT1 with binary alpha.
Format_DXT3, Format_DXT3,
Format_DXT5, Format_DXT5,
Format_DXT5n, // Compressed HILO: R=1, G=y, B=0, A=x Format_DXT5n, // Compressed HILO: R=0, G=x, B=0, A=y
// DX10 formats. // DX10 formats.
Format_BC1 = Format_DXT1, Format_BC1 = Format_DXT1,
@ -194,7 +194,7 @@ namespace nvtt
// Describe the format of the input. // Describe the format of the input.
NVTT_API void setFormat(InputFormat format); NVTT_API void setFormat(InputFormat format);
// Set the way the input alpha channel is interpreted. // Set the way the input alpha channel is interpreted. @@ Not implemented!
NVTT_API void setAlphaMode(AlphaMode alphaMode); NVTT_API void setAlphaMode(AlphaMode alphaMode);
// Set gamma settings. // Set gamma settings.

33
src/nvtt/squish/maths.cpp
View File

@ -24,7 +24,6 @@
-------------------------------------------------------------------------- */ -------------------------------------------------------------------------- */
#include "maths.h" #include "maths.h"
#include "simd.h"
#include <cfloat> #include <cfloat>
namespace squish { namespace squish {
@ -61,39 +60,12 @@ Sym3x3 ComputeWeightedCovariance( int n, Vec3 const* points, float const* weight
} }
#define POWER_ITERATION_COUNT 8
#if SQUISH_USE_SIMD
Vec3 ComputePrincipleComponent( Sym3x3 const& matrix ) Vec3 ComputePrincipleComponent( Sym3x3 const& matrix )
{ {
Vec4 const row0( matrix[0], matrix[1], matrix[2], 0.0f ); const int NUM = 8;
Vec4 const row1( matrix[1], matrix[3], matrix[4], 0.0f );
Vec4 const row2( matrix[2], matrix[4], matrix[5], 0.0f );
Vec4 v = VEC4_CONST( 1.0f );
for( int i = 0; i < POWER_ITERATION_COUNT; ++i )
{
// matrix multiply
Vec4 w = row0*v.SplatX();
w = MultiplyAdd(row1, v.SplatY(), w);
w = MultiplyAdd(row2, v.SplatZ(), w);
// get max component from xyz in all channels
Vec4 a = Max(w.SplatX(), Max(w.SplatY(), w.SplatZ()));
// divide through and advance
v = w*Reciprocal(a);
}
return v.GetVec3();
}
#else
Vec3 ComputePrincipleComponent( Sym3x3 const& matrix )
{
Vec3 v(1, 1, 1); Vec3 v(1, 1, 1);
for (int i = 0; i < POWER_ITERATION_COUNT; i++) for(int i = 0; i < NUM; i++) {
{
float x = v.X() * matrix[0] + v.Y() * matrix[1] + v.Z() * matrix[2]; float x = v.X() * matrix[0] + v.Y() * matrix[1] + v.Z() * matrix[2];
float y = v.X() * matrix[1] + v.Y() * matrix[3] + v.Z() * matrix[4]; float y = v.X() * matrix[1] + v.Y() * matrix[3] + v.Z() * matrix[4];
float z = v.X() * matrix[2] + v.Y() * matrix[4] + v.Z() * matrix[5]; float z = v.X() * matrix[2] + v.Y() * matrix[4] + v.Z() * matrix[5];
@ -110,6 +82,5 @@ Vec3 ComputePrincipleComponent( Sym3x3 const& matrix )
return v; return v;
} }
#endif
} // namespace squish } // namespace squish

969
src/nvtt/squish/weightedclusterfit.cpp
View File

File diff suppressed because it is too large Load Diff

43
src/nvtt/tools/compress.cpp
View File

@ -87,10 +87,7 @@ struct MyErrorHandler : public nvtt::ErrorHandler
{ {
virtual void error(nvtt::Error e) virtual void error(nvtt::Error e)
{ {
#if _DEBUG
nvDebugBreak(); nvDebugBreak();
#endif
printf("Error: '%s'\n", nvtt::errorString(e));
} }
}; };
@ -257,12 +254,7 @@ int main(int argc, char *argv[])
} }
} }
const uint version = nvtt::version(); printf("NVIDIA Texture Tools - Copyright NVIDIA Corporation 2007\n\n");
const uint major = version / 100;
const uint minor = version % 100;
printf("NVIDIA Texture Tools %u.%u - Copyright NVIDIA Corporation 2007\n\n", major, minor);
if (input.isNull()) if (input.isNull())
{ {
@ -289,7 +281,7 @@ int main(int argc, char *argv[])
printf(" -bc4 \tBC4 format (ATI1)\n"); printf(" -bc4 \tBC4 format (ATI1)\n");
printf(" -bc5 \tBC5 format (3Dc/ATI2)\n\n"); printf(" -bc5 \tBC5 format (3Dc/ATI2)\n\n");
return EXIT_FAILURE; return 1;
} }
// @@ Make sure input file exists. // @@ Make sure input file exists.
@ -304,13 +296,13 @@ int main(int argc, char *argv[])
if (!dds.isValid()) if (!dds.isValid())
{ {
fprintf(stderr, "The file '%s' is not a valid DDS file.\n", input.str()); fprintf(stderr, "The file '%s' is not a valid DDS file.\n", input.str());
return EXIT_FAILURE; return 1;
} }
if (!dds.isSupported() || dds.isTexture3D()) if (!dds.isSupported() || dds.isTexture3D())
{ {
fprintf(stderr, "The file '%s' is not a supported DDS file.\n", input.str()); fprintf(stderr, "The file '%s' is not a supported DDS file.\n", input.str());
return EXIT_FAILURE; return 1;
} }
uint faceCount; uint faceCount;
@ -347,7 +339,7 @@ int main(int argc, char *argv[])
if (!image.load(input)) if (!image.load(input))
{ {
fprintf(stderr, "The file '%s' is not a supported image type.\n", input.str()); fprintf(stderr, "The file '%s' is not a supported image type.\n", input.str());
return EXIT_FAILURE; return 1;
} }
inputOptions.setTextureLayout(nvtt::TextureType_2D, image.width(), image.height()); inputOptions.setTextureLayout(nvtt::TextureType_2D, image.width(), image.height());
@ -410,7 +402,7 @@ int main(int argc, char *argv[])
if (outputHandler.stream->isError()) if (outputHandler.stream->isError())
{ {
fprintf(stderr, "Error opening '%s' for writting\n", output.str()); fprintf(stderr, "Error opening '%s' for writting\n", output.str());
return EXIT_FAILURE; return 1;
} }
nvtt::Compressor compressor; nvtt::Compressor compressor;
@ -424,7 +416,7 @@ int main(int argc, char *argv[])
else else
{ {
printf("DISABLED\n\n"); printf("DISABLED\n\n");
} }
outputHandler.setTotal(compressor.estimateSize(inputOptions, compressionOptions)); outputHandler.setTotal(compressor.estimateSize(inputOptions, compressionOptions));
outputHandler.setDisplayProgress(!silent); outputHandler.setDisplayProgress(!silent);
@ -438,16 +430,27 @@ int main(int argc, char *argv[])
// fflush(stdout); // fflush(stdout);
// getchar(); // getchar();
/* LARGE_INTEGER temp;
QueryPerformanceFrequency((LARGE_INTEGER*) &temp);
double freq = ((double) temp.QuadPart) / 1000.0;
LARGE_INTEGER start_time;
QueryPerformanceCounter((LARGE_INTEGER*) &start_time);
*/
clock_t start = clock(); clock_t start = clock();
if (!compressor.process(inputOptions, compressionOptions, outputOptions)) compressor.process(inputOptions, compressionOptions, outputOptions);
{ /*
return EXIT_FAILURE; LARGE_INTEGER end_time;
} QueryPerformanceCounter((LARGE_INTEGER*) &end_time);
float diff_time = (float) (((double) end_time.QuadPart - (double) start_time.QuadPart) / freq);
printf("\rtime taken: %.3f seconds\n", diff_time/1000);
*/
clock_t end = clock(); clock_t end = clock();
printf("\rtime taken: %.3f seconds\n", float(end-start) / CLOCKS_PER_SEC); printf("\rtime taken: %.3f seconds\n", float(end-start) / CLOCKS_PER_SEC);
return EXIT_SUCCESS; return 0;
} }