From: hasufell Date: Sat, 14 Apr 2012 21:35:15 +0000 (+0200) Subject: dev-util/nvidia-texture-tools: New Ebuild for bug 407191 thanks to mgorny and binki X-Git-Url: http://pileus.org/git/?a=commitdiff_plain;h=6ea652108424bc72d7d83c9135dc36c89889a3ed;p=~andy%2Fsunrise dev-util/nvidia-texture-tools: New Ebuild for bug 407191 thanks to mgorny and binki --- diff --git a/dev-util/nvidia-texture-tools/ChangeLog b/dev-util/nvidia-texture-tools/ChangeLog new file mode 100644 index 000000000..6fc3d4a84 --- /dev/null +++ b/dev-util/nvidia-texture-tools/ChangeLog @@ -0,0 +1,13 @@ +# ChangeLog for dev-util/nvidia-texture-tools +# Copyright 1999-2012 Gentoo Foundation; Distributed under the GPL v2 +# $Header: $ + +*nvidia-texture-tools-2.0.8 (14 Apr 2012) + + 14 Apr 2012; hasufell + +nvidia-texture-tools-2.0.8.ebuild, +files/libpng1.5-build.patch, + +files/nvidia-texture-tools-2.0.8-cmake.patch, +files/cuda.patch, + +files/gcc4.4.4-aliasing.patch, +files/libtiff4.patch, +files/valgrind.patch, + +metadata.xml: + New Ebuild for bug 407191 thanks to mgorny and binki + diff --git a/dev-util/nvidia-texture-tools/Manifest b/dev-util/nvidia-texture-tools/Manifest new file mode 100644 index 000000000..0666946eb --- /dev/null +++ b/dev-util/nvidia-texture-tools/Manifest @@ -0,0 +1,10 @@ +AUX cuda.patch 722 RMD160 e76a003405e7fcfbe60023a1de3da659879e62bf SHA1 83dff56cbbec9d69c19e9a53502a27c301251f3f SHA256 ef3ecafbf040c0193ac6ad5dc86974f667d74a6a96eae2526ae2abbc14398f5c +AUX gcc4.4.4-aliasing.patch 1553 RMD160 18525e0eb8d3b8a0212e670243f01099e41ef97a SHA1 73272c8e6661c56dcaa9bf96d971cb7df77cec54 SHA256 12df5dab88246e239ff9c96bd87ccb86ea3769b6f817fee08d7613d1ae6b3a0c +AUX libpng1.5-build.patch 591 RMD160 89c68d37852bcd4d333a34efc2d5b7daa3b5a663 SHA1 9df903aff0253e99448efd446232f3109bc382ba SHA256 30aa82b877926e91e95139b89277ae3e73bc1c3c14e4abbc90378e42deacd8c3 +AUX libtiff4.patch 2897 RMD160 16485b0934b934139e33de995f39317de161384f SHA1 cff6768bf053606c0b4032b02b7f7f5538a2a41e SHA256 86ca76aacd4219d10326e54fce887943aea8cb55662bfbd4ffe7a9695f223448 +AUX nvidia-texture-tools-2.0.8-cmake.patch 4773 RMD160 9e819bf5c1104653db6a70aabc2315910b985cdf SHA1 b313d81da904023b25b431eb5df3ae0eabbb4116 SHA256 dde709ed016a60e82563992f6c5dfc41969432cbd83c4253a90248ab998c6649 +AUX valgrind.patch 26286 RMD160 d2b438833024c1448d0aef7221668e8853f2ad68 SHA1 e46eff41188629c831d53ce0b045e0b939b0e34d SHA256 2ee618e7d9ddfe11bc3f304e7045832bc0e1e3a79b70924996830cdd46676539 +DIST nvidia-texture-tools-2.0.8-1.tar.gz 935227 RMD160 dbb2a1ea4bef259af8520d881ab414d69ee0dea2 SHA1 3eaa578acc35159684748055aeb4bacdeaef12d1 SHA256 6b3c83500b420ee976f61eeae16e5727e2401e133f543baeac76c66c381eed2e +EBUILD nvidia-texture-tools-2.0.8.ebuild 1375 RMD160 47d54633aebb85675a0c9ce79b5cb59196415644 SHA1 693e199590ebc9249f719f23127288a3c18023f4 SHA256 6c24032d566bdd68f8458c7644c3db7ee7cd9651c3b4b88693b79bb1610d9457 +MISC ChangeLog 517 RMD160 cfea122640e4cfa7261d3b80f5eb54efdd557418 SHA1 e6627f0acc3fd46e94a637ad2d5a185b29934110 SHA256 6d0a68412c44ef1468f43a4790d1ae32f6a4fef4e34e788fc7624108d722f8a1 +MISC metadata.xml 382 RMD160 39b31924c1369a0478cd0ec709e01fd623178cba SHA1 566d696883a5795251bcadce39a4771dd535db17 SHA256 2f2e19993374f1de97db1723f09d4839997b76707510efce20dfb3123ba6a8ef diff --git a/dev-util/nvidia-texture-tools/files/cuda.patch b/dev-util/nvidia-texture-tools/files/cuda.patch new file mode 100644 index 000000000..abf6041a6 --- /dev/null +++ b/dev-util/nvidia-texture-tools/files/cuda.patch @@ -0,0 +1,16 @@ +Subject: Current CUDA runtime generates cpp code by default. Fix extension. +Origin: upstream, http://code.google.com/p/nvidia-texture-tools/source/detail?r=1157 + +Index: branches/2.0/cmake/FindCUDA.cmake +=================================================================== +--- branches/2.0/cmake/FindCUDA.cmake (revision 1156) ++++ branches/2.0/cmake/FindCUDA.cmake (revision 1157) +@@ -120,7 +120,7 @@ + FOREACH (CUFILE ${ARGN}) + GET_FILENAME_COMPONENT (CUFILE ${CUFILE} ABSOLUTE) + GET_FILENAME_COMPONENT (CFILE ${CUFILE} NAME_WE) +- SET (CFILE ${CMAKE_CURRENT_BINARY_DIR}/${CFILE}.gen.c) ++ SET (CFILE ${CMAKE_CURRENT_BINARY_DIR}/${CFILE}.gen.cpp) + + GET_CUFILE_DEPENDENCIES(CUDEPS ${CUFILE}) + #MESSAGE("${CUDEPS}") diff --git a/dev-util/nvidia-texture-tools/files/gcc4.4.4-aliasing.patch b/dev-util/nvidia-texture-tools/files/gcc4.4.4-aliasing.patch new file mode 100644 index 000000000..a362e7494 --- /dev/null +++ b/dev-util/nvidia-texture-tools/files/gcc4.4.4-aliasing.patch @@ -0,0 +1,59 @@ +Subject: Aliasing violation causes erroneous output in GCC 4.4.4 +Origin, upstream, http://code.google.com/p/nvidia-texture-tools/source/detail?r=1167 +Bug: http://code.google.com/p/nvidia-texture-tools/issues/detail?id=139 + +Index: src/src/nvmath/Vector.h +=================================================================== +--- src/src/nvmath/Vector.h (revision 8311) ++++ src/src/nvmath/Vector.h (working copy) +@@ -68,7 +68,7 @@ + scalar y() const; + scalar z() const; + +- const Vector2 & xy() const; ++ Vector2 xy() const; + + scalar component(uint idx) const; + +@@ -111,8 +111,8 @@ + scalar z() const; + scalar w() const; + +- const Vector2 & xy() const; +- const Vector3 & xyz() const; ++ Vector2 xy() const; ++ Vector3 xyz() const; + + scalar component(uint idx) const; + +@@ -231,9 +231,9 @@ + inline scalar Vector3::y() const { return m_y; } + inline scalar Vector3::z() const { return m_z; } + +-inline const Vector2 & Vector3::xy() const ++inline Vector2 Vector3::xy() const + { +- return *(Vector2 *)this; ++ return Vector2(m_x, m_y); + } + + inline scalar Vector3::component(uint idx) const +@@ -332,14 +332,14 @@ + inline scalar Vector4::z() const { return m_z; } + inline scalar Vector4::w() const { return m_w; } + +-inline const Vector2 & Vector4::xy() const ++inline Vector2 Vector4::xy() const + { +- return *(Vector2 *)this; ++ return Vector2(m_x, m_y); + } + +-inline const Vector3 & Vector4::xyz() const ++inline Vector3 Vector4::xyz() const + { +- return *(Vector3 *)this; ++ return Vector3(m_x, m_y, m_z); + } + + inline scalar Vector4::component(uint idx) const diff --git a/dev-util/nvidia-texture-tools/files/libpng1.5-build.patch b/dev-util/nvidia-texture-tools/files/libpng1.5-build.patch new file mode 100644 index 000000000..ce3622431 --- /dev/null +++ b/dev-util/nvidia-texture-tools/files/libpng1.5-build.patch @@ -0,0 +1,17 @@ +Subject: Fixed build with libpng1.5 +Last-Update: 2012-03-31 +Origin: upstream, http://code.google.com/p/nvidia-texture-tools/source/detail?r=1248 + +diff --git a/src/nvimage/ImageIO.cpp b/src/nvimage/ImageIO.cpp +index 0b24600..22e920a 100644 +--- a/src/nvimage/ImageIO.cpp ++++ b/src/nvimage/ImageIO.cpp +@@ -603,7 +603,7 @@ static void user_read_data(png_structp png_ptr, png_bytep data, png_size_t lengt + { + nvDebugCheck(png_ptr != NULL); + +- Stream * s = (Stream *)png_ptr->io_ptr; ++ Stream * s = (Stream *)png_get_io_ptr(png_ptr); + s->serialize(data, (int)length); + + if (s->isError()) { diff --git a/dev-util/nvidia-texture-tools/files/libtiff4.patch b/dev-util/nvidia-texture-tools/files/libtiff4.patch new file mode 100644 index 000000000..e78769eeb --- /dev/null +++ b/dev-util/nvidia-texture-tools/files/libtiff4.patch @@ -0,0 +1,116 @@ +Origin: upstream, http://code.google.com/p/nvidia-texture-tools/source/detail?r=1156 + +Index: branches/2.0/src/nvcore/nvcore.h +=================================================================== +--- branches/2.0/src/nvcore/nvcore.h (revision 1155) ++++ branches/2.0/src/nvcore/nvcore.h (revision 1156) +@@ -99,6 +99,23 @@ + #define NV_ENDIAN_STRING POSH_ENDIAN_STRING + + ++// Type definitions: ++typedef posh_u8_t uint8; ++typedef posh_i8_t int8; ++ ++typedef posh_u16_t uint16; ++typedef posh_i16_t int16; ++ ++typedef posh_u32_t uint32; ++typedef posh_i32_t int32; ++ ++typedef posh_u64_t uint64; ++typedef posh_i64_t int64; ++ ++// Aliases ++typedef uint32 uint; ++ ++ + // Version string: + #define NV_VERSION_STRING \ + NV_OS_STRING "/" NV_CC_STRING "/" NV_CPU_STRING"/" \ +Index: branches/2.0/src/nvcore/DefsVcWin32.h +=================================================================== +--- branches/2.0/src/nvcore/DefsVcWin32.h (revision 1155) ++++ branches/2.0/src/nvcore/DefsVcWin32.h (revision 1156) +@@ -39,7 +39,7 @@ + #define __FUNC__ __FUNCTION__ + #endif + +- ++/* + // Type definitions + typedef unsigned char uint8; + typedef signed char int8; +@@ -55,8 +55,8 @@ + + // Aliases + typedef uint32 uint; ++*/ + +- + // Unwanted VC++ warnings to disable. + /* + #pragma warning(disable : 4244) // conversion to float, possible loss of data +Index: branches/2.0/src/nvcore/DefsGnucDarwin.h +=================================================================== +--- branches/2.0/src/nvcore/DefsGnucDarwin.h (revision 1155) ++++ branches/2.0/src/nvcore/DefsGnucDarwin.h (revision 1156) +@@ -2,7 +2,7 @@ + #error "Do not include this file directly." + #endif + +-#include // uint8_t, int8_t, ... ++//#include // uint8_t, int8_t, ... + + // Function linkage + #define DLL_IMPORT +@@ -48,7 +48,7 @@ + + #define restrict __restrict__ + +- ++/* + // Type definitions + typedef uint8_t uint8; + typedef int8_t int8; +@@ -64,3 +64,4 @@ + + // Aliases + typedef uint32 uint; ++*/ +Index: branches/2.0/src/nvcore/DefsGnucLinux.h +=================================================================== +--- branches/2.0/src/nvcore/DefsGnucLinux.h (revision 1155) ++++ branches/2.0/src/nvcore/DefsGnucLinux.h (revision 1156) +@@ -47,7 +47,7 @@ + + #define restrict __restrict__ + +- ++/* + // Type definitions + typedef unsigned char uint8; + typedef signed char int8; +@@ -63,3 +63,4 @@ + + // Aliases + typedef uint32 uint; ++*/ +Index: branches/2.0/src/nvcore/DefsGnucWin32.h +=================================================================== +--- branches/2.0/src/nvcore/DefsGnucWin32.h (revision 1155) ++++ branches/2.0/src/nvcore/DefsGnucWin32.h (revision 1156) +@@ -41,7 +41,7 @@ + + #define restrict __restrict__ + +- ++/* + // Type definitions + typedef unsigned char uint8; + typedef signed char int8; +@@ -57,3 +57,4 @@ + + // Aliases + typedef uint32 uint; ++*/ diff --git a/dev-util/nvidia-texture-tools/files/nvidia-texture-tools-2.0.8-cmake.patch b/dev-util/nvidia-texture-tools/files/nvidia-texture-tools-2.0.8-cmake.patch new file mode 100644 index 000000000..f2cadfc61 --- /dev/null +++ b/dev-util/nvidia-texture-tools/files/nvidia-texture-tools-2.0.8-cmake.patch @@ -0,0 +1,176 @@ +From: hasufell +Date: Wed Apr 11 21:49:58 UTC 2012 +Subject: various cmake fixes + +fix hardcoded install paths for BINDIR and LIBDIR +make cg, cuda, glew, glut and openexr controllable and not automagic + +--- src/nvcore/CMakeLists.txt ++++ src/nvcore/CMakeLists.txt +@@ -42,6 +42,6 @@ + TARGET_LINK_LIBRARIES(nvcore ${LIBS}) + + INSTALL(TARGETS nvcore +- RUNTIME DESTINATION bin +- LIBRARY DESTINATION lib +- ARCHIVE DESTINATION lib/static) ++ RUNTIME DESTINATION ${BINDIR} ++ LIBRARY DESTINATION ${LIBDIR} ++ ARCHIVE DESTINATION ${LIBDIR}) +--- src/nvimage/CMakeLists.txt ++++ src/nvimage/CMakeLists.txt +@@ -62,7 +62,7 @@ + TARGET_LINK_LIBRARIES(nvimage ${LIBS} nvcore nvmath posh) + + INSTALL(TARGETS nvimage +- RUNTIME DESTINATION bin +- LIBRARY DESTINATION lib +- ARCHIVE DESTINATION lib/static) ++ RUNTIME DESTINATION ${BINDIR} ++ LIBRARY DESTINATION ${LIBDIR} ++ ARCHIVE DESTINATION ${LIBDIR}) + +--- src/nvmath/CMakeLists.txt ++++ src/nvmath/CMakeLists.txt +@@ -28,6 +28,6 @@ + TARGET_LINK_LIBRARIES(nvmath ${LIBS} nvcore) + + INSTALL(TARGETS nvmath +- RUNTIME DESTINATION bin +- LIBRARY DESTINATION lib +- ARCHIVE DESTINATION lib/static) ++ RUNTIME DESTINATION ${BINDIR} ++ LIBRARY DESTINATION ${LIBDIR} ++ ARCHIVE DESTINATION ${LIBDIR}) +--- src/nvtt/CMakeLists.txt ++++ src/nvtt/CMakeLists.txt +@@ -53,9 +53,9 @@ + TARGET_LINK_LIBRARIES(nvtt ${LIBS} nvcore nvmath nvimage squish) + + INSTALL(TARGETS nvtt +- RUNTIME DESTINATION bin +- LIBRARY DESTINATION lib +- ARCHIVE DESTINATION lib/static) ++ RUNTIME DESTINATION ${BINDIR} ++ LIBRARY DESTINATION ${LIBDIR} ++ ARCHIVE DESTINATION ${LIBDIR}) + + INSTALL(FILES nvtt.h DESTINATION include/nvtt) + +--- src/CMakeLists.txt ++++ src/CMakeLists.txt +@@ -5,6 +5,13 @@ + SUBDIRS(nvtt) + + INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}) ++ ++# initial variables ++SET(GLUT TRUE CACHE BOOL "") ++SET(GLEW TRUE CACHE BOOL "") ++SET(CG TRUE CACHE BOOL "") ++SET(CUDA TRUE CACHE BOOL "") ++SET(OPENEXR TRUE CACHE BOOL "") + + # OpenGL + INCLUDE(FindOpenGL) +@@ -15,13 +22,15 @@ + ENDIF(OPENGL_FOUND) + + # GLUT +-INCLUDE(${NV_CMAKE_DIR}/FindGLUT.cmake) +-#INCLUDE(FindGLUT) +-IF(GLUT_FOUND) +- MESSAGE(STATUS "Looking for GLUT - found") +-ELSE(GLUT_FOUND) +- MESSAGE(STATUS "Looking for GLUT - not found") +-ENDIF(GLUT_FOUND) ++IF(GLUT) ++ INCLUDE(${NV_CMAKE_DIR}/FindGLUT.cmake) ++ #INCLUDE(FindGLUT) ++ IF(GLUT_FOUND) ++ MESSAGE(STATUS "Looking for GLUT - found") ++ ELSE(GLUT_FOUND) ++ MESSAGE(STATUS "Looking for GLUT - not found") ++ ENDIF(GLUT_FOUND) ++ENDIF(GLUT) + + # DirectX + INCLUDE(${NV_CMAKE_DIR}/FindDirectX.cmake) +@@ -32,29 +41,35 @@ + ENDIF(DX10_FOUND) + + # GLEW +-INCLUDE(${NV_CMAKE_DIR}/FindGLEW.cmake) +-IF(GLEW_FOUND) +- MESSAGE(STATUS "Looking for GLEW - found") +-ELSE(GLEW_FOUND) +- MESSAGE(STATUS "Looking for GLEW - not found") +-ENDIF(GLEW_FOUND) ++IF(GLEW) ++ INCLUDE(${NV_CMAKE_DIR}/FindGLEW.cmake) ++ IF(GLEW_FOUND) ++ MESSAGE(STATUS "Looking for GLEW - found") ++ ELSE(GLEW_FOUND) ++ MESSAGE(STATUS "Looking for GLEW - not found") ++ ENDIF(GLEW_FOUND) ++ENDIF(GLEW) + + # Cg +-INCLUDE(${NV_CMAKE_DIR}/FindCg.cmake) +-IF(CG_FOUND) +- MESSAGE(STATUS "Looking for Cg - found") +-ELSE(CG_FOUND) +- MESSAGE(STATUS "Looking for Cg - not found") +-ENDIF(CG_FOUND) ++IF(CG) ++ INCLUDE(${NV_CMAKE_DIR}/FindCg.cmake) ++ IF(CG_FOUND) ++ MESSAGE(STATUS "Looking for Cg - found") ++ ELSE(CG_FOUND) ++ MESSAGE(STATUS "Looking for Cg - not found") ++ ENDIF(CG_FOUND) ++ENDIF(CG) + + # CUDA +-INCLUDE(${NV_CMAKE_DIR}/FindCUDA.cmake) +-IF(CUDA_FOUND) +- SET(HAVE_CUDA ${CUDA_FOUND} CACHE BOOL "Set to TRUE if CUDA is found, FALSE otherwise") +- MESSAGE(STATUS "Looking for CUDA - found") +-ELSE(CUDA_FOUND) +- MESSAGE(STATUS "Looking for CUDA - not found") +-ENDIF(CUDA_FOUND) ++IF(CUDA) ++ INCLUDE(${NV_CMAKE_DIR}/FindCUDA.cmake) ++ IF(CUDA_FOUND) ++ SET(HAVE_CUDA ${CUDA_FOUND} CACHE BOOL "Set to TRUE if CUDA is found, FALSE otherwise") ++ MESSAGE(STATUS "Looking for CUDA - found") ++ ELSE(CUDA_FOUND) ++ MESSAGE(STATUS "Looking for CUDA - not found") ++ ENDIF(CUDA_FOUND) ++ENDIF(CUDA) + + # Maya + INCLUDE(${NV_CMAKE_DIR}/FindMaya.cmake) +@@ -93,13 +108,15 @@ + ENDIF(TIFF_FOUND) + + # OpenEXR +-INCLUDE(${NV_CMAKE_DIR}/FindOpenEXR.cmake) +-IF(OPENEXR_FOUND) +- SET(HAVE_OPENEXR ${OPENEXR_FOUND} CACHE BOOL "Set to TRUE if OpenEXR is found, FALSE otherwise") +- MESSAGE(STATUS "Looking for OpenEXR - found") +-ELSE(OPENEXR_FOUND) +- MESSAGE(STATUS "Looking for OpenEXR - not found") +-ENDIF(OPENEXR_FOUND) ++IF(OPENEXR) ++ INCLUDE(${NV_CMAKE_DIR}/FindOpenEXR.cmake) ++ IF(OPENEXR_FOUND) ++ SET(HAVE_OPENEXR ${OPENEXR_FOUND} CACHE BOOL "Set to TRUE if OpenEXR is found, FALSE otherwise") ++ MESSAGE(STATUS "Looking for OpenEXR - found") ++ ELSE(OPENEXR_FOUND) ++ MESSAGE(STATUS "Looking for OpenEXR - not found") ++ ENDIF(OPENEXR_FOUND) ++ENDIF(OPENEXR) + + # Qt + FIND_PACKAGE(Qt4) diff --git a/dev-util/nvidia-texture-tools/files/valgrind.patch b/dev-util/nvidia-texture-tools/files/valgrind.patch new file mode 100644 index 000000000..808e59dd9 --- /dev/null +++ b/dev-util/nvidia-texture-tools/files/valgrind.patch @@ -0,0 +1,857 @@ +Subject: Remove malloc overrides +Last-Update: 2012-03-31 +Origin, upstream, http://code.google.com/p/nvidia-texture-tools/source/detail?r=1172 +Bug: http://code.google.com/p/nvidia-texture-tools/issues/detail?id=138 + +diff --git a/src/nvcore/Containers.h b/src/nvcore/Containers.h +index f0b63d4..3d1d8ee 100644 +--- a/src/nvcore/Containers.h ++++ b/src/nvcore/Containers.h +@@ -16,9 +16,9 @@ Do not use memmove in insert & remove, use copy ctors instead. + + + // nvcore +-#include +-#include +-#include ++#include "nvcore.h" ++#include "Memory.h" ++#include "Debug.h" + + #include // memmove + #include // for placement new +@@ -589,15 +589,15 @@ namespace nv + // free the buffer. + if( m_buffer_size == 0 ) { + if( m_buffer ) { +- mem::free( m_buffer ); ++ free( m_buffer ); + m_buffer = NULL; + } + } + + // realloc the buffer + else { +- if( m_buffer ) m_buffer = (T *) mem::realloc( m_buffer, sizeof(T) * m_buffer_size ); +- else m_buffer = (T *) mem::malloc( sizeof(T) * m_buffer_size ); ++ if( m_buffer ) m_buffer = (T *) realloc(m_buffer, sizeof(T) * m_buffer_size); ++ else m_buffer = (T *) ::malloc(sizeof(T) * m_buffer_size); + } + } + +@@ -778,7 +778,7 @@ namespace nv + e->clear(); + } + } +- mem::free(table); ++ free(table); + table = NULL; + entry_count = 0; + size_mask = -1; +@@ -1001,7 +1001,7 @@ namespace nv + new_size = nextPowerOfTwo(new_size); + + HashMap 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); + + new_hash.entry_count = 0; +@@ -1026,7 +1026,7 @@ namespace nv + } + + // Delete our old data buffer. +- mem::free(table); ++ free(table); + } + + // Steal new_hash's data. +diff --git a/src/nvcore/Memory.cpp b/src/nvcore/Memory.cpp +index 7ece018..d470580 100644 +--- a/src/nvcore/Memory.cpp ++++ b/src/nvcore/Memory.cpp +@@ -1,36 +1,118 @@ ++// This code is in the public domain -- Ignacio Castaño + + #include "Memory.h" + #include "Debug.h" + +-//#if HAVE_MALLOC_H +-//#include +-//#endif +- + #include + ++#define USE_EFENCE 0 ++ ++#if USE_EFENCE ++extern "C" void *EF_malloc(size_t size); ++extern "C" void *EF_realloc(void * oldBuffer, size_t newSize); ++extern "C" void EF_free(void * address); ++#endif + + using namespace nv; + +-void * nv::mem::malloc(size_t size) ++#if NV_OVERRIDE_ALLOC ++ ++void * malloc(size_t size) ++{ ++#if USE_EFENCE ++ return EF_malloc(size); ++#else ++ return ::malloc(size); ++#endif ++} ++ ++void * debug_malloc(size_t size, const char * file, int line) ++{ ++ NV_UNUSED(file); ++ NV_UNUSED(line); ++#if USE_EFENCE ++ return EF_malloc(size); ++#else ++ return ::malloc(size); ++#endif ++} ++ ++void free(void * ptr) + { +- return ::malloc(size); ++#if USE_EFENCE ++ return EF_free(const_cast(ptr)); ++#else ++ ::free(const_cast(ptr)); ++#endif + } + +-void * nv::mem::malloc(size_t size, const char * file, int line) ++void * realloc(void * ptr, size_t size) + { +- NV_UNUSED(file); +- NV_UNUSED(line); +- return ::malloc(size); ++ nvDebugCheck(ptr != NULL || size != 0); // undefined realloc behavior. ++#if USE_EFENCE ++ return EF_realloc(ptr, size); ++#else ++ return ::realloc(ptr, size); ++#endif + } + +-void nv::mem::free(const void * ptr) ++/* No need to override this unless we want line info. ++void * operator new (size_t size) throw() + { +- ::free(const_cast(ptr)); ++ return malloc(size); + } + +-void * nv::mem::realloc(void * ptr, size_t size) ++void operator delete (void *p) throw() + { +- nvDebugCheck(ptr != NULL || size != 0); // undefined realloc behavior. +- return ::realloc(ptr, size); ++ 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 +diff --git a/src/nvcore/Memory.h b/src/nvcore/Memory.h +index d699926..897388b 100644 +--- a/src/nvcore/Memory.h ++++ b/src/nvcore/Memory.h +@@ -1,186 +1,52 @@ +-// This code is in the public domain -- castanyo@yahoo.es ++// This code is in the public domain -- Ignacio Castaño + ++#pragma once + #ifndef NV_CORE_MEMORY_H + #define NV_CORE_MEMORY_H + +-#include ++#include "nvcore.h" + + #include // malloc(), realloc() and free() +-#include // size_t ++#include // size_t + + #include // new and delete + +-// Custom memory allocator +-namespace nv +-{ +- namespace mem +- { +- NVCORE_API void * malloc(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 ++#define NV_OVERRIDE_ALLOC 0 + +-inline void * operator new (size_t size) throw() +-{ +- return nv::mem::malloc(size); +-} +- +-inline void operator delete (void *p) throw() +-{ +- nv::mem::free(p); +-} ++#if NV_OVERRIDE_ALLOC + +-inline void * operator new [] (size_t size) throw() +-{ +- return nv::mem::malloc(size); +-} +- +-inline void operator delete [] (void * p) throw() +-{ +- nv::mem::free(p); ++// Custom memory allocator ++extern "C" { ++ NVCORE_API void * malloc(size_t size); ++ NVCORE_API void * debug_malloc(size_t size, const char * file, int line); ++ NVCORE_API void free(void * ptr); ++ NVCORE_API void * realloc(void * ptr, size_t size); + } + + /* + #ifdef _DEBUG + #define new new(__FILE__, __LINE__) +-#define malloc(i) malloc(i, __FILE__, __LINE__) ++#define malloc(i) debug_malloc(i, __FILE__, __LINE__) + #endif + */ + +-#if 0 +-/* +- File: main.cpp +- +- Version: 1.0 +- +- Abstract: Overrides the C++ 'operator new' and 'operator delete'. +- +- Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple Computer, Inc. +- ("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 +-#include +-#include +-#include +-#include +- +-/* 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. +- Most applications will want to override at least these four versions of new/delete if they override any of them. +- +- 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. ++#endif + +- 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. ++namespace nv { + +- 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++; +-} ++ // C++ helpers. ++ template T * malloc(size_t count) { ++ return (T *)::malloc(sizeof(T) * count); ++ } + +-/* 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); +-} ++ template T * realloc(T * ptr, size_t count) { ++ return (T *)::realloc(ptr, sizeof(T) * count); ++ } + +-/* 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 () { } ++ template void free(const T * ptr) { ++ ::free((void *)ptr); ++ } + +-/* 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 ++} // nv namespace + + #endif // NV_CORE_MEMORY_H +diff --git a/src/nvcore/StrLib.cpp b/src/nvcore/StrLib.cpp +index 34cf992..34518d9 100644 +--- a/src/nvcore/StrLib.cpp ++++ b/src/nvcore/StrLib.cpp +@@ -21,17 +21,17 @@ namespace + { + static char * strAlloc(uint size) + { +- return static_cast(mem::malloc(size)); ++ return static_cast(::malloc(size)); + } + + static char * strReAlloc(char * str, uint size) + { +- return static_cast(mem::realloc(str, size)); ++ return static_cast(::realloc(str, size)); + } + + static void strFree(const char * str) + { +- return mem::free(const_cast(str)); ++ return ::free(const_cast(str)); + } + + /*static char * strDup( const char * str ) +diff --git a/src/nvcore/StrLib.h b/src/nvcore/StrLib.h +index 8012271..4164cf5 100644 +--- a/src/nvcore/StrLib.h ++++ b/src/nvcore/StrLib.h +@@ -294,7 +294,7 @@ namespace nv + const uint16 count = getRefCount(); + setRefCount(count - 1); + if (count - 1 == 0) { +- mem::free(data - 2); ++ free(data - 2); + data = NULL; + } + } +@@ -323,7 +323,7 @@ namespace nv + + void allocString(const char * str, int len) + { +- const char * ptr = static_cast(mem::malloc(2 + len + 1)); ++ const char * ptr = static_cast(::malloc(2 + len + 1)); + + setData( ptr ); + setRefCount( 0 ); +diff --git a/src/nvimage/FloatImage.cpp b/src/nvimage/FloatImage.cpp +index 90818ca..6e82ade 100644 +--- a/src/nvimage/FloatImage.cpp ++++ b/src/nvimage/FloatImage.cpp +@@ -148,13 +148,13 @@ void FloatImage::allocate(uint c, uint w, uint h) + m_height = h; + m_componentNum = c; + m_count = w * h * c; +- m_mem = reinterpret_cast(nv::mem::malloc(m_count * sizeof(float))); ++ m_mem = reinterpret_cast(::malloc(m_count * sizeof(float))); + } + + /// Free the image, but don't clear the members. + void FloatImage::free() + { +- nv::mem::free( reinterpret_cast(m_mem) ); ++ ::free( reinterpret_cast(m_mem) ); + m_mem = NULL; + } + +diff --git a/src/nvimage/Image.cpp b/src/nvimage/Image.cpp +index 2307d5c..53c0b5f 100644 +--- a/src/nvimage/Image.cpp ++++ b/src/nvimage/Image.cpp +@@ -78,7 +78,7 @@ void Image::unwrap() + + void Image::free() + { +- nv::mem::free(m_data); ++ ::free(m_data); + m_data = NULL; + } + +diff --git a/src/nvimage/ImageIO.cpp b/src/nvimage/ImageIO.cpp +index 0b24600..70949ff 100644 +--- a/src/nvimage/ImageIO.cpp ++++ b/src/nvimage/ImageIO.cpp +@@ -954,7 +954,7 @@ FloatImage * nv::ImageIO::loadFloatTIFF(const char * fileName, Stream & s) + fimage->allocate(spp, width, height); + + int linesize = TIFFScanlineSize(tif); +- tdata_t buf = (::uint8 *)nv::mem::malloc(linesize); ++ tdata_t buf = (::uint8 *)::malloc(linesize); + + for (uint y = 0; y < height; y++) + { +@@ -991,7 +991,7 @@ FloatImage * nv::ImageIO::loadFloatTIFF(const char * fileName, Stream & s) + } + } + +- nv::mem::free(buf); ++ ::free(buf); + + TIFFClose(tif); + +diff --git a/src/nvtt/CompressRGB.cpp b/src/nvtt/CompressRGB.cpp +index 35239c4..7a6564d 100644 +--- a/src/nvtt/CompressRGB.cpp ++++ b/src/nvtt/CompressRGB.cpp +@@ -1,140 +1,140 @@ +-// Copyright NVIDIA Corporation 2007 -- Ignacio Castano +-// +-// 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 +- +-#include +-#include +-#include +- +-#include "CompressRGB.h" +-#include "CompressionOptions.h" +-#include "OutputOptions.h" +- +-using namespace nv; +-using namespace nvtt; +- +-namespace +-{ +- +- inline uint computePitch(uint w, uint bitsize) +- { +- uint p = w * ((bitsize + 7) / 8); +- +- // Align to 32 bits. +- return ((p + 3) / 4) * 4; +- } +- +- inline void convert_to_a8r8g8b8(const void * src, void * dst, uint w) +- { +- memcpy(dst, src, 4 * w); +- } +- +- inline void convert_to_x8r8g8b8(const void * src, void * dst, uint w) +- { +- memcpy(dst, src, 4 * w); +- } +- +-} // namespace +- +- +-// Pixel format converter. +-void nv::compressRGB(const Image * image, const OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions) +-{ +- nvCheck(image != NULL); +- +- const uint w = image->width(); +- const uint h = image->height(); +- +- const uint bitCount = compressionOptions.bitcount; +- nvCheck(bitCount == 8 || bitCount == 16 || bitCount == 24 || bitCount == 32); +- +- const uint byteCount = bitCount / 8; +- +- const uint rmask = compressionOptions.rmask; +- uint rshift, rsize; +- PixelFormat::maskShiftAndSize(rmask, &rshift, &rsize); +- +- const uint gmask = compressionOptions.gmask; +- uint gshift, gsize; +- PixelFormat::maskShiftAndSize(gmask, &gshift, &gsize); +- +- const uint bmask = compressionOptions.bmask; +- uint bshift, bsize; +- PixelFormat::maskShiftAndSize(bmask, &bshift, &bsize); +- +- const uint amask = compressionOptions.amask; +- uint ashift, asize; +- PixelFormat::maskShiftAndSize(amask, &ashift, &asize); +- +- // Determine pitch. +- uint pitch = computePitch(w, compressionOptions.bitcount); +- +- uint8 * dst = (uint8 *)mem::malloc(pitch + 4); +- +- for (uint y = 0; y < h; y++) +- { +- const Color32 * src = image->scanline(y); +- +- if (bitCount == 32 && rmask == 0xFF0000 && gmask == 0xFF00 && bmask == 0xFF && amask == 0xFF000000) +- { +- convert_to_a8r8g8b8(src, dst, w); +- } +- else if (bitCount == 32 && rmask == 0xFF0000 && gmask == 0xFF00 && bmask == 0xFF && amask == 0) +- { +- convert_to_x8r8g8b8(src, dst, w); +- } +- else +- { +- // Generic pixel format conversion. +- for (uint x = 0; x < w; x++) +- { +- uint c = 0; +- c |= PixelFormat::convert(src[x].r, 8, rsize) << rshift; +- c |= PixelFormat::convert(src[x].g, 8, gsize) << gshift; +- c |= PixelFormat::convert(src[x].b, 8, bsize) << bshift; +- c |= PixelFormat::convert(src[x].a, 8, asize) << ashift; +- +- // Output one byte at a time. +- for (uint i = 0; i < byteCount; i++) +- { +- *(dst + x * byteCount + i) = (c >> (i * 8)) & 0xFF; +- } +- } +- +- // Zero padding. +- for (uint x = w * byteCount; x < pitch; x++) +- { +- *(dst + x) = 0; +- } +- } +- +- if (outputOptions.outputHandler != NULL) +- { +- outputOptions.outputHandler->writeData(dst, pitch); +- } +- } +- +- mem::free(dst); +-} +- ++// Copyright NVIDIA Corporation 2007 -- Ignacio Castano ++// ++// 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 ++ ++#include ++#include ++#include ++ ++#include "CompressRGB.h" ++#include "CompressionOptions.h" ++#include "OutputOptions.h" ++ ++using namespace nv; ++using namespace nvtt; ++ ++namespace ++{ ++ ++ inline uint computePitch(uint w, uint bitsize) ++ { ++ uint p = w * ((bitsize + 7) / 8); ++ ++ // Align to 32 bits. ++ return ((p + 3) / 4) * 4; ++ } ++ ++ inline void convert_to_a8r8g8b8(const void * src, void * dst, uint w) ++ { ++ memcpy(dst, src, 4 * w); ++ } ++ ++ inline void convert_to_x8r8g8b8(const void * src, void * dst, uint w) ++ { ++ memcpy(dst, src, 4 * w); ++ } ++ ++} // namespace ++ ++ ++// Pixel format converter. ++void nv::compressRGB(const Image * image, const OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions) ++{ ++ nvCheck(image != NULL); ++ ++ const uint w = image->width(); ++ const uint h = image->height(); ++ ++ const uint bitCount = compressionOptions.bitcount; ++ nvCheck(bitCount == 8 || bitCount == 16 || bitCount == 24 || bitCount == 32); ++ ++ const uint byteCount = bitCount / 8; ++ ++ const uint rmask = compressionOptions.rmask; ++ uint rshift, rsize; ++ PixelFormat::maskShiftAndSize(rmask, &rshift, &rsize); ++ ++ const uint gmask = compressionOptions.gmask; ++ uint gshift, gsize; ++ PixelFormat::maskShiftAndSize(gmask, &gshift, &gsize); ++ ++ const uint bmask = compressionOptions.bmask; ++ uint bshift, bsize; ++ PixelFormat::maskShiftAndSize(bmask, &bshift, &bsize); ++ ++ const uint amask = compressionOptions.amask; ++ uint ashift, asize; ++ PixelFormat::maskShiftAndSize(amask, &ashift, &asize); ++ ++ // Determine pitch. ++ uint pitch = computePitch(w, compressionOptions.bitcount); ++ ++ uint8 * dst = (uint8 *)::malloc(pitch + 4); ++ ++ for (uint y = 0; y < h; y++) ++ { ++ const Color32 * src = image->scanline(y); ++ ++ if (bitCount == 32 && rmask == 0xFF0000 && gmask == 0xFF00 && bmask == 0xFF && amask == 0xFF000000) ++ { ++ convert_to_a8r8g8b8(src, dst, w); ++ } ++ else if (bitCount == 32 && rmask == 0xFF0000 && gmask == 0xFF00 && bmask == 0xFF && amask == 0) ++ { ++ convert_to_x8r8g8b8(src, dst, w); ++ } ++ else ++ { ++ // Generic pixel format conversion. ++ for (uint x = 0; x < w; x++) ++ { ++ uint c = 0; ++ c |= PixelFormat::convert(src[x].r, 8, rsize) << rshift; ++ c |= PixelFormat::convert(src[x].g, 8, gsize) << gshift; ++ c |= PixelFormat::convert(src[x].b, 8, bsize) << bshift; ++ c |= PixelFormat::convert(src[x].a, 8, asize) << ashift; ++ ++ // Output one byte at a time. ++ for (uint i = 0; i < byteCount; i++) ++ { ++ *(dst + x * byteCount + i) = (c >> (i * 8)) & 0xFF; ++ } ++ } ++ ++ // Zero padding. ++ for (uint x = w * byteCount; x < pitch; x++) ++ { ++ *(dst + x) = 0; ++ } ++ } ++ ++ if (outputOptions.outputHandler != NULL) ++ { ++ outputOptions.outputHandler->writeData(dst, pitch); ++ } ++ } ++ ++ ::free(dst); ++} ++ +diff --git a/src/nvtt/cuda/CudaCompressDXT.cpp b/src/nvtt/cuda/CudaCompressDXT.cpp +index c59bedd..6b45ceb 100644 +--- a/src/nvtt/cuda/CudaCompressDXT.cpp ++++ b/src/nvtt/cuda/CudaCompressDXT.cpp +@@ -137,7 +137,7 @@ void CudaCompressor::compressDXT1(const CompressionOptions::Private & compressio + const uint h = (m_image->height() + 3) / 4; + + uint imageSize = w * h * 16 * sizeof(Color32); +- uint * blockLinearImage = (uint *) malloc(imageSize); ++ uint * blockLinearImage = (uint *) ::malloc(imageSize); + convertToBlockLinear(m_image, blockLinearImage); // @@ Do this in parallel with the GPU, or in the GPU! + + const uint blockNum = w * h; +@@ -207,14 +207,14 @@ void CudaCompressor::compressDXT3(const CompressionOptions::Private & compressio + const uint h = (m_image->height() + 3) / 4; + + uint imageSize = w * h * 16 * sizeof(Color32); +- uint * blockLinearImage = (uint *) malloc(imageSize); ++ uint * blockLinearImage = (uint *) ::malloc(imageSize); + convertToBlockLinear(m_image, blockLinearImage); + + const uint blockNum = w * h; + const uint compressedSize = blockNum * 8; + + AlphaBlockDXT3 * alphaBlocks = NULL; +- alphaBlocks = (AlphaBlockDXT3 *)malloc(min(compressedSize, MAX_BLOCKS * 8U)); ++ alphaBlocks = (AlphaBlockDXT3 *)::malloc(min(compressedSize, MAX_BLOCKS * 8U)); + + setupCompressKernel(compressionOptions.colorWeight.ptr()); + +@@ -298,14 +298,14 @@ void CudaCompressor::compressDXT5(const CompressionOptions::Private & compressio + const uint h = (m_image->height() + 3) / 4; + + uint imageSize = w * h * 16 * sizeof(Color32); +- uint * blockLinearImage = (uint *) malloc(imageSize); ++ uint * blockLinearImage = (uint *) ::malloc(imageSize); + convertToBlockLinear(m_image, blockLinearImage); + + const uint blockNum = w * h; + const uint compressedSize = blockNum * 8; + + AlphaBlockDXT5 * alphaBlocks = NULL; +- alphaBlocks = (AlphaBlockDXT5 *)malloc(min(compressedSize, MAX_BLOCKS * 8U)); ++ alphaBlocks = (AlphaBlockDXT5 *)::malloc(min(compressedSize, MAX_BLOCKS * 8U)); + + setupCompressKernel(compressionOptions.colorWeight.ptr()); + diff --git a/dev-util/nvidia-texture-tools/metadata.xml b/dev-util/nvidia-texture-tools/metadata.xml new file mode 100644 index 000000000..85d84e8e0 --- /dev/null +++ b/dev-util/nvidia-texture-tools/metadata.xml @@ -0,0 +1,13 @@ + + + + + maintainer-wanted@gentoo.org + + + Use NVIDIA toolkit plugin + Use nvidia cuda toolkit + Enable glew extensions + + + diff --git a/dev-util/nvidia-texture-tools/nvidia-texture-tools-2.0.8.ebuild b/dev-util/nvidia-texture-tools/nvidia-texture-tools-2.0.8.ebuild new file mode 100644 index 000000000..cde4be1b1 --- /dev/null +++ b/dev-util/nvidia-texture-tools/nvidia-texture-tools-2.0.8.ebuild @@ -0,0 +1,62 @@ +# Copyright 1999-2012 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Header: $ + +EAPI=4 + +inherit cmake-utils eutils multilib + +DESCRIPTION="A set of cuda-enabled texture tools and compressors" +HOMEPAGE="http://developer.nvidia.com/object/texture_tools.html" +SRC_URI="http://${PN}.googlecode.com/files/${P}-1.tar.gz" + +LICENSE="MIT" +SLOT="0" +KEYWORDS="~amd64 ~x86" +IUSE="cg cuda glew glut openexr static" + +DEPEND="media-libs/libpng:0 + media-libs/ilmbase + media-libs/tiff + sys-libs/zlib + virtual/jpeg + virtual/opengl + x11-libs/libX11 + cg? ( media-gfx/nvidia-cg-toolkit ) + cuda? ( dev-util/nvidia-cuda-toolkit ) + glew? ( media-libs/glew ) + glut? ( media-libs/freeglut ) + openexr? ( media-libs/openexr ) + " +RDEPEND="${DEPEND}" + +S=${WORKDIR}/${PN} + +src_prepare() { + epatch "${FILESDIR}"/gcc4.4.4-aliasing.patch \ + "${FILESDIR}"/libpng1.5-build.patch \ + "${FILESDIR}"/valgrind.patch \ + "${FILESDIR}"/cuda.patch \ + "${FILESDIR}"/libtiff4.patch \ + "${FILESDIR}"/${P}-cmake.patch +} + +src_configure() { + local mycmakeargs=( + -DLIBDIR=$(get_libdir) + $(cmake-utils_use cg CG) + $(cmake-utils_use cuda CUDA) + $(cmake-utils_use glew GLEW) + $(cmake-utils_use glut GLUT) + $(cmake-utils_use openexr OPENEXR) + $(cmake-utils_use !static NVTT_SHARED) + ) + + cmake-utils_src_configure +} + +src_install() { + cmake-utils_src_install + + dodoc ChangeLog +}