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

Stop using custom memory allocators.

Browse Source 
Fix aliasing errors. Fixes issue 139 in trunk.
Fix build errors under OSX.
This commit is contained in:
castano 2010-10-06 02:56:35 +00:00
parent 06bf4ea960
commit df13c904b2
16 changed files with 318 additions and 339 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/nvcore/Array.h
View File

@ -60,7 +60,7 @@ struct PseudoIndexWrapper {
// Declare foreach keyword. // Declare foreach keyword.
#if !defined NV_NO_USE_KEYWORDS #if !defined NV_NO_USE_KEYWORDS
# define foreach NV_FOREACH # define foreach NV_FOREACH
#endif #endif
@ -340,7 +340,7 @@ namespace nv
// Destruct old elements (if we're shrinking). // Destruct old elements (if we're shrinking).
for( i = new_size; i < old_size; i++ ) { for( i = new_size; i < old_size; i++ ) {
(m_buffer+i)->~T(); // Explicit call to the destructor (m_buffer+i)->~T(); // Explicit call to the destructor
} }
if( m_size == 0 ) { if( m_size == 0 ) {
@ -380,7 +380,7 @@ namespace nv
// Destruct old elements (if we're shrinking). // Destruct old elements (if we're shrinking).
for( i = new_size; i < old_size; i++ ) { for( i = new_size; i < old_size; i++ ) {
(m_buffer+i)->~T(); // Explicit call to the destructor (m_buffer+i)->~T(); // Explicit call to the destructor
} }
if( m_size == 0 ) { if( m_size == 0 ) {
@ -503,15 +503,14 @@ namespace nv
// free the buffer. // free the buffer.
if (m_buffer_size == 0) { if (m_buffer_size == 0) {
if (m_buffer) { if (m_buffer) {
mem::free( m_buffer ); free( m_buffer );
m_buffer = NULL; m_buffer = NULL;
} }
} }
// realloc the buffer // realloc the buffer
else { else {
if (m_buffer) m_buffer = (T *) mem::realloc( m_buffer, sizeof(T) * m_buffer_size ); m_buffer = (T *) realloc( m_buffer, sizeof(T) * m_buffer_size );
else m_buffer = (T *) mem::malloc( sizeof(T) * m_buffer_size );
} }
} }

1
src/nvcore/CMakeLists.txt
View File

@ -10,6 +10,7 @@ SET(CORE_SRCS
DefsGnucWin32.h DefsGnucWin32.h
DefsVcWin32.h DefsVcWin32.h
FileSystem.h FileSystem.cpp FileSystem.h FileSystem.cpp
# FileMonitor.h FileMonitor.cpp
Library.h Library.cpp Library.h Library.cpp
Memory.h Memory.cpp Memory.h Memory.cpp
Ptr.h Ptr.h

6
src/nvcore/HashMap.h
View File

@ -232,7 +232,7 @@ namespace nv
e->clear(); e->clear();
} }
} }
mem::free(table); free(table);
table = NULL; table = NULL;
entry_count = 0; entry_count = 0;
size_mask = -1; size_mask = -1;
@ -503,7 +503,7 @@ namespace nv
new_size = nextPowerOfTwo(new_size); new_size = nextPowerOfTwo(new_size);
HashMap<T, U, H, E> new_hash; HashMap<T, U, H, E> new_hash;
new_hash.table = (Entry *) mem::malloc(sizeof(Entry) * new_size); new_hash.table = (Entry *) malloc(sizeof(Entry) * new_size);
nvDebugCheck(new_hash.table != NULL); nvDebugCheck(new_hash.table != NULL);
new_hash.entry_count = 0; new_hash.entry_count = 0;
@ -528,7 +528,7 @@ namespace nv
} }
// Delete our old data buffer. // Delete our old data buffer.
mem::free(table); free(table);
} }
// Steal new_hash's data. // Steal new_hash's data.

70
src/nvcore/Memory.cpp
View File

