Ignacio Castano 3 years ago
commit e4301b3df7
  1. 33
      .github/workflows/build.yml
  2. 29
      CMakeLists.txt
  3. 2
      LICENSE
  4. 8
      README.md
  5. 3
      buildpkg
  6. 72
      cmake/DetermineProcessor.cmake
  7. 172
      cmake/FindCg.cmake
  8. 38
      cmake/FindDirectX.cmake
  9. 53
      cmake/FindFreeImage.cmake
  10. 50
      cmake/FindGLEW.cmake
  11. 67
      cmake/FindMaya.cmake
  12. 75
      cmake/FindOpenEXR.cmake
  13. 47
      cmake/OptimalOptions.cmake
  14. 2
      doc/release_todo
  15. 2
      extern/CMakeLists.txt
  16. BIN
      extern/atitc/ATI_Compress.chm
  17. 175
      extern/atitc/ATI_Compress.h
  18. BIN
      extern/atitc/VC7/MT DLL Debug/ATI_Compress_MT_DLL_VC7.lib
  19. BIN
      extern/atitc/VC7/MT DLL Release/ATI_Compress_MT_DLL_VC7.lib
  20. BIN
      extern/atitc/VC7/MT Debug/ATI_Compress_MT_VC7.lib
  21. BIN
      extern/atitc/VC7/MT Release/ATI_Compress_MT_VC7.lib
  22. BIN
      extern/atitc/VC8/DLL Debug/Win32/ATI_Compress_1_7.dll
  23. BIN
      extern/atitc/VC8/DLL Debug/Win32/ATI_Compress_1_7_DLL.lib
  24. BIN
      extern/atitc/VC8/DLL Debug/x64/ATI_Compress_1_7.dll
  25. BIN
      extern/atitc/VC8/DLL Debug/x64/ATI_Compress_1_7_DLL.lib
  26. BIN
      extern/atitc/VC8/DLL Release/Win32/ATI_Compress_1_7.dll
  27. BIN
      extern/atitc/VC8/DLL Release/Win32/ATI_Compress_1_7_DLL.lib
  28. BIN
      extern/atitc/VC8/DLL Release/x64/ATI_Compress_1_7.dll
  29. BIN
      extern/atitc/VC8/DLL Release/x64/ATI_Compress_1_7_DLL.lib
  30. BIN
      extern/atitc/VC8/MT DLL Debug/Win32/ATI_Compress_MT_DLL_VC8.lib
  31. BIN
      extern/atitc/VC8/MT DLL Debug/x64/ATI_Compress_MT_DLL_VC8.lib
  32. BIN
      extern/atitc/VC8/MT DLL Release/Win32/ATI_Compress_MT_DLL_VC8.lib
  33. BIN
      extern/atitc/VC8/MT DLL Release/x64/ATI_Compress_MT_DLL_VC8.lib
  34. BIN
      extern/atitc/VC8/MT Debug/Win32/ATI_Compress_MT_VC8.lib
  35. BIN
      extern/atitc/VC8/MT Debug/x64/ATI_Compress_MT_VC8.lib
  36. BIN
      extern/atitc/VC8/MT Release/Win32/ATI_Compress_MT_VC8.lib
  37. BIN
      extern/atitc/VC8/MT Release/x64/ATI_Compress_MT_VC8.lib
  38. 7
      extern/butteraugli/CMakeLists.txt
  39. 1588
      extern/butteraugli/butteraugli.cc
  40. 560
      extern/butteraugli/butteraugli.h
  41. 73
      extern/glew/LICENSE.txt
  42. 18
      extern/glew/README.txt
  43. BIN
      extern/glew/bin/glew32.dll
  44. 13369
      extern/glew/include/GL/glew.h
  45. 1446
      extern/glew/include/GL/glxew.h
  46. 1247
      extern/glew/include/GL/wglew.h
  47. BIN
      extern/glew/lib/glew32.lib
  48. BIN
      extern/glew/lib/glew32s.lib
  49. 1565
      extern/goofy_tc.h
  50. 15
      project/nvtt.code-workspace
  51. 10
      project/nvtt.sublime-project
  52. 115
      src/CMakeLists.txt
  53. 19
      src/nvcore/Debug.cpp
  54. 2
      src/nvimage/DirectDrawSurface.cpp
  55. 122
      src/nvimage/ValveTextureFormat.h
  56. 10
      src/nvmath/nvmath.h
  57. 139
      src/nvtt/BlockCompressor.cpp
  58. 19
      src/nvtt/BlockCompressor.h
  59. 17
      src/nvtt/Context.cpp
  60. 15
      src/nvtt/CubeSurface.cpp
  61. 11
      src/nvtt/nvtt.h
  62. 4
      src/nvtt/tests/bc1enc.cpp

@ -0,0 +1,33 @@
name: build
on: [push, pull_request]
jobs:
vs2017:
runs-on: windows-2019
steps:
- uses: actions/checkout@v2
- uses: microsoft/setup-msbuild@v1.0.0
- name: Build Debug/x64
run: msbuild .\project\vc2017\nvtt.sln /property:Configuration=Debug /property:Platform=x64
- name: Build Debug/Win32
run: msbuild .\project\vc2017\nvtt.sln /property:Configuration=Debug /property:Platform=Win32
- name: Build Release/x64
run: msbuild .\project\vc2017\nvtt.sln /property:Configuration=Release /property:Platform=x64
- name: Build Release/Win32
run: msbuild .\project\vc2017\nvtt.sln /property:Configuration=Release /property:Platform=Win32
unix:
strategy:
matrix:
os: [ubuntu, macos]
name: ${{matrix.os}}
runs-on: ${{matrix.os}}-latest
steps:
- uses: actions/checkout@v2
- name: make
run: |
./configure --debug
make
./configure --release
make

