Merge branch 'master' of https://github.com/castano/nvidia-texture-tools
Ignacio Castano
3 years ago
commit
e4301b3df7
@ -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 |
||||
@ -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) |
||||
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
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@ -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) | ||||