@ -15,7 +15,9 @@ extern "C" void EF_free(void * address);
using namespace nv; using namespace nv;
void * nv::mem::malloc(size_t size) #if NV_OVERRIDE_ALLOC
void * malloc(size_t size)
{ {
#if USE_EFENCE #if USE_EFENCE
return EF_malloc(size); return EF_malloc(size);
@ -24,7 +26,7 @@ void * nv::mem::malloc(size_t size)
#endif #endif
} }
void * nv::mem::malloc(size_t size, const char * file, int line) void * debug_malloc(size_t size, const char * file, int line)
{ {
NV_UNUSED(file); NV_UNUSED(file);
NV_UNUSED(line); NV_UNUSED(line);
@ -35,7 +37,7 @@ void * nv::mem::malloc(size_t size, const char * file, int line)
#endif #endif
} }
void nv::mem::free(const void * ptr) void free(void * ptr)
{ {
#if USE_EFENCE #if USE_EFENCE
return EF_free(const_cast<void *>(ptr)); return EF_free(const_cast<void *>(ptr));
@ -44,7 +46,7 @@ void nv::mem::free(const void * ptr)
#endif #endif
} }
void * nv::mem::realloc(void * ptr, size_t size) void * realloc(void * ptr, size_t size)
{ {
nvDebugCheck(ptr != NULL || size != 0); // undefined realloc behavior. nvDebugCheck(ptr != NULL || size != 0); // undefined realloc behavior.
#if USE_EFENCE #if USE_EFENCE
@ -54,3 +56,63 @@ void * nv::mem::realloc(void * ptr, size_t size)
#endif #endif
} }
/* No need to override this unless we want line info.
void * operator new (size_t size) throw()
{
return malloc(size);
}
void operator delete (void *p) throw()
{
free(p);
}
void * operator new [] (size_t size) throw()
{
return malloc(size);
}
void operator delete [] (void * p) throw()
{
free(p);
}
*/
#if 0 // Code from Apple:
void* operator new(std::size_t sz) throw (std::bad_alloc)
{
void *result = std::malloc (sz == 0 ? 1 : sz);
if (result == NULL)
throw std::bad_alloc();
gNewCounter++;
return result;
}
void operator delete(void* p) throw()
{
if (p == NULL)
return;
std::free (p);
gDeleteCounter++;
}
/* These are the 'nothrow' versions of the above operators.
The system version will try to call a std::new_handler if they
fail, but your overriding versions are not required to do this. */
void* operator new(std::size_t sz, const std::nothrow_t&) throw()
{
try {
void * result = ::operator new (sz); // calls our overridden operator new
return result;
} catch (std::bad_alloc &) {
return NULL;
}
}
void operator delete(void* p, const std::nothrow_t&) throw()
{
::operator delete (p);
}
#endif // 0
#endif // NV_OVERRIDE_ALLOC

177
src/nvcore/Memory.h
View File

@ -7,181 +7,42 @@
#include "nvcore.h" #include "nvcore.h"
#include <stdlib.h> // malloc(), realloc() and free() #include <stdlib.h> // malloc(), realloc() and free()
#include <stddef.h> // size_t #include <stddef.h> // size_t
#include <new> // new and delete #include <new> // new and delete
#define NV_OVERRIDE_ALLOC 0
#if NV_OVERRIDE_ALLOC
// Custom memory allocator // Custom memory allocator
namespace nv extern "C" {
{ NVCORE_API void * malloc(size_t size);
namespace mem NVCORE_API void * debug_malloc(size_t size, const char * file, int line);
{ NVCORE_API void free(void * ptr);
NVCORE_API void * malloc(size_t size); NVCORE_API void * realloc(void * ptr, size_t size);
NVCORE_API void * malloc(size_t size, const char * file, int line);
NVCORE_API void free(const void * ptr);
NVCORE_API void * realloc(void * ptr, size_t size);
} // mem namespace
} // nv namespace
// Override new/delete
inline void * operator new (size_t size) throw()
{
return nv::mem::malloc(size);
}
inline void operator delete (void *p) throw()
{
nv::mem::free(p);
}
inline void * operator new [] (size_t size) throw()
{
return nv::mem::malloc(size);
}
inline void operator delete [] (void * p) throw()
{
nv::mem::free(p);
} }
/* /*
#ifdef _DEBUG #ifdef _DEBUG
#define new new(__FILE__, __LINE__) #define new new(__FILE__, __LINE__)
#define malloc(i) malloc(i, __FILE__, __LINE__) #define malloc(i) debug_malloc(i, __FILE__, __LINE__)
#endif #endif
*/ */
#if 0 #endif
/*
File: main.cpp
Version: 1.0
Abstract: Overrides the C++ 'operator new' and 'operator delete'. // C++ helpers.
template <typename T> T * malloc(size_t count) {
Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple Computer, Inc. return (T *)::malloc(sizeof(T) * count);
("Apple") in consideration of your agreement to the following terms, and your
use, installation, modification or redistribution of this Apple software
constitutes acceptance of these terms. If you do not agree with these terms,
please do not use, install, modify or redistribute this Apple software.
In consideration of your agreement to abide by the following terms, and subject
to these terms, Apple grants you a personal, non-exclusive license, under Apple’s
copyrights in this original Apple software (the "Apple Software"), to use,
reproduce, modify and redistribute the Apple Software, with or without
modifications, in source and/or binary forms; provided that if you redistribute
the Apple Software in its entirety and without modifications, you must retain
this notice and the following text and disclaimers in all such redistributions of
the Apple Software. Neither the name, trademarks, service marks or logos of
Apple Computer, Inc. may be used to endorse or promote products derived from the
Apple Software without specific prior written permission from Apple. Except as
expressly stated in this notice, no other rights or licenses, express or implied,
are granted by Apple herein, including but not limited to any patent rights that
may be infringed by your derivative works or by other works in which the Apple
Software may be incorporated.
The Apple Software is provided by Apple on an "AS IS" basis. APPLE MAKES NO
WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN
COMBINATION WITH YOUR PRODUCTS.
IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION
OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, TORT
(INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Copyright © 2006 Apple Computer, Inc., All Rights Reserved
*/
/* This sample shows how to override the C++ global 'new' and 'delete' operators. */
#include <new>
#include <iostream>
#include <cstdlib>
#include <stdexcept>
#include <locale>
/* Some variables and code to make the example do something. */
namespace {
unsigned long long gNewCounter; // number of times 'new' was called
unsigned long long gDeleteCounter; // number of times 'delete' was called
void printCounters() // print the counters above
{
std::cout << "new was called " << gNewCounter << " times and delete was called " << gDeleteCounter << " times\n";
}
} }
/* These are the overridden new and delete routines. template <typename T> T * realloc(T * ptr, size_t count) {
Most applications will want to override at least these four versions of new/delete if they override any of them. return (T *)::realloc(ptr, sizeof(T) * count);
In Mac OS, it's not necessary to override the array versions of operator new and delete if all
they would do is call the non-array versions; the C++ standard library, as an extension
to the C++ standard, does this for you.
Developers should consult the section [lib.support.dynamic] in the C++ standard to see the requirements
on the generic operators new and delete; the system may expect that your overridden operators meet all these
requirements.
Your operators may be called by the system, even early in start-up before constructors have been executed. */
void* operator new(std::size_t sz) throw (std::bad_alloc)
{
void *result = std::malloc (sz == 0 ? 1 : sz);
if (result == NULL)
throw std::bad_alloc();
gNewCounter++;
return result;
}
void operator delete(void* p) throw()
{
if (p == NULL)
return;
std::free (p);
gDeleteCounter++;
} }
/* These are the 'nothrow' versions of the above operators. template <typename T> void free(const T * ptr) {
The system version will try to call a std::new_handler if they ::free((T *)ptr);
fail, but your overriding versions are not required to do this. */
void* operator new(std::size_t sz, const std::nothrow_t&) throw()
{
try {
void * result = ::operator new (sz); // calls our overridden operator new
return result;
} catch (std::bad_alloc &) {
return NULL;
}
} }
void operator delete(void* p, const std::nothrow_t&) throw()
{
::operator delete (p);
}
/* Bug 4067110 is that if your program has no weak symbols at all, the linker will not set the
WEAK_DEFINES bit in the Mach-O header and as a result the new and delete operators above won't
be seen by system libraries. This is mostly a problem for test programs and small examples,
since almost all real C++ programs complicated enough to override new and delete will have at
least one weak symbol. However, this is a small example, so: */
void __attribute__((weak, visibility("default"))) workaroundFor4067110 () { }
/* This is a simple test program that causes the runtime library to call new and delete. */
int main()
{
atexit (printCounters);
try {
std::locale example("does_not_exist");
} catch (std::runtime_error &x) {
}
return 0;
}
#endif // 0
#endif // NV_CORE_MEMORY_H #endif // NV_CORE_MEMORY_H