@ -16,23 +16,7 @@ else()
message(FATAL_ERROR "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")
endif()
IF(WIN32)
# gnuwin32 paths:
#SET(GNUWIN32_PATH "${NV_SOURCE_DIR}/extern/gnuwin32")
#SET(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} "${GNUWIN32_PATH}/include")
#SET(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} "${GNUWIN32_PATH}/lib")
# Set GLUT path:
#SET(GLUT_ROOT_DIR "${NV_SOURCE_DIR}/extern/glut")
# Set FreeImage path:
#SET(FREEIMAGE_ROOT_DIR "${NV_SOURCE_DIR}/extern/FreeImage")
ENDIF(WIN32)
INCLUDE(${NV_CMAKE_DIR}/OptimalOptions.cmake)
MESSAGE(STATUS "Setting optimal options")
MESSAGE(STATUS " Processor: ${NV_SYSTEM_PROCESSOR}")
MESSAGE(STATUS " Compiler Flags: ${CMAKE_CXX_FLAGS}")
IF(CMAKE_BUILD_TYPE MATCHES "debug")
SET(CMAKE_DEBUG_POSTFIX "_d" CACHE STRING "Postfix for debug build libraries.")
@ -40,12 +24,6 @@ IF(CMAKE_BUILD_TYPE MATCHES "debug")
ENDIF()
#IF(NVTT_SHARED)
# SET(NVCORE_SHARED TRUE)
# SET(NVMATH_SHARED TRUE)
# SET(NVIMAGE_SHARED TRUE)
#ENDIF(NVTT_SHARED)
ADD_SUBDIRECTORY(extern)
ADD_SUBDIRECTORY(src)
@ -66,10 +44,9 @@ ENDIF(CMAKE_SYSTEM_NAME STREQUAL "Linux")
SET(CPACK_PACKAGE_NAME "nvidia-texture-tools")
SET(CPACK_PACKAGE_VERSION_MAJOR "2")
SET(CPACK_PACKAGE_VERSION_MINOR "1")
SET(CPACK_PACKAGE_VERSION_PATCH "0")
SET(CPACK_PACKAGE_VERSION "2.1.0")
SET(CPACK_PACKAGE_VERSION_PATCH "1")
SET(CPACK_PACKAGE_VERSION "2.1.1")
SET(CPACK_PACKAGE_CONTACT "Ignacio Castaño <castano@gmail.com>")
#SET(CPACK_PACKAGE_VENDOR "NVIDIA Corporation")
SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Texture processing tools with support for Direct3D 10 and 11 formats.")
SET(CPACK_PACKAGE_DESCRIPTION_FILE "${NV_SOURCE_DIR}/README.md")
@ -79,7 +56,7 @@ SET(CPACK_RESOURCE_FILE_LICENSE "${NV_SOURCE_DIR}/LICENSE")
IF(WIN32)
SET(CPACK_NSIS_DISPLAY_NAME "${CPACK_PACKAGE_VENDOR}\\\\NVIDIA Texture Tools 2.1")
SET(CPACK_PACKAGE_INSTALL_DIRECTORY "${CPACK_PACKAGE_VENDOR}\\\\NVIDIA Texture Tools 2.1")
SET(CPACK_PACKAGE_ICON "${NV_SOURCE_DIR}\\\\project\\\\vc8\\\\nvcompress\\\\nvidia.ico")
SET(CPACK_PACKAGE_ICON "${NV_SOURCE_DIR}\\\\project\\\\vc2017\\\\nvcompress\\\\nvidia.ico")
ENDIF(WIN32)
INCLUDE(CPack)

@ -1,6 +1,6 @@
NVIDIA Texture Tools is licensed under the MIT license.
Copyright (c) 2009-2017 Ignacio Castaño
Copyright (c) 2009-2020 Ignacio Castaño
Copyright (c) 2007-2009 NVIDIA Corporation
Permission is hereby granted, free of charge, to any person