2
src/nvcore/Ptr.h
View File

@ -6,7 +6,7 @@
#include "nvcore.h" #include "nvcore.h"
#include "Debug.h" #include "Debug.h"
#include "RefCounted.h"
namespace nv namespace nv
{ {

59
src/nvcore/StdStream.h
View File

@ -43,7 +43,13 @@ namespace nv
virtual ~StdStream() virtual ~StdStream()
{ {
if( m_fp != NULL && m_autoclose ) { if( m_fp != NULL && m_autoclose ) {
#if NV_OS_WIN32
_fclose_nolock( m_fp ); _fclose_nolock( m_fp );
#elif NV_OS_LINUX
fclose_unlocked( m_fp );
#else
fclose( m_fp );
#endif
} }
} }
@ -54,22 +60,46 @@ namespace nv
{ {
nvDebugCheck(m_fp != NULL); nvDebugCheck(m_fp != NULL);
nvDebugCheck(pos < size()); nvDebugCheck(pos < size());
#if NV_OS_WIN32
_fseek_nolock(m_fp, pos, SEEK_SET); _fseek_nolock(m_fp, pos, SEEK_SET);
#elif NV_OS_LINUX
fseek_unlocked(m_fp, pos, SEEK_SET);
#else
fseek(m_fp, pos, SEEK_SET);
#endif
} }
virtual uint tell() const virtual uint tell() const
{ {
nvDebugCheck(m_fp != NULL); nvDebugCheck(m_fp != NULL);
#if NV_OS_WIN32
return _ftell_nolock(m_fp); return _ftell_nolock(m_fp);
#elif NV_OS_LINUX
return ftell_unlocked(m_fp);
#else
return ftell(m_fp);
#endif
} }
virtual uint size() const virtual uint size() const
{ {
nvDebugCheck(m_fp != NULL); nvDebugCheck(m_fp != NULL);
uint pos = ftell(m_fp); #if NV_OS_WIN32
uint pos = _ftell_nolock(m_fp);
_fseek_nolock(m_fp, 0, SEEK_END); _fseek_nolock(m_fp, 0, SEEK_END);
uint end = ftell(m_fp); uint end = _ftell_nolock(m_fp);
_fseek_nolock(m_fp, pos, SEEK_SET); _fseek_nolock(m_fp, pos, SEEK_SET);
#elif NV_OS_LINUX
uint pos = ftell_unlocked(m_fp);
fseek_unlocked(m_fp, 0, SEEK_END);
uint end = ftell_unlocked(m_fp);
fseek_unlocked(m_fp, pos, SEEK_SET);
#else
uint pos = ftell(m_fp);
fseek(m_fp, 0, SEEK_END);
uint end = ftell(m_fp);
fseek(m_fp, pos, SEEK_SET);
#endif
return end; return end;
} }
@ -123,7 +153,19 @@ namespace nv
{ {
nvDebugCheck(data != NULL); nvDebugCheck(data != NULL);
nvDebugCheck(m_fp != NULL); nvDebugCheck(m_fp != NULL);
#if NV_OS_WIN32
return (uint)_fwrite_nolock(data, 1, len, m_fp); return (uint)_fwrite_nolock(data, 1, len, m_fp);
#elif NV_OS_LINUX
return (uint)fwrite_unlocked(data, 1, len, m_fp);
#elif NV_OS_DARWIN
// @@ No error checking, always returns len.
for (uint i = 0; i < len; i++) {
putc_unlocked(((char *)data)[i], m_fp);
}
return len;
#else
return (uint)fwrite(data, 1, len, m_fp);
#endif
} }
virtual bool isLoading() const virtual bool isLoading() const
@ -161,7 +203,20 @@ namespace nv
{ {
nvDebugCheck(data != NULL); nvDebugCheck(data != NULL);
nvDebugCheck(m_fp != NULL); nvDebugCheck(m_fp != NULL);
#if NV_OS_WIN32
return (uint)_fread_nolock(data, 1, len, m_fp); return (uint)_fread_nolock(data, 1, len, m_fp);
#elif NV_OS_LINUX
return (uint)fread_unlocked(data, 1, len, m_fp);
#elif NV_OS_DARWIN
// @@ No error checking, always returns len.
for (uint i = 0; i < len; i++) {
((char *)data)[i] = getc_unlocked(m_fp);
}
return len;
#else
return (uint)fread(data, 1, len, m_fp);
#endif
} }
virtual bool isLoading() const virtual bool isLoading() const

18
src/nvcore/StrLib.cpp
View File

@ -15,26 +15,26 @@ namespace
{ {
static char * strAlloc(uint size) static char * strAlloc(uint size)
{ {
return static_cast<char *>(mem::malloc(size)); return static_cast<char *>(malloc(size));
} }
static char * strReAlloc(char * str, uint size) static char * strReAlloc(char * str, uint size)
{ {
return static_cast<char *>(mem::realloc(str, size)); return static_cast<char *>(realloc(str, size));
} }
static void strFree(const char * str) static void strFree(const char * str)
{ {
return mem::free(const_cast<char *>(str)); return free(const_cast<char *>(str));
} }
/*static char * strDup( const char * str ) /*static char * strDup( const char * str )
{ {
nvDebugCheck( str != NULL ); nvDebugCheck( str != NULL );
uint len = uint(strlen( str ) + 1); uint len = uint(strlen( str ) + 1);
char * dup = strAlloc( len ); char * dup = strAlloc( len );
memcpy( dup, str, len ); memcpy( dup, str, len );
return dup; return dup;
}*/ }*/
// helper function for integer to string conversion. // helper function for integer to string conversion.

4
src/nvcore/StrLib.h
View File

@ -314,7 +314,7 @@ namespace nv
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); free(data - 2);
data = NULL; data = NULL;
} }
} }
@ -343,7 +343,7 @@ namespace nv
void allocString(const char * str, int len) void allocString(const char * str, int len)
{ {
const char * ptr = static_cast<const char *>(mem::malloc(2 + len + 1)); const char * ptr = static_cast<const char *>(malloc(2 + len + 1));
setData( ptr ); setData( ptr );
setRefCount( 0 ); setRefCount( 0 );

6
src/nvimage/FloatImage.cpp
View File

@ -138,13 +138,13 @@ void FloatImage::allocate(uint c, uint w, uint h)
m_height = h; m_height = h;
m_componentNum = c; m_componentNum = c;
m_count = w * h * c; m_count = w * h * c;
m_mem = reinterpret_cast<float *>(nv::mem::malloc(m_count * sizeof(float))); m_mem = malloc<float>(m_count);
} }
/// Free the image, but don't clear the members. /// Free the image, but don't clear the members.
void FloatImage::free() void FloatImage::free()
{ {
nv::mem::free( reinterpret_cast<void *>(m_mem) ); ::free(m_mem);
m_mem = NULL; m_mem = NULL;
} }
@ -152,7 +152,7 @@ void FloatImage::resizeChannelCount(uint c)
{ {
if (m_componentNum != c) { if (m_componentNum != c) {
uint count = m_width * m_height * c; uint count = m_width * m_height * c;
nv::mem::realloc(m_mem, count * sizeof(float)); realloc(m_mem, count * sizeof(float));
if (c > m_componentNum) { if (c > m_componentNum) {
memset(m_mem + m_count, 0, (count - m_count) * sizeof(float)); memset(m_mem + m_count, 0, (count - m_count) * sizeof(float));

6
src/nvimage/Image.cpp
View File

@ -39,10 +39,10 @@ const Image & Image::operator=(const Image & img)
void Image::allocate(uint w, uint h) void Image::allocate(uint w, uint h)
{ {
free(); free();
m_width = w; m_width = w;
m_height = h; m_height = h;
m_data = (Color32 *)nv::mem::realloc(m_data, w * h * sizeof(Color32)); m_data = (Color32 *)realloc(m_data, w * h * sizeof(Color32));
} }
bool Image::load(const char * name) bool Image::load(const char * name)
@ -80,7 +80,7 @@ void Image::unwrap()
void Image::free() void Image::free()
{ {
nv::mem::free(m_data); ::free(m_data);
m_data = NULL; m_data = NULL;
} }

18
src/nvmath/Vector.h
View File

@ -64,7 +64,7 @@ namespace nv
const Vector3 & operator=(Vector3::Arg v); const Vector3 & operator=(Vector3::Arg v);
const Vector2 & xy() const; Vector2 xy() const;
const scalar * ptr() const; const scalar * ptr() const;
@ -104,8 +104,8 @@ namespace nv
const Vector4 & operator=(Vector4::Arg v); const Vector4 & operator=(Vector4::Arg v);
const Vector2 & xy() const; Vector2 xy() const;
const Vector3 & xyz() const; Vector3 xyz() const;
const scalar * ptr() const; const scalar * ptr() const;
@ -211,9 +211,9 @@ namespace nv
} }
inline const Vector2 & Vector3::xy() const inline Vector2 Vector3::xy() const
{ {
return *(Vector2 *)this; return Vector2(x, y);
} }
inline const scalar * Vector3::ptr() const inline const scalar * Vector3::ptr() const
@ -297,14 +297,14 @@ namespace nv
return *this; return *this;
} }
inline const Vector2 & Vector4::xy() const inline Vector2 Vector4::xy() const
{ {
return *(Vector2 *)this; return Vector2(x, y);
} }
inline const Vector3 & Vector4::xyz() const inline Vector3 Vector4::xyz() const
{ {
return *(Vector3 *)this; return Vector3(x, y, z);
} }
inline const scalar * Vector4::ptr() const inline const scalar * Vector4::ptr() const

95
src/nvtt/CMakeLists.txt
View File

@ -5,50 +5,51 @@ ADD_SUBDIRECTORY(bc6h)
#ADD_SUBDIRECTORY(bc7) #ADD_SUBDIRECTORY(bc7)
SET(NVTT_SRCS SET(NVTT_SRCS
nvtt.h nvtt.h
nvtt.cpp nvtt.cpp
Context.h Context.h
Context.cpp Context.cpp
nvtt_wrapper.h nvtt_wrapper.h
nvtt_wrapper.cpp nvtt_wrapper.cpp
Compressor.h Compressor.h
CompressorDXT.h CompressorDXT.h
CompressorDXT.cpp CompressorDXT.cpp
CompressorDX9.h CompressorDX9.h
CompressorDX9.cpp CompressorDX9.cpp
CompressorDX10.h CompressorDX10.h
CompressorDX10.cpp CompressorDX10.cpp
CompressorDX11.h CompressorDX11.h
CompressorDX11.cpp CompressorDX11.cpp
CompressorRGB.h CompressorRGB.h
CompressorRGB.cpp CompressorRGB.cpp
CompressorRGBE.h CompressorRGBE.h
CompressorRGBE.cpp CompressorRGBE.cpp
QuickCompressDXT.h QuickCompressDXT.h
QuickCompressDXT.cpp QuickCompressDXT.cpp
OptimalCompressDXT.h OptimalCompressDXT.h
OptimalCompressDXT.cpp OptimalCompressDXT.cpp
SingleColorLookup.h SingleColorLookup.h
CompressionOptions.h SingleColorLookup.cpp
CompressionOptions.cpp CompressionOptions.h
InputOptions.h CompressionOptions.cpp
InputOptions.cpp InputOptions.h
OutputOptions.h InputOptions.cpp
OutputOptions.cpp OutputOptions.h
TexImage.h TexImage.cpp OutputOptions.cpp
cuda/CudaUtils.h TexImage.h TexImage.cpp
cuda/CudaUtils.cpp cuda/CudaUtils.h
cuda/CudaMath.h cuda/CudaUtils.cpp
cuda/BitmapTable.h cuda/CudaMath.h
cuda/CudaCompressorDXT.h cuda/BitmapTable.h
cuda/CudaCompressorDXT.cpp) cuda/CudaCompressorDXT.h
cuda/CudaCompressorDXT.cpp)
IF (CUDA_FOUND) IF (CUDA_FOUND)
ADD_DEFINITIONS(-DHAVE_CUDA) ADD_DEFINITIONS(-DHAVE_CUDA)
CUDA_COMPILE(CUDA_SRCS cuda/CompressKernel.cu) CUDA_COMPILE(CUDA_SRCS cuda/CompressKernel.cu)
SET(NVTT_SRCS ${NVTT_SRCS} ${CUDA_SRCS}) SET(NVTT_SRCS ${NVTT_SRCS} ${CUDA_SRCS})
SET(LIBS ${LIBS} ${CUDA_LIBRARIES}) SET(LIBS ${LIBS} ${CUDA_LIBRARIES})
INCLUDE_DIRECTORIES(${CUDA_INCLUDE_DIRS}) INCLUDE_DIRECTORIES(${CUDA_INCLUDE_DIRS})
ENDIF (CUDA_FOUND) ENDIF (CUDA_FOUND)
INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}) INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
@ -56,17 +57,17 @@ INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
ADD_DEFINITIONS(-DNVTT_EXPORTS) ADD_DEFINITIONS(-DNVTT_EXPORTS)
IF(NVTT_SHARED) IF(NVTT_SHARED)
ADD_LIBRARY(nvtt SHARED ${NVTT_SRCS}) ADD_LIBRARY(nvtt SHARED ${NVTT_SRCS})
ELSE(NVTT_SHARED) ELSE(NVTT_SHARED)
ADD_LIBRARY(nvtt ${NVTT_SRCS}) ADD_LIBRARY(nvtt ${NVTT_SRCS})
ENDIF(NVTT_SHARED) ENDIF(NVTT_SHARED)
TARGET_LINK_LIBRARIES(nvtt ${LIBS} nvcore nvmath nvimage squish bc6h) TARGET_LINK_LIBRARIES(nvtt ${LIBS} nvcore nvmath nvimage squish bc6h)
INSTALL(TARGETS nvtt INSTALL(TARGETS nvtt
RUNTIME DESTINATION bin RUNTIME DESTINATION bin
LIBRARY DESTINATION lib LIBRARY DESTINATION lib
ARCHIVE DESTINATION lib/static) ARCHIVE DESTINATION lib/static)
INSTALL(FILES nvtt.h DESTINATION include/nvtt) INSTALL(FILES nvtt.h DESTINATION include/nvtt)

168
src/nvtt/CompressorRGB.cpp
View File

@ -123,86 +123,86 @@ namespace
void PixelFormatConverter::compress(nvtt::InputFormat inputFormat, nvtt::AlphaMode alphaMode, uint w, uint h, const void * data, const nvtt::CompressionOptions::Private & compressionOptions, const nvtt::OutputOptions::Private & outputOptions) void PixelFormatConverter::compress(nvtt::InputFormat inputFormat, nvtt::AlphaMode alphaMode, uint w, uint h, const void * data, const nvtt::CompressionOptions::Private & compressionOptions, const nvtt::OutputOptions::Private & outputOptions)
{ {
uint bitCount; uint bitCount;
uint rmask, rshift, rsize; uint rmask, rshift, rsize;
uint gmask, gshift, gsize; uint gmask, gshift, gsize;
uint bmask, bshift, bsize; uint bmask, bshift, bsize;
uint amask, ashift, asize; uint amask, ashift, asize;
if (compressionOptions.pixelType == nvtt::PixelType_Float) if (compressionOptions.pixelType == nvtt::PixelType_Float)
{ {
rsize = compressionOptions.rsize; rsize = compressionOptions.rsize;
gsize = compressionOptions.gsize; gsize = compressionOptions.gsize;
bsize = compressionOptions.bsize; bsize = compressionOptions.bsize;
asize = compressionOptions.asize; asize = compressionOptions.asize;
nvCheck(rsize == 0 || rsize == 16 || rsize == 32); nvCheck(rsize == 0 || rsize == 16 || rsize == 32);
nvCheck(gsize == 0 || gsize == 16 || gsize == 32); nvCheck(gsize == 0 || gsize == 16 || gsize == 32);
nvCheck(bsize == 0 || bsize == 16 || bsize == 32); nvCheck(bsize == 0 || bsize == 16 || bsize == 32);
nvCheck(asize == 0 || asize == 16 || asize == 32); nvCheck(asize == 0 || asize == 16 || asize == 32);
bitCount = rsize + gsize + bsize + asize; bitCount = rsize + gsize + bsize + asize;
} }
else else
{ {
if (compressionOptions.bitcount != 0) if (compressionOptions.bitcount != 0)
{ {
bitCount = compressionOptions.bitcount; bitCount = compressionOptions.bitcount;
nvCheck(bitCount <= 32); nvCheck(bitCount <= 32);
rmask = compressionOptions.rmask; rmask = compressionOptions.rmask;
gmask = compressionOptions.gmask; gmask = compressionOptions.gmask;
bmask = compressionOptions.bmask; bmask = compressionOptions.bmask;
amask = compressionOptions.amask; amask = compressionOptions.amask;
PixelFormat::maskShiftAndSize(rmask, &rshift, &rsize); PixelFormat::maskShiftAndSize(rmask, &rshift, &rsize);
PixelFormat::maskShiftAndSize(gmask, &gshift, &gsize); PixelFormat::maskShiftAndSize(gmask, &gshift, &gsize);
PixelFormat::maskShiftAndSize(bmask, &bshift, &bsize); PixelFormat::maskShiftAndSize(bmask, &bshift, &bsize);
PixelFormat::maskShiftAndSize(amask, &ashift, &asize); PixelFormat::maskShiftAndSize(amask, &ashift, &asize);
} }
else else
{ {
rsize = compressionOptions.rsize; rsize = compressionOptions.rsize;
gsize = compressionOptions.gsize; gsize = compressionOptions.gsize;
bsize = compressionOptions.bsize; bsize = compressionOptions.bsize;
asize = compressionOptions.asize; asize = compressionOptions.asize;
bitCount = rsize + gsize + bsize + asize; bitCount = rsize + gsize + bsize + asize;
nvCheck(bitCount <= 32); nvCheck(bitCount <= 32);
ashift = 0; ashift = 0;
bshift = ashift + asize; bshift = ashift + asize;
gshift = bshift + bsize; gshift = bshift + bsize;
rshift = gshift + gsize; rshift = gshift + gsize;
rmask = ((1 << rsize) - 1) << rshift; rmask = ((1 << rsize) - 1) << rshift;
gmask = ((1 << gsize) - 1) << gshift; gmask = ((1 << gsize) - 1) << gshift;
bmask = ((1 << bsize) - 1) << bshift; bmask = ((1 << bsize) - 1) << bshift;
amask = ((1 << asize) - 1) << ashift; amask = ((1 << asize) - 1) << ashift;
} }
} }
const uint pitch = computePitch(w, bitCount, compressionOptions.pitchAlignment); const uint pitch = computePitch(w, bitCount, compressionOptions.pitchAlignment);
const uint wh = w * h; const uint wh = w * h;
// Allocate output scanline. // Allocate output scanline.
uint8 * const dst = (uint8 *)mem::malloc(pitch); uint8 * const dst = malloc<uint8>(pitch);
for (uint y = 0; y < h; y++) for (uint y = 0; y < h; y++)
{ {
const uint * src = (const uint *)data + y * w; const uint * src = (const uint *)data + y * w;
const float * fsrc = (const float *)data + y * w; const float * fsrc = (const float *)data + y * w;
if (inputFormat == nvtt::InputFormat_BGRA_8UB && compressionOptions.pixelType == nvtt::PixelType_UnsignedNorm && bitCount == 32 && rmask == 0xFF0000 && gmask == 0xFF00 && bmask == 0xFF && amask == 0xFF000000) if (inputFormat == nvtt::InputFormat_BGRA_8UB && compressionOptions.pixelType == nvtt::PixelType_UnsignedNorm && bitCount == 32 && rmask == 0xFF0000 && gmask == 0xFF00 && bmask == 0xFF && amask == 0xFF000000)
{ {
convert_to_a8r8g8b8(src, dst, w); convert_to_a8r8g8b8(src, dst, w);
} }
else else
{ {
BitStream stream(dst); BitStream stream(dst);
for (uint x = 0; x < w; x++) for (uint x = 0; x < w; x++)
{ {
float r, g, b, a; float r, g, b, a;
if (inputFormat == nvtt::InputFormat_BGRA_8UB) { if (inputFormat == nvtt::InputFormat_BGRA_8UB) {
@ -215,29 +215,29 @@ void PixelFormatConverter::compress(nvtt::InputFormat inputFormat, nvtt::AlphaMo
else { else {
nvDebugCheck (inputFormat == nvtt::InputFormat_RGBA_32F); nvDebugCheck (inputFormat == nvtt::InputFormat_RGBA_32F);
//r = ((float *)src)[4 * x + 0]; // Color components not interleaved. //r = ((float *)src)[4 * x + 0]; // Color components not interleaved.
//g = ((float *)src)[4 * x + 1]; //g = ((float *)src)[4 * x + 1];
//b = ((float *)src)[4 * x + 2]; //b = ((float *)src)[4 * x + 2];
//a = ((float *)src)[4 * x + 3]; //a = ((float *)src)[4 * x + 3];
r = fsrc[x + 0 * wh]; r = fsrc[x + 0 * wh];
g = fsrc[x + 1 * wh]; g = fsrc[x + 1 * wh];
b = fsrc[x + 2 * wh]; b = fsrc[x + 2 * wh];
a = fsrc[x + 3 * wh]; a = fsrc[x + 3 * wh];
} }
if (compressionOptions.pixelType == nvtt::PixelType_Float) if (compressionOptions.pixelType == nvtt::PixelType_Float)
{ {
if (rsize == 32) stream.putFloat(r); if (rsize == 32) stream.putFloat(r);
else if (rsize == 16) stream.putHalf(r); else if (rsize == 16) stream.putHalf(r);
if (gsize == 32) stream.putFloat(g); if (gsize == 32) stream.putFloat(g);
else if (gsize == 16) stream.putHalf(g); else if (gsize == 16) stream.putHalf(g);
if (bsize == 32) stream.putFloat(b); if (bsize == 32) stream.putFloat(b);
else if (bsize == 16) stream.putHalf(b); else if (bsize == 16) stream.putHalf(b);
if (asize == 32) stream.putFloat(a); if (asize == 32) stream.putFloat(a);
else if (asize == 16) stream.putHalf(a); else if (asize == 16) stream.putHalf(a);
} }
else else
{ {
@ -250,34 +250,34 @@ void PixelFormatConverter::compress(nvtt::InputFormat inputFormat, nvtt::AlphaMo
} }
// @@ Add support for nvtt::PixelType_SignedInt, nvtt::PixelType_SignedNorm, nvtt::PixelType_UnsignedInt // @@ Add support for nvtt::PixelType_SignedInt, nvtt::PixelType_SignedNorm, nvtt::PixelType_UnsignedInt
uint p = 0; uint p = 0;
p |= PixelFormat::convert(c.r, 8, rsize) << rshift; p |= PixelFormat::convert(c.r, 8, rsize) << rshift;
p |= PixelFormat::convert(c.g, 8, gsize) << gshift; p |= PixelFormat::convert(c.g, 8, gsize) << gshift;
p |= PixelFormat::convert(c.b, 8, bsize) << bshift; p |= PixelFormat::convert(c.b, 8, bsize) << bshift;
p |= PixelFormat::convert(c.a, 8, asize) << ashift; p |= PixelFormat::convert(c.a, 8, asize) << ashift;
stream.putBits(p, bitCount); stream.putBits(p, bitCount);
// Output one byte at a time. // Output one byte at a time.
/*for (uint i = 0; i < byteCount; i++) /*for (uint i = 0; i < byteCount; i++)
{ {
*(dst + x * byteCount + i) = (p >> (i * 8)) & 0xFF; *(dst + x * byteCount + i) = (p >> (i * 8)) & 0xFF;
}*/ }*/
} }
} }
// Zero padding. // Zero padding.
stream.align(compressionOptions.pitchAlignment); stream.align(compressionOptions.pitchAlignment);
nvDebugCheck(stream.ptr == dst + pitch); nvDebugCheck(stream.ptr == dst + pitch);
/*for (uint x = w * byteCount; x < pitch; x++) /*for (uint x = w * byteCount; x < pitch; x++)
{ {
*(dst + x) = 0; *(dst + x) = 0;
}*/ }*/
} }
outputOptions.writeData(dst, pitch); outputOptions.writeData(dst, pitch);
} }
mem::free(dst); free(dst);
} }