@ -11,9 +11,7 @@ conversion, and DXT compression.
### How to build (Windows)
Open `project/vc12/thekla.sln` using Visual Studio.
Solutions for previous versions are also available, but they may not be up to date.
Use the provided Visual Studio 2017 solution `project/vc2017/thekla.sln`.
### How to build (Linux/OSX)
@ -32,13 +30,13 @@ $ sudo make install
To use the NVIDIA Texture Tools in your own applications you just have to
include the following header file:
src/nvtt/nvtt.h
[src/nvtt/nvtt.h](https://github.com/castano/nvidia-texture-tools/blob/master/src/nvtt/nvtt.h)
And include the nvtt library in your projects.
The following file contains a simple example that shows how to use the library:
src/nvtt/tools/compress.cpp
[src/nvtt/tools/compress.cpp](https://github.com/castano/nvidia-texture-tools/blob/master/src/nvtt/tools/compress.cpp)
Detailed documentation of the API can be found at:

@ -4,9 +4,6 @@ tar zcvf nvidia-texture-tools-`cat VERSION`.tar.gz \
--exclude '.*' --exclude debian --exclude '*~' --exclude buildpkg \
--exclude 'build-*' --exclude data --exclude tags --exclude Makefile \
--exclude 'doc' --exclude 'nvidia-texture-tools-*.tar.gz' \
--exclude 'extern/skylight' --exclude 'extern/FreeImage' \
--exclude 'extern/atitc' --exclude 'extern/glew' \
--exclude 'extern/gnuwin32' \
--exclude '*.user' -s ',^,nvidia-texture-tools/,' *
# --exclude '*.user' --transform 's,^,nvidia-texture-tools/,' *
# --exclude '*.user' *

@ -1,72 +0,0 @@
# Assume i586 by default.
SET(NV_SYSTEM_PROCESSOR "i586")
IF(UNIX)
FIND_PROGRAM(CMAKE_UNAME uname /bin /usr/bin /usr/local/bin )
IF(CMAKE_UNAME)
#EXEC_PROGRAM(uname ARGS -p OUTPUT_VARIABLE NV_SYSTEM_PROCESSOR RETURN_VALUE val)
#IF("${val}" GREATER 0 OR NV_SYSTEM_PROCESSOR STREQUAL "unknown")
EXEC_PROGRAM(uname ARGS -m OUTPUT_VARIABLE NV_SYSTEM_PROCESSOR RETURN_VALUE val)
#ENDIF("${val}" GREATER 0 OR NV_SYSTEM_PROCESSOR STREQUAL "unknown")
IF(NV_SYSTEM_PROCESSOR STREQUAL "Power Macintosh")
SET(NV_SYSTEM_PROCESSOR "powerpc")
ENDIF(NV_SYSTEM_PROCESSOR STREQUAL "Power Macintosh")
# processor may have double quote in the name, and that needs to be removed
STRING(REGEX REPLACE "\"" "" NV_SYSTEM_PROCESSOR "${NV_SYSTEM_PROCESSOR}")
STRING(REGEX REPLACE "/" "_" NV_SYSTEM_PROCESSOR "${NV_SYSTEM_PROCESSOR}")
ENDIF(CMAKE_UNAME)
#~ # Get extended processor information from /proc/cpuinfo
#~ IF(EXISTS "/proc/cpuinfo")
#~ FILE(READ /proc/cpuinfo PROC_CPUINFO)
#~ SET(VENDOR_ID_RX "vendor_id[ \t]*:[ \t]*([a-zA-Z]+)\n")
#~ STRING(REGEX MATCH "${VENDOR_ID_RX}" VENDOR_ID "${PROC_CPUINFO}")
#~ STRING(REGEX REPLACE "${VENDOR_ID_RX}" "\\1" VENDOR_ID "${VENDOR_ID}")
#~ SET(CPU_FAMILY_RX "cpu family[ \t]*:[ \t]*([0-9]+)")
#~ STRING(REGEX MATCH "${CPU_FAMILY_RX}" CPU_FAMILY "${PROC_CPUINFO}")
#~ STRING(REGEX REPLACE "${CPU_FAMILY_RX}" "\\1" CPU_FAMILY "${CPU_FAMILY}")
#~ SET(MODEL_RX "model[ \t]*:[ \t]*([0-9]+)")
#~ STRING(REGEX MATCH "${MODEL_RX}" MODEL "${PROC_CPUINFO}")
#~ STRING(REGEX REPLACE "${MODEL_RX}" "\\1" MODEL "${MODEL}")
#~ SET(FLAGS_RX "flags[ \t]*:[ \t]*([a-zA-Z0-9 _]+)\n")
#~ STRING(REGEX MATCH "${FLAGS_RX}" FLAGS "${PROC_CPUINFO}")
#~ STRING(REGEX REPLACE "${FLAGS_RX}" "\\1" FLAGS "${FLAGS}")
#~ # Debug output.
#~ IF(LINUX_CPUINFO)
#~ MESSAGE(STATUS "LinuxCPUInfo.cmake:")
#~ MESSAGE(STATUS "VENDOR_ID : ${VENDOR_ID}")
#~ MESSAGE(STATUS "CPU_FAMILY : ${CPU_FAMILY}")
#~ MESSAGE(STATUS "MODEL : ${MODEL}")
#~ MESSAGE(STATUS "FLAGS : ${FLAGS}")
#~ ENDIF(LINUX_CPUINFO)
#~ ENDIF(EXISTS "/proc/cpuinfo")
#~ # Information on how to decode CPU_FAMILY and MODEL:
#~ # http://balusc.xs4all.nl/srv/har-cpu-int-pm.php
ELSE(UNIX)
IF(WIN32)
# It's not OK to trust $ENV{PROCESSOR_ARCHITECTURE}: its value depends on the type of executable being run,
# so a 32-bit cmake (the default binary distribution) will always say "x86" regardless of the actual target.
IF (CMAKE_SIZEOF_VOID_P EQUAL 8)
SET (NV_SYSTEM_PROCESSOR "x86_64")
ELSE(CMAKE_SIZEOF_VOID_P EQUAL 8)
SET (NV_SYSTEM_PROCESSOR "x86")
ENDIF(CMAKE_SIZEOF_VOID_P EQUAL 8)
ENDIF(WIN32)
ENDIF(UNIX)

@ -1,172 +0,0 @@
#
# Try to find NVIDIA's Cg compiler, runtime libraries, and include path.
# Once done this will define
#
# CG_FOUND =system has NVIDIA Cg and it can be used.
# CG_INCLUDE_DIR = directory where cg.h resides
# CG_LIBRARY = full path to libCg.so (Cg.DLL on win32)
# CG_GL_LIBRARY = full path to libCgGL.so (CgGL.dll on win32)
# CG_COMPILER = full path to cgc (cgc.exe on win32)
#
# On OSX default to using the framework version of Cg.
IF (APPLE)
INCLUDE(${CMAKE_ROOT}/Modules/CMakeFindFrameworks.cmake)
SET(CG_FRAMEWORK_INCLUDES)
CMAKE_FIND_FRAMEWORKS(Cg)
IF (Cg_FRAMEWORKS)
FOREACH(dir ${Cg_FRAMEWORKS})
SET(CG_FRAMEWORK_INCLUDES ${CG_FRAMEWORK_INCLUDES}
${dir}/Headers ${dir}/PrivateHeaders)
ENDFOREACH(dir)
# Find the include dir
FIND_PATH(CG_INCLUDE_DIR cg.h
${CG_FRAMEWORK_INCLUDES}
)
# Since we are using Cg framework, we must link to it.
# Note, we use weak linking, so that it works even when Cg is not available.
SET(CG_LIBRARY "-weak_framework Cg" CACHE STRING "Cg library")
SET(CG_GL_LIBRARY "-weak_framework Cg" CACHE STRING "Cg GL library")
ENDIF (Cg_FRAMEWORKS)
FIND_PROGRAM(CG_COMPILER cgc
/usr/bin
/usr/local/bin
DOC "The Cg compiler"
)
ELSE (APPLE)
IF (WIN32)
# When compiling 64-bit programs, the binaries and libs are in bin.x64 and lib.x64 directories,
# This will have only effect for 64bit versions of cmake, when running the default 32bit version
# both ProgramFiles and ProgramFiles(x86) point to the same place in Win64
SET(PFx86_VARNAME "ProgramFiles(x86)")
SET(PFx86 $ENV{${PFx86_VARNAME}})
# Let's play safe in case we are cross compiling to 64 bit: for cgc it doesn't really matter
FIND_PROGRAM( CG_COMPILER cgc
$ENV{CG_BIN64_PATH}
$ENV{CG_BIN_PATH}
$ENV{PROGRAMFILES}/NVIDIA\ Corporation/Cg/bin
$ENV{PFx86}/NVIDIA\ Corporation/Cg/bin
$ENV{PROGRAMFILES}/Cg
${PROJECT_SOURCE_DIR}/../Cg
DOC "The Cg Compiler"
)
IF (CG_COMPILER)
GET_FILENAME_COMPONENT(CG_COMPILER_DIR ${CG_COMPILER} PATH)
GET_FILENAME_COMPONENT(CG_COMPILER_SUPER_DIR ${CG_COMPILER_DIR} PATH)
ELSE (CG_COMPILER)
SET (CG_COMPILER_DIR .)
SET (CG_COMPILER_SUPER_DIR ..)
ENDIF (CG_COMPILER)
FIND_PATH( CG_INCLUDE_DIR Cg/cg.h
$ENV{CG_INC_PATH}
$ENV{PROGRAMFILES}/NVIDIA\ Corporation/Cg/include
$ENV{PROGRAMFILES}/Cg
${PROJECT_SOURCE_DIR}/../Cg
${CG_COMPILER_SUPER_DIR}/include
${CG_COMPILER_DIR}
DOC "The directory where Cg/cg.h resides"
)
IF (NV_SYSTEM_PROCESSOR STREQUAL "x86_64")
FIND_LIBRARY( CG_LIBRARY
NAMES Cg
PATHS
$ENV{CG_LIB64_PATH}
$ENV{PROGRAMFILES}/NVIDIA\ Corporation/Cg/lib.x64
$ENV{PFx86}/NVIDIA\ Corporation/Cg/lib.x64
$ENV{PROGRAMFILES}/Cg
$ENV{PFx86}/Cg
${PROJECT_SOURCE_DIR}/../Cg
${CG_COMPILER_SUPER_DIR}/lib.x64
${CG_COMPILER_DIR}
DOC "The Cg runtime library (64-bit)"
)
FIND_LIBRARY( CG_GL_LIBRARY
NAMES CgGL
PATHS
$ENV{CG_LIB64_PATH}
$ENV{PROGRAMFILES}/NVIDIA\ Corporation/Cg/lib.x64
$ENV{PFx86}/NVIDIA\ Corporation/Cg/lib.x64
$ENV{PROGRAMFILES}/Cg
$ENV{PFx86}/Cg
${PROJECT_SOURCE_DIR}/../Cg
${CG_COMPILER_SUPER_DIR}/lib.x64
${CG_COMPILER_DIR}
DOC "The Cg GL runtime library (64-bit)"
)
ELSE(NV_SYSTEM_PROCESSOR STREQUAL "x86_64")
FIND_LIBRARY( CG_LIBRARY
NAMES Cg
PATHS
$ENV{CG_LIB_PATH}
$ENV{PROGRAMFILES}/NVIDIA\ Corporation/Cg/lib
$ENV{PROGRAMFILES}/Cg
${PROJECT_SOURCE_DIR}/../Cg
${CG_COMPILER_SUPER_DIR}/lib
${CG_COMPILER_DIR}
DOC "The Cg runtime library"
)
FIND_LIBRARY( CG_GL_LIBRARY
NAMES CgGL
PATHS
$ENV{CG_LIB_PATH}
$ENV{PROGRAMFILES}/NVIDIA\ Corporation/Cg/lib
$ENV{PROGRAMFILES}/Cg
${PROJECT_SOURCE_DIR}/../Cg
${CG_COMPILER_SUPER_DIR}/lib
${CG_COMPILER_DIR}
DOC "The Cg GL runtime library"
)
ENDIF(NV_SYSTEM_PROCESSOR STREQUAL "x86_64")
ELSE (WIN32)
FIND_PROGRAM( CG_COMPILER cgc
/usr/bin
/usr/local/bin
DOC "The Cg Compiler"
)
GET_FILENAME_COMPONENT(CG_COMPILER_DIR "${CG_COMPILER}" PATH)
GET_FILENAME_COMPONENT(CG_COMPILER_SUPER_DIR "${CG_COMPILER_DIR}" PATH)
FIND_PATH( CG_INCLUDE_DIR Cg/cg.h
/usr/include
/usr/local/include
${CG_COMPILER_SUPER_DIR}/include
DOC "The directory where Cg/cg.h resides"
)
FIND_LIBRARY( CG_LIBRARY Cg
PATHS
/usr/lib64
/usr/lib
/usr/local/lib64
/usr/local/lib
${CG_COMPILER_SUPER_DIR}/lib64
${CG_COMPILER_SUPER_DIR}/lib
DOC "The Cg runtime library"
)
SET(CG_LIBRARY ${CG_LIBRARY} -lpthread)
FIND_LIBRARY( CG_GL_LIBRARY CgGL
PATHS
/usr/lib64
/usr/lib
/usr/local/lib64
/usr/local/lib
${CG_COMPILER_SUPER_DIR}/lib64
${CG_COMPILER_SUPER_DIR}/lib
DOC "The Cg runtime library"
)
ENDIF (WIN32)
ENDIF (APPLE)
IF (CG_INCLUDE_DIR)
SET( CG_FOUND 1 CACHE STRING "Set to 1 if CG is found, 0 otherwise")
ELSE (CG_INCLUDE_DIR)
SET( CG_FOUND 0 CACHE STRING "Set to 1 if CG is found, 0 otherwise")
ENDIF (CG_INCLUDE_DIR)
MARK_AS_ADVANCED( CG_FOUND )

@ -1,38 +0,0 @@
IF (WIN32)
FIND_PATH(DX9_INCLUDE_PATH d3d9.h
PATHS
"$ENV{DXSDK_DIR}/Include"
"$ENV{PROGRAMFILES}/Microsoft DirectX SDK/Include"
DOC "The directory where D3D9.h resides")
FIND_PATH(DX10_INCLUDE_PATH D3D10.h
PATHS
"$ENV{DXSDK_DIR}/Include"
"$ENV{PROGRAMFILES}/Microsoft DirectX SDK/Include"
DOC "The directory where D3D10.h resides")
FIND_LIBRARY(D3D10_LIBRARY d3d10.lib
PATHS
"$ENV{DXSDK_DIR}/Lib/x86"
"$ENV{PROGRAMFILES}/Microsoft DirectX SDK/Lib/x86"
DOC "The directory where d3d10.lib resides")
FIND_LIBRARY(D3DX10_LIBRARY d3dx10.lib
PATHS
"$ENV{DXSDK_DIR}/Lib/x86"
"$ENV{PROGRAMFILES}/Microsoft DirectX SDK/Lib/x86"
DOC "The directory where d3dx10.lib resides")
SET(DX10_LIBRARIES ${D3D10_LIBRARY} ${D3DX10_LIBRARY})
ENDIF (WIN32)
IF (DX10_INCLUDE_PATH)
SET( DX10_FOUND 1 CACHE STRING "Set to 1 if CG is found, 0 otherwise")
ELSE (DX10_INCLUDE_PATH)
SET( DX10_FOUND 0 CACHE STRING "Set to 1 if CG is found, 0 otherwise")
ENDIF (DX10_INCLUDE_PATH)
MARK_AS_ADVANCED( DX10_FOUND )

@ -1,53 +0,0 @@
#
# Try to find the FreeImage library and include path.
# Once done this will define
#
# FREEIMAGE_FOUND
# FREEIMAGE_INCLUDE_PATH
# FREEIMAGE_LIBRARY
#
IF (WIN32)
FIND_PATH( FREEIMAGE_INCLUDE_PATH FreeImage.h
${FREEIMAGE_ROOT_DIR}/include
${FREEIMAGE_ROOT_DIR}
DOC "The directory where FreeImage.h resides")
FIND_LIBRARY( FREEIMAGE_LIBRARY
NAMES FreeImage freeimage
PATHS
${FREEIMAGE_ROOT_DIR}/lib
${FREEIMAGE_ROOT_DIR}
DOC "The FreeImage library")
ELSE (WIN32)
FIND_PATH( FREEIMAGE_INCLUDE_PATH FreeImage.h
/usr/include
/usr/local/include
/sw/include
/opt/local/include
DOC "The directory where FreeImage.h resides")
FIND_LIBRARY( FREEIMAGE_LIBRARY
NAMES FreeImage freeimage
PATHS
/usr/lib64
/usr/lib
/usr/local/lib64
/usr/local/lib
/sw/lib
/opt/local/lib
DOC "The FreeImage library")
ENDIF (WIN32)
SET(FREEIMAGE_LIBRARIES ${FREEIMAGE_LIBRARY})
IF (FREEIMAGE_INCLUDE_PATH AND FREEIMAGE_LIBRARY)
SET( FREEIMAGE_FOUND TRUE CACHE BOOL "Set to TRUE if FreeImage is found, FALSE otherwise")
ELSE (FREEIMAGE_INCLUDE_PATH AND FREEIMAGE_LIBRARY)
SET( FREEIMAGE_FOUND FALSE CACHE BOOL "Set to TRUE if FreeImage is found, FALSE otherwise")
ENDIF (FREEIMAGE_INCLUDE_PATH AND FREEIMAGE_LIBRARY)
MARK_AS_ADVANCED(
FREEIMAGE_FOUND
FREEIMAGE_LIBRARY
FREEIMAGE_LIBRARIES
FREEIMAGE_INCLUDE_PATH)

@ -1,50 +0,0 @@
#
# Try to find GLEW library and include path.
# Once done this will define
#
# GLEW_FOUND
# GLEW_INCLUDE_PATH
# GLEW_LIBRARY
#
IF (WIN32)
FIND_PATH( GLEW_INCLUDE_PATH GL/glew.h
$ENV{PROGRAMFILES}/GLEW/include
${GLEW_ROOT_DIR}/include
DOC "The directory where GL/glew.h resides")
FIND_LIBRARY( GLEW_LIBRARY
NAMES glew GLEW glew32 glew32s
PATHS
$ENV{PROGRAMFILES}/GLEW/lib
${PROJECT_SOURCE_DIR}/src/nvgl/glew/bin
${PROJECT_SOURCE_DIR}/src/nvgl/glew/lib
DOC "The GLEW library")
ELSE (WIN32)
FIND_PATH( GLEW_INCLUDE_PATH GL/glew.h
/usr/include
/usr/local/include
/sw/include
/opt/local/include
${GLEW_ROOT_DIR}/include
DOC "The directory where GL/glew.h resides")
# Prefer the static library.
FIND_LIBRARY( GLEW_LIBRARY
NAMES libGLEW.a GLEW
PATHS
/usr/lib64
/usr/lib
/usr/local/lib64
/usr/local/lib
/sw/lib
/opt/local/lib
${GLEW_ROOT_DIR}/lib
DOC "The GLEW library")
ENDIF (WIN32)
SET(GLEW_FOUND "NO")
IF (GLEW_INCLUDE_PATH AND GLEW_LIBRARY)
SET(GLEW_LIBRARIES ${GLEW_LIBRARY})
SET(GLEW_FOUND "YES")
ENDIF (GLEW_INCLUDE_PATH AND GLEW_LIBRARY)

@ -1,67 +0,0 @@
IF (WIN32)
# Maya plugins can only be compiled with msvc
IF (MSVC)
FIND_PATH(MAYA_INCLUDE_PATH maya/MTypes.h
PATHS
"$ENV{PROGRAMFILES}/Autodesk/Maya8.5/include"
"$ENV{MAYA_LOCATION}/include"
DOC "The directory where MTypes.h resides")
# Find maya version!
FIND_LIBRARY(MAYA_FOUNDATION_LIBRARY Foundation
PATHS
"$ENV{PROGRAMFILES}/Autodesk/Maya8.5/lib"
"$ENV{MAYA_LOCATION}/lib"
DOC "The directory where Foundation.lib resides")
FIND_LIBRARY(MAYA_OPENMAYA_LIBRARY OpenMaya
PATHS
"$ENV{PROGRAMFILES}/Autodesk/Maya8.5/lib"
"$ENV{MAYA_LOCATION}/lib"
DOC "The directory where OpenMaya.lib resides")
FIND_LIBRARY(MAYA_OPENMAYAANIM_LIBRARY OpenMayaAnim
PATHS
"$ENV{PROGRAMFILES}/Autodesk/Maya8.5/lib"
"$ENV{MAYA_LOCATION}/lib"
DOC "The directory where OpenMayaAnim.lib resides")
SET(MAYA_LIBRARIES
${MAYA_FOUNDATION_LIBRARY}
${MAYA_OPENMAYA_LIBRARY}
${MAYA_OPENMAYAANIM_LIBRARY})
SET(MAYA_EXTENSION ".mll")
ENDIF (MSVC)
ELSE (WIN32)
# On linux, check gcc version.
# OSX and Linux
FIND_PATH(MAYA_INCLUDE_PATH maya/MTypes.h
PATHS
/usr/autodesk/maya/include
$ENV{MAYA_LOCATION}/include
DOC "The directory where MTypes.h resides")
# TODO
ENDIF (WIN32)
IF (MAYA_INCLUDE_PATH)
SET( MAYA_FOUND 1 CACHE STRING "Set to 1 if Maya is found, 0 otherwise")
ELSE (MAYA_INCLUDE_PATH)
SET( MAYA_FOUND 0 CACHE STRING "Set to 1 if Maya is found, 0 otherwise")
ENDIF (MAYA_INCLUDE_PATH)
MARK_AS_ADVANCED( MAYA_FOUND )

@ -1,75 +0,0 @@
#
# Try to find OpenEXR's libraries, and include path.
# Once done this will define:
#
# OPENEXR_FOUND = OpenEXR found.
# OPENEXR_INCLUDE_PATHS = OpenEXR include directories.
# OPENEXR_LIBRARIES = libraries that are needed to use OpenEXR.
#
INCLUDE(FindZLIB)
IF(ZLIB_FOUND)
SET(LIBRARY_PATHS
/usr/lib
/usr/local/lib
/sw/lib
/opt/local/lib
$ENV{PROGRAM_FILES}/OpenEXR/lib/static)
FIND_PATH(OPENEXR_INCLUDE_PATH ImfRgbaFile.h
PATH_SUFFIXES OpenEXR
/usr/include
/usr/local/include
/sw/include
/opt/local/include)
FIND_LIBRARY(OPENEXR_HALF_LIBRARY
NAMES Half
PATHS ${LIBRARY_PATHS})
FIND_LIBRARY(OPENEXR_IEX_LIBRARY
NAMES Iex
PATHS ${LIBRARY_PATHS})
FIND_LIBRARY(OPENEXR_IMATH_LIBRARY
NAMES Imath
PATHS ${LIBRARY_PATHS})
FIND_LIBRARY(OPENEXR_ILMIMF_LIBRARY
NAMES IlmImf
PATHS ${LIBRARY_PATHS})
FIND_LIBRARY(OPENEXR_ILMTHREAD_LIBRARY
NAMES IlmThread
PATHS ${LIBRARY_PATHS})
ENDIF(ZLIB_FOUND)
#MESSAGE(STATUS ${OPENEXR_IMATH_LIBRARY} ${OPENEXR_ILMIMF_LIBRARY} ${OPENEXR_IEX_LIBRARY} ${OPENEXR_HALF_LIBRARY} ${OPENEXR_ILMTHREAD_LIBRARY} ${ZLIB_LIBRARY})
IF (OPENEXR_INCLUDE_PATH AND OPENEXR_IMATH_LIBRARY AND OPENEXR_ILMIMF_LIBRARY AND OPENEXR_IEX_LIBRARY AND OPENEXR_HALF_LIBRARY)
SET(OPENEXR_FOUND TRUE)
SET(OPENEXR_INCLUDE_PATHS ${OPENEXR_INCLUDE_PATH} CACHE STRING "The include paths needed to use OpenEXR")
SET(OPENEXR_LIBRARIES ${OPENEXR_IMATH_LIBRARY} ${OPENEXR_ILMIMF_LIBRARY} ${OPENEXR_IEX_LIBRARY} ${OPENEXR_HALF_LIBRARY} ${OPENEXR_ILMTHREAD_LIBRARY} ${ZLIB_LIBRARY} CACHE STRING "The libraries needed to use OpenEXR")
ENDIF (OPENEXR_INCLUDE_PATH AND OPENEXR_IMATH_LIBRARY AND OPENEXR_ILMIMF_LIBRARY AND OPENEXR_IEX_LIBRARY AND OPENEXR_HALF_LIBRARY)
IF(OPENEXR_FOUND)
IF(NOT OPENEXR_FIND_QUIETLY)
MESSAGE(STATUS "Found OpenEXR: ${OPENEXR_ILMIMF_LIBRARY}")
ENDIF(NOT OPENEXR_FIND_QUIETLY)
ELSE(OPENEXR_FOUND)
IF(OPENEXR_FIND_REQUIRED)
MESSAGE(FATAL_ERROR "Could not find OpenEXR library")
ENDIF(OPENEXR_FIND_REQUIRED)
ENDIF(OPENEXR_FOUND)
MARK_AS_ADVANCED(
OPENEXR_INCLUDE_PATHS
OPENEXR_LIBRARIES
OPENEXR_ILMIMF_LIBRARY
OPENEXR_IMATH_LIBRARY
OPENEXR_IEX_LIBRARY
OPENEXR_HALF_LIBRARY)

@ -1,56 +1,11 @@
INCLUDE(${NV_CMAKE_DIR}/DetermineProcessor.cmake)
# Set optimal options for gcc:
IF(CMAKE_COMPILER_IS_GNUCXX)
IF(NV_SYSTEM_PROCESSOR STREQUAL "i586")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=i586")
ENDIF(NV_SYSTEM_PROCESSOR STREQUAL "i586")
IF(NV_SYSTEM_PROCESSOR STREQUAL "i686")
#SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=i686")
#SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpmath=sse -mtune=i686 -msse3")
#SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=pentium4")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=prescott")
ENDIF(NV_SYSTEM_PROCESSOR STREQUAL "i686")
IF(NV_SYSTEM_PROCESSOR STREQUAL "x86_64")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=athlon64")
#SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=athlon64 -msse3")
ENDIF(NV_SYSTEM_PROCESSOR STREQUAL "x86_64")
IF(NV_SYSTEM_PROCESSOR STREQUAL "powerpc")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcpu=powerpc -faltivec -maltivec -mabi=altivec -mpowerpc-gfxopt")
# ibook G4:
#SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcpu=7450 -mtune=7450 -faltivec -maltivec -mabi=altivec -mpowerpc-gfxopt")
# G5
#SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcpu=G5 -faltivec -maltivec -mabi=altivec -mpowerpc-gfxopt")
ENDIF(NV_SYSTEM_PROCESSOR STREQUAL "powerpc")
# IF(DARWIN)
# SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mmacosx-version-min=10.5 -isysroot /Developer/SDKs/MacOSX10.5.sdk")
# SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mmacosx-version-min=10.5 -isysroot /Developer/SDKs/MacOSX10.5.sdk")
# ENDIF(DARWIN)
IF(APPLE)
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -arch i586 -arch x86_64 -msse3 -mmacosx-version-min=10.5")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -arch i586 -arch x86_64 -msse3 -mmacosx-version-min=10.5")
ENDIF(APPLE)
IF(CMAKE_BUILD_TYPE STREQUAL "debug")
ADD_DEFINITIONS(-D_DEBUG)
ENDIF(CMAKE_BUILD_TYPE STREQUAL "debug")
ENDIF(CMAKE_COMPILER_IS_GNUCXX)
if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
ENDIF()
IF(MSVC)
# @@ Some of these might only be available in VC8.
# Code generation flags.
# SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /arch:SSE2 /fp:fast")
# SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:SSE2 /fp:fast")

@ -1,4 +1,4 @@
Update version number in nvtt/nvtt.h
Update version number in nvimage/DirectDrawSurface.cpp
Update version number in CMakeLists.txt
Update version number in VERSION
Update version number in NVIDIA_Texture_Tools_README.txt

@ -5,8 +5,6 @@ ADD_SUBDIRECTORY(EtcLib)
ADD_SUBDIRECTORY(rg_etc1_v104)
#ADD_SUBDIRECTORY(etcpack)
#ADD_SUBDIRECTORY(butteraugli)
ADD_SUBDIRECTORY(libsquish-1.15)
ADD_SUBDIRECTORY(CMP_Core)

Binary file not shown.

@ -1,175 +0,0 @@
//////////////////////////////////////////////////////////////////////////////
//
// Advanced Micro Devices, Inc.
// 1 AMD Place
// Sunnyvale, CA
// USA 94088
//
// File Name: ATI_Compress.h
// Description: A library to compress/decompress textures
//
// Copyright (c) 2007,2008 Advanced Micro Devices, Inc.
// Copyright (c) 2004-2006 ATI Technologies Inc.
//
// Version: 1.7
//
// Developer: Seth Sowerby
// Email: gputools.support@amd.com
//
//////////////////////////////////////////////////////////////////////////////
/// \file
/// ATI_Compress.h declares the interface to the ATI_Compress library.
#ifndef ATI_COMPRESS
#define ATI_COMPRESS
#define ATI_COMPRESS_VERSION_MAJOR 1 ///< The major version number of this release.
#define ATI_COMPRESS_VERSION_MINOR 7 ///< The minor version number of this release.
typedef unsigned long ATI_TC_DWORD; ///< A 32-bit integer format.
typedef unsigned short ATI_TC_WORD; ///< A 16-bit integer format.
typedef unsigned char ATI_TC_BYTE; ///< An 8-bit integer format.
#if defined(WIN32) || defined(_WIN64)
# define ATI_TC_API __cdecl
#else
# define ATI_TC_API
#endif
#ifdef ATI_COMPRESS_INTERNAL_BUILD
# include "ATI_Compress_Internal.h"
#else // ATI_COMPRESS_INTERNAL_BUILD
/// Texture format.
typedef enum
{
ATI_TC_FORMAT_Unknown, ///< An undefined texture format.
ATI_TC_FORMAT_ARGB_8888, ///< An ARGB format with 8-bit fixed channels.
ATI_TC_FORMAT_RGB_888, ///< A RGB format with 8-bit fixed channels.
ATI_TC_FORMAT_RG_8, ///< A two component format with 8-bit fixed channels.
ATI_TC_FORMAT_R_8, ///< A single component format with 8-bit fixed channels.
ATI_TC_FORMAT_ARGB_2101010, ///< An ARGB format with 10-bit fixed channels for color & a 2-bit fixed channel for alpha.
ATI_TC_FORMAT_ARGB_16, ///< A ARGB format with 16-bit fixed channels.
ATI_TC_FORMAT_RG_16, ///< A two component format with 16-bit fixed channels.
ATI_TC_FORMAT_R_16, ///< A single component format with 16-bit fixed channels.
ATI_TC_FORMAT_ARGB_16F, ///< An ARGB format with 16-bit floating-point channels.
ATI_TC_FORMAT_RG_16F, ///< A two component format with 16-bit floating-point channels.
ATI_TC_FORMAT_R_16F, ///< A single component with 16-bit floating-point channels.
ATI_TC_FORMAT_ARGB_32F, ///< An ARGB format with 32-bit floating-point channels.
ATI_TC_FORMAT_RG_32F, ///< A two component format with 32-bit floating-point channels.
ATI_TC_FORMAT_R_32F, ///< A single component with 32-bit floating-point channels.
ATI_TC_FORMAT_DXT1, ///< An opaque (or 1-bit alpha) DXTC compressed texture format. Four bits per pixel.
ATI_TC_FORMAT_DXT3, ///< A DXTC compressed texture format with explicit alpha. Eight bits per pixel.
ATI_TC_FORMAT_DXT5, ///< A DXTC compressed texture format with interpolated alpha. Eight bits per pixel.
ATI_TC_FORMAT_DXT5_xGBR, ///< A DXT5 with the red component swizzled into the alpha channel. Eight bits per pixel.
ATI_TC_FORMAT_DXT5_RxBG, ///< A swizzled DXT5 format with the green component swizzled into the alpha channel. Eight bits per pixel.
ATI_TC_FORMAT_DXT5_RBxG, ///< A swizzled DXT5 format with the green component swizzled into the alpha channel & the blue component swizzled into the green channel. Eight bits per pixel.
ATI_TC_FORMAT_DXT5_xRBG, ///< A swizzled DXT5 format with the green component swizzled into the alpha channel & the red component swizzled into the green channel. Eight bits per pixel.
ATI_TC_FORMAT_DXT5_RGxB, ///< A swizzled DXT5 format with the blue component swizzled into the alpha channel. Eight bits per pixel.
ATI_TC_FORMAT_DXT5_xGxR, ///< A two-component swizzled DXT5 format with the red component swizzled into the alpha channel & the green component in the green channel. Eight bits per pixel.
ATI_TC_FORMAT_ATI1N, ///< A single component compression format using the same technique as DXT5 alpha. Four bits per pixel.
ATI_TC_FORMAT_ATI2N, ///< A two component compression format using the same technique as DXT5 alpha. Designed for compression object space normal maps. Eight bits per pixel.
ATI_TC_FORMAT_ATI2N_XY, ///< A two component compression format using the same technique as DXT5 alpha. The same as ATI2N but with the channels swizzled. Eight bits per pixel.
ATI_TC_FORMAT_ATI2N_DXT5, ///< An ATI2N like format using DXT5. Intended for use on GPUs that do not natively support ATI2N. Eight bits per pixel.
ATI_TC_FORMAT_BC1, ///< A four component opaque (or 1-bit alpha) compressed texture format for Microsoft DirectX10. Identical to DXT1. Four bits per pixel.
ATI_TC_FORMAT_BC2, ///< A four component compressed texture format with explicit alpha for Microsoft DirectX10. Identical to DXT3. Eight bits per pixel.
ATI_TC_FORMAT_BC3, ///< A four component compressed texture format with interpolated alpha for Microsoft DirectX10. Identical to DXT5. Eight bits per pixel.
ATI_TC_FORMAT_BC4, ///< A single component compressed texture format for Microsoft DirectX10. Identical to ATI1N. Four bits per pixel.
ATI_TC_FORMAT_BC5, ///< A two component compressed texture format for Microsoft DirectX10. Identical to ATI2N. Eight bits per pixel.
ATI_TC_FORMAT_ATC_RGB, ///< ATI_TC - a compressed RGB format for cellphones & hand-held devices.
ATI_TC_FORMAT_ATC_RGBA_Explicit, ///< ATI_TC - a compressed ARGB format with explicit alpha for cellphones & hand-held devices.
ATI_TC_FORMAT_ATC_RGBA_Interpolated, ///< ATI_TC - a compressed ARGB format with interpolated alpha for cellphones & hand-held devices.
ATI_TC_FORMAT_ETC_RGB, ///< ETC (aka Ericsson Texture Compression) - a compressed RGB format for cellphones.
ATI_TC_FORMAT_MAX = ATI_TC_FORMAT_ETC_RGB
} ATI_TC_FORMAT;
/// An enum selecting the speed vs. quality trade-off.
typedef enum
{
ATI_TC_Speed_Normal, ///< Highest quality mode
ATI_TC_Speed_Fast, ///< Slightly lower quality but much faster compression mode - DXTn & ATInN only
ATI_TC_Speed_SuperFast, ///< Slightly lower quality but much, much faster compression mode - DXTn & ATInN only
} ATI_TC_Speed;
/// ATI_Compress error codes
typedef enum
{
ATI_TC_OK = 0, ///< Ok.
ATI_TC_ABORTED, ///< The conversion was aborted.
ATI_TC_ERR_INVALID_SOURCE_TEXTURE, ///< The source texture is invalid.
ATI_TC_ERR_INVALID_DEST_TEXTURE, ///< The destination texture is invalid.
ATI_TC_ERR_UNSUPPORTED_SOURCE_FORMAT, ///< The source format is not a supported format.
ATI_TC_ERR_UNSUPPORTED_DEST_FORMAT, ///< The destination format is not a supported format.
ATI_TC_ERR_SIZE_MISMATCH, ///< The source and destination texture sizes do not match.
ATI_TC_ERR_UNABLE_TO_INIT_CODEC, ///< ATI_Compress was unable to initialize the codec needed for conversion.
ATI_TC_ERR_GENERIC ///< An unknown error occurred.
} ATI_TC_ERROR;
/// Options for the compression.
/// Passing this structure is optional
typedef struct
{
ATI_TC_DWORD dwSize; ///< The size of this structure.
BOOL bUseChannelWeighting; ///< Use channel weightings. With swizzled formats the weighting applies to the data within the specified channel not the channel itself.
double fWeightingRed; ///< The weighting of the Red or X Channel.
double fWeightingGreen; ///< The weighting of the Green or Y Channel.
double fWeightingBlue; ///< The weighting of the Blue or Z Channel.
BOOL bUseAdaptiveWeighting; ///< Adapt weighting on a per-block basis.
BOOL bDXT1UseAlpha; ///< Encode single-bit alpha data. Only valid when compressing to DXT1 & BC1.
ATI_TC_BYTE nAlphaThreshold; ///< The alpha threshold to use when compressing to DXT1 & BC1 with bDXT1UseAlpha. Texels with an alpha value less than the threshold are treated as transparent.
BOOL bDisableMultiThreading; ///< Disable multi-threading of the compression. This will slow the compression but can be useful if you're managing threads in your application.
ATI_TC_Speed nCompressionSpeed; ///< The trade-off between compression speed & quality.
} ATI_TC_CompressOptions;
#endif // !ATI_COMPRESS_INTERNAL_BUILD
/// The structure describing a texture.
typedef struct
{
ATI_TC_DWORD dwSize; ///< Size of this structure.
ATI_TC_DWORD dwWidth; ///< Width of the texture.
ATI_TC_DWORD dwHeight; ///< Height of the texture.
ATI_TC_DWORD dwPitch; ///< Distance to start of next line - necessary only for uncompressed textures.
ATI_TC_FORMAT format; ///< Format of the texture.
ATI_TC_DWORD dwDataSize; ///< Size of the allocated texture data.
ATI_TC_BYTE* pData; ///< Pointer to the texture data
} ATI_TC_Texture;
#define MINIMUM_WEIGHT_VALUE 0.01f
#ifdef __cplusplus
extern "C" {
#endif
/// ATI_TC_Feedback_Proc
/// Feedback function for conversion.
/// \param[in] fProgress The percentage progress of the texture compression.
/// \param[in] pUser1 User data as passed to ATI_TC_ConvertTexture.
/// \param[in] pUser2 User data as passed to ATI_TC_ConvertTexture.
/// \return non-NULL(true) value to abort conversion
typedef bool (ATI_TC_API * ATI_TC_Feedback_Proc)(float fProgress, DWORD_PTR pUser1, DWORD_PTR pUser2);
/// Calculates the required buffer size for the specified texture
/// \param[in] pTexture A pointer to the texture.
/// \return The size of the buffer required to hold the texture data.
ATI_TC_DWORD ATI_TC_API ATI_TC_CalculateBufferSize(const ATI_TC_Texture* pTexture);
/// Converts the source texture to the destination texture
/// This can be compression, decompression or converting between two uncompressed formats.
/// \param[in] pSourceTexture A pointer to the source texture.
/// \param[in] pDestTexture A pointer to the destination texture.
/// \param[in] pOptions A pointer to the compression options - can be NULL.
/// \param[in] pFeedbackProc A pointer to the feedback function - can be NULL.
/// \param[in] pUser1 User data to pass to the feedback function.
/// \param[in] pUser2 User data to pass to the feedback function.
/// \return ATI_TC_OK if successful, otherwise the error code.
ATI_TC_ERROR ATI_TC_API ATI_TC_ConvertTexture(const ATI_TC_Texture* pSourceTexture, ATI_TC_Texture* pDestTexture,
const ATI_TC_CompressOptions* pOptions,
ATI_TC_Feedback_Proc pFeedbackProc, DWORD_PTR pUser1, DWORD_PTR pUser2);
#ifdef __cplusplus
};
#endif
#endif // !ATI_COMPRESS

@ -1,7 +0,0 @@
SET(BUTTERAUGLI_SRCS
butteraugli.cc
butteraugli.h)
ADD_LIBRARY(butteraugli STATIC ${BUTTERAUGLI_SRCS})

File diff suppressed because it is too large Load Diff

@ -1,560 +0,0 @@
// Copyright 2016 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Disclaimer: This is not an official Google product.
//
// Author: Jyrki Alakuijala (jyrki.alakuijala@gmail.com)
#ifndef BUTTERAUGLI_BUTTERAUGLI_H_
#define BUTTERAUGLI_BUTTERAUGLI_H_
#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <memory>
#include <vector>
#ifndef PROFILER_ENABLED
#define PROFILER_ENABLED 0
#endif
#if PROFILER_ENABLED
#else
#define PROFILER_FUNC
#define PROFILER_ZONE(name)
#endif
#define BUTTERAUGLI_ENABLE_CHECKS 0
// This is the main interface to butteraugli image similarity
// analysis function.
namespace butteraugli {
template<typename T>
class Image;
using Image8 = Image<uint8_t>;
using ImageF = Image<float>;
using ImageD = Image<double>;
// ButteraugliInterface defines the public interface for butteraugli.
//
// It calculates the difference between rgb0 and rgb1.
//
// rgb0 and rgb1 contain the images. rgb0[c][px] and rgb1[c][px] contains
// the red image for c == 0, green for c == 1, blue for c == 2. Location index
// px is calculated as y * xsize + x.
//
// Value of pixels of images rgb0 and rgb1 need to be represented as raw
// intensity. Most image formats store gamma corrected intensity in pixel
// values. This gamma correction has to be removed, by applying the following
// function:
// butteraugli_val = 255.0 * pow(png_val / 255.0, gamma);
// A typical value of gamma is 2.2. It is usually stored in the image header.
// Take care not to confuse that value with its inverse. The gamma value should
// be always greater than one.
// Butteraugli does not work as intended if the caller does not perform
// gamma correction.
//
// diffmap will contain an image of the size xsize * ysize, containing
// localized differences for values px (indexed with the px the same as rgb0
// and rgb1). diffvalue will give a global score of similarity.
//
// A diffvalue smaller than kButteraugliGood indicates that images can be
// observed as the same image.
// diffvalue larger than kButteraugliBad indicates that a difference between
// the images can be observed.
// A diffvalue between kButteraugliGood and kButteraugliBad indicates that
// a subtle difference can be observed between the images.
//
// Returns true on success.
bool ButteraugliInterface(const std::vector<ImageF> &rgb0,
const std::vector<ImageF> &rgb1,
ImageF &diffmap,
double &diffvalue);
const double kButteraugliQuantLow = 0.26;
const double kButteraugliQuantHigh = 1.454;
// Converts the butteraugli score into fuzzy class values that are continuous
// at the class boundary. The class boundary location is based on human
// raters, but the slope is arbitrary. Particularly, it does not reflect
// the expectation value of probabilities of the human raters. It is just
// expected that a smoother class boundary will allow for higher-level
// optimization algorithms to work faster.
//
// Returns 2.0 for a perfect match, and 1.0 for 'ok', 0.0 for bad. Because the
// scoring is fuzzy, a butteraugli score of 0.96 would return a class of
// around 1.9.
double ButteraugliFuzzyClass(double score);
// Input values should be in range 0 (bad) to 2 (good). Use
// kButteraugliNormalization as normalization.
double ButteraugliFuzzyInverse(double seek);
// Returns a map which can be used for adaptive quantization. Values can
// typically range from kButteraugliQuantLow to kButteraugliQuantHigh. Low
// values require coarse quantization (e.g. near random noise), high values
// require fine quantization (e.g. in smooth bright areas).
bool ButteraugliAdaptiveQuantization(size_t xsize, size_t ysize,
const std::vector<std::vector<float> > &rgb, std::vector<float> &quant);
// Implementation details, don't use anything below or your code will
// break in the future.
#ifdef _MSC_VER
#define BUTTERAUGLI_RESTRICT __restrict
#else
#define BUTTERAUGLI_RESTRICT __restrict__
#endif
#ifdef _MSC_VER
#define BUTTERAUGLI_CACHE_ALIGNED_RETURN /* not supported */
#else
#define BUTTERAUGLI_CACHE_ALIGNED_RETURN __attribute__((assume_aligned(64)))
#endif
// Alias for unchangeable, non-aliased pointers. T is a pointer type,
// possibly to a const type. Example: ConstRestrict<uint8_t*> ptr = nullptr.
// The conventional syntax uint8_t* const RESTRICT is more confusing - it is
// not immediately obvious that the pointee is non-const.
template <typename T>
using ConstRestrict = T const BUTTERAUGLI_RESTRICT;
// Functions that depend on the cache line size.
class CacheAligned {
public:
static constexpr size_t kPointerSize = sizeof(void *);
static constexpr size_t kCacheLineSize = 64;
// The aligned-return annotation is only allowed on function declarations.
static void *Allocate(const size_t bytes) BUTTERAUGLI_CACHE_ALIGNED_RETURN;
static void Free(void *aligned_pointer);
};
template <typename T>
using CacheAlignedUniquePtrT = std::unique_ptr<T[], void (*)(void *)>;
using CacheAlignedUniquePtr = CacheAlignedUniquePtrT<uint8_t>;
template <typename T = uint8_t>
static inline CacheAlignedUniquePtrT<T> Allocate(const size_t entries) {
return CacheAlignedUniquePtrT<T>(
static_cast<ConstRestrict<T *>>(
CacheAligned::Allocate(entries * sizeof(T))),
CacheAligned::Free);
}
// Returns the smallest integer not less than "amount" that is divisible by
// "multiple", which must be a power of two.
template <size_t multiple>
static inline size_t Align(const size_t amount) {
static_assert(multiple != 0 && ((multiple & (multiple - 1)) == 0),
"Align<> argument must be a power of two");
return (amount + multiple - 1) & ~(multiple - 1);
}
// Single channel, contiguous (cache-aligned) rows separated by padding.
// T must be POD.
//
// Rationale: vectorization benefits from aligned operands - unaligned loads and
// especially stores are expensive when the address crosses cache line
// boundaries. Introducing padding after each row ensures the start of a row is
// aligned, and that row loops can process entire vectors (writes to the padding
// are allowed and ignored).
//
// We prefer a planar representation, where channels are stored as separate
// 2D arrays, because that simplifies vectorization (repeating the same
// operation on multiple adjacent components) without the complexity of a
// hybrid layout (8 R, 8 G, 8 B, ...). In particular, clients can easily iterate
// over all components in a row and Image requires no knowledge of the pixel
// format beyond the component type "T". The downside is that we duplicate the
// xsize/ysize members for each channel.
//
// This image layout could also be achieved with a vector and a row accessor
// function, but a class wrapper with support for "deleter" allows wrapping
// existing memory allocated by clients without copying the pixels. It also
// provides convenient accessors for xsize/ysize, which shortens function
// argument lists. Supports move-construction so it can be stored in containers.
template <typename ComponentType>
class Image {
// Returns cache-aligned row stride, being careful to avoid 2K aliasing.
static size_t BytesPerRow(const size_t xsize) {
// Allow reading one extra AVX-2 vector on the right margin.
const size_t row_size = xsize * sizeof(T)