6
src/nvtt/tests/process_alpha_map.cpp
View File

@ -60,10 +60,10 @@ int main(int argc, char *argv[])
outputFileNameColor.stripExtension(); outputFileNameColor.stripExtension();
outputFileNameColor.append(".dds"); outputFileNameColor.append(".dds");
colorOutputOptions.setFileName(outputFileNameColor); colorOutputOptions.setFileName(outputFileNameColor.str());
// Load normal map. // Load normal map.
nvtt::TexImage normalMap; nvtt::TexImage normalMap = context.createTexImage();
if (inputFileNameNormal != NULL) { if (inputFileNameNormal != NULL) {
normalMap = context.createTexImage(); normalMap = context.createTexImage();
if (!normalMap.load(inputFileNameColor)) { if (!normalMap.load(inputFileNameColor)) {
@ -89,7 +89,7 @@ int main(int argc, char *argv[])
outputFileNameNormal.stripExtension(); outputFileNameNormal.stripExtension();
outputFileNameNormal.append(".dds"); outputFileNameNormal.append(".dds");
normalOutputOptions.setFileName(outputFileNameNormal); normalOutputOptions.setFileName(outputFileNameNormal.str());
} }

10
src/nvtt/tools/thumbnailer.cpp
View File

@ -116,7 +116,7 @@ int main(int argc, char *argv[])
} }
nv::Image image; nv::Image image;
if (!loadImage(image, input)) return 1; if (!loadImage(image, input.str())) return 1;
nv::ImageIO::ImageMetaData metaData; nv::ImageIO::ImageMetaData metaData;
metaData.tagMap.add("Thumb::Image::Width", nv::StringBuilder().number (image.width())); metaData.tagMap.add("Thumb::Image::Width", nv::StringBuilder().number (image.width()));
@ -143,13 +143,13 @@ int main(int argc, char *argv[])
nv::AutoPtr<nv::Image> result(fresult->createImageGammaCorrect(gamma)); nv::AutoPtr<nv::Image> result(fresult->createImageGammaCorrect(gamma));
result->setFormat(nv::Image::Format_ARGB); result->setFormat(nv::Image::Format_ARGB);
nv::StdOutputStream stream(output); nv::StdOutputStream stream(output.str());
nv::ImageIO::save(output, stream, result.ptr(), &metaData); nv::ImageIO::save(output.str(), stream, result.ptr(), &metaData);
} }
else else
{ {
nv::StdOutputStream stream(output); nv::StdOutputStream stream(output.str());
nv::ImageIO::save(output, stream, &image, &metaData); nv::ImageIO::save(output.str(), stream, &image, &metaData);
} }
return 0; return 0;