# CMake project file by Prakash Punnoor

CMAKE_MINIMUM_REQUIRED(VERSION 2.4)
IF(COMMAND cmake_policy)
cmake_policy(SET CMP0003 NEW)
ENDIF(COMMAND cmake_policy)
IF(NOT DEFINED CMAKE_BUILD_TYPE)
SET(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build, options
are: None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo M
inSizeRel.")
ENDIF(NOT DEFINED CMAKE_BUILD_TYPE)
SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/CMakeModules")
Project(Aften C)
SET(SO_MAJOR_VERSION "0")
SET(SO_MINOR_VERSION "0")
SET(SO_BUILD_VERSION "8")
SET(SO_VERSION "${SO_MAJOR_VERSION}.${SO_MINOR_VERSION}.${SO_BUILD_VERSION}")
IF(${Aften_SOURCE_DIR} MATCHES ${Aften_BINARY_DIR})
MESSAGE("Please do an out-of-tree build:")
MESSAGE("rm -f CMakeCache.txt; mkdir -p default; cd default; cmake ..; make")
MESSAGE(FATAL_ERROR "in-tree-build detected")
ENDIF(${Aften_SOURCE_DIR} MATCHES ${Aften_BINARY_DIR})
INCLUDE(${CMAKE_ROOT}/Modules/TestBigEndian.cmake)
INCLUDE(${CMAKE_ROOT}/Modules/CheckCSourceCompiles.cmake)
INCLUDE(${CMAKE_MODULE_PATH}/ConfigHelper.cmake)
INCLUDE(${CMAKE_MODULE_PATH}/HeaderTests.cmake)
INCLUDE(${CMAKE_MODULE_PATH}/FlagsTests.cmake)
INCLUDE(${CMAKE_MODULE_PATH}/CompilerVisibility.cmake)
INCLUDE(${CMAKE_MODULE_PATH}/CompilerSIMD.cmake)
INCLUDE(${CMAKE_MODULE_PATH}/DetectCompiler.cmake)
OPTION(SHARED "build shared Aften library" OFF)
OPTION(DOUBLE "build Aften with doubles instead of floats" OFF)
IF(DOUBLE)
ADD_DEFINE(CONFIG_DOUBLE)
ENDIF(DOUBLE)
OPTION(BINDINGS_CS "build C# bindings" OFF)
OPTION(BINDINGS_CXX "build C++ bindings" OFF)
IF(BINDINGS_CXX)
SET(SHARED ON CACHE BOOL "build shared Aften library" FORCE)
ENDIF(BINDINGS_CXX)
INCLUDE_DIRECTORIES(${Aften_BINARY_DIR}/)
INCLUDE_DIRECTORIES(${Aften_SOURCE_DIR}/)
INCLUDE_DIRECTORIES(${Aften_SOURCE_DIR}/libaften)
INCLUDE_DIRECTORIES(${Aften_SOURCE_DIR}/aften)
INCLUDE_DIRECTORIES(${Aften_SOURCE_DIR}/pcm)
SET(LIBAFTEN_SRCS libaften/a52enc.h
libaften/a52enc.c
libaften/a52.h
libaften/a52.c
libaften/a52tab.h
libaften/a52tab.c
libaften/bitalloc.h

libaften/bitalloc.c
libaften/bitio.h
libaften/bitio.c
libaften/crc.h
libaften/crc.c
libaften/dynrng.h
libaften/dynrng.c
libaften/window.h
libaften/window.c
libaften/mdct.h
libaften/mdct.c
libaften/exponent.h
libaften/exponent.c
libaften/filter.h
libaften/filter.c
libaften/util.c
libaften/convert.h
libaften/convert.c
libaften/threading.h
libaften/a52dec.h
libaften/aften.h
libaften/aften-types.h
libaften/cpu_caps.h
libaften/mem.h
common.h
bswap.h)
SET(LIBAFTEN_X86_SRCS libaften/x86/cpu_caps.c
libaften/x86/cpu_caps.h
libaften/x86/asm_common.h
libaften/x86/asm_support.h
libaften/x86/gas_support.h
libaften/x86/intelas_support.h)
SET(LIBAFTEN_X86_MMX_SRCS libaften/x86/exponent_mmx.c
libaften/x86/exponent.h
libaften/x86/simd_support.h)
SET(LIBAFTEN_X86_SSE_SRCS libaften/x86/mdct_sse.c
libaften/x86/mdct_common_sse.c
libaften/x86/mdct_common_sse.h
libaften/x86/mdct.h
libaften/x86/window_sse.c
libaften/x86/window.h
libaften/x86/simd_support.h)
SET(LIBAFTEN_X86_SSE2_SRCS libaften/x86/exponent_sse2.c
libaften/x86/exponent.h
libaften/x86/simd_support.h)
SET(LIBAFTEN_X86_SSE3_SRCS libaften/x86/mdct_sse3.c
libaften/x86/mdct_common_sse.h
libaften/x86/mdct.h
libaften/x86/simd_support.h)
SET(LIBAFTEN_PPC_SRCS libaften/ppc/cpu_caps.c
libaften/ppc/cpu_caps.h)
SET(LIBAFTEN_ALTIVEC_SRCS libaften/ppc/mdct_altivec.c
libaften/ppc/mdct.h

libaften/ppc/altivec_common.h)
SET(AFTEN_SRCS aften/aften.c
aften/opts.c
aften/opts.h
aften/helptext.h)
SET(PCM_SRCS pcm/aiff.c
pcm/byteio.c
pcm/byteio.h
pcm/caff.c
pcm/convert.c
pcm/formats.c
pcm/formats.h
pcm/pcm.c
pcm/pcm.h
pcm/pcmfile.c
pcm/pcmfile.h
pcm/pcm_io.c
pcm/raw.c
pcm/wav.c)
IF(CMAKE_UNAME)
EXEC_PROGRAM(uname ARGS -m OUTPUT_VARIABLE CMAKE_SYSTEM_MACHINE)
ELSE(CMAKE_UNAME)
IF(CMAKE_SYSTEM MATCHES "Windows" AND CMAKE_SYSTEM_PROCESSOR MATCHES "x86")
IF(CMAKE_SIZEOF_VOID_P MATCHES "8")
SET(CMAKE_SYSTEM_MACHINE "x86_64")
ELSE(CMAKE_SIZEOF_VOID_P MATCHES "8")
SET(CMAKE_SYSTEM_MACHINE "i386")
ENDIF(CMAKE_SIZEOF_VOID_P MATCHES "8")
ELSE(CMAKE_SYSTEM MATCHES "Windows" AND CMAKE_SYSTEM_PROCESSOR MATCHES "x86")
MESSAGE(FATAL_ERROR "Could not detect machine type")
ENDIF(CMAKE_SYSTEM MATCHES "Windows" AND CMAKE_SYSTEM_PROCESSOR MATCHES "x86")
ENDIF(CMAKE_UNAME)
DETECT_COMPILER()
CHECK_64BITS()
IF(CMAKE_COMPILER_IS_GNUCC)
SET(CMAKE_C_FLAGS_RELEASE "-funroll-loops -fomit-frame-pointer ${CMAKE_C_FLAGS
_RELEASE}")
SET(ADD_CFLAGS "-pedantic -Wall -Wpointer-arith -Wredundant-decls -Wformat -Wu
nused ${ADD_CFLAGS}")
# gcc 2.9.5 doesn't know following
CHECK_CFLAGS_APPEND(ADD_EXCLUSIVE_CFLAGS "-std=gnu99")
CHECK_CFLAGS_APPEND(ADD_CFLAGS "-Wdisabled-optimization")
CHECK_CFLAGS_APPEND(ADD_CFLAGS "-Wfloat-equal")
CHECK_CFLAGS_APPEND(ADD_EXCLUSIVE_CFLAGS "-Wbad-function-cast")
# gcc 3.0 doesn't know following
CHECK_CFLAGS_APPEND(ADD_EXCLUSIVE_CFLAGS "-Wdeclaration-after-statement")
CHECK_CFLAGS_APPEND(ADD_CFLAGS "-Wextra")
CHECK_CFLAGS_APPEND(ADD_CFLAGS "-Wno-switch")
# gcc 4.1 doesn't know following
CHECK_CFLAGS_APPEND(ADD_CFLAGS "-Wstrict-overflow")

ENDIF(CMAKE_COMPILER_IS_GNUCC)
IF(CMAKE_COMPILER_IS_ICC)
SET(CMAKE_C_FLAGS_RELEASE "-O3 -funroll-loops -fomit-frame-pointer ${CMAKE_C_F
LAGS_RELEASE}")
SET(ADD_CFLAGS "-std=c99 -Wall -wd810 ${ADD_CFLAGS}")
ENDIF(CMAKE_COMPILER_IS_ICC)
IF(MSVC)
# msvc ignores bogus options, so detection makes no sense
SET(CMAKE_C_FLAGS_RELEASE "/Ot /Oy /Oi /Ox ${CMAKE_C_FLAGS_RELEASE}")
ADD_DEFINITIONS(-D_CRT_SECURE_NO_DEPRECATE)
ENDIF(MSVC)
TEST_BIG_ENDIAN(CMAKE_WORDS_BIGENDIAN)
IF(CMAKE_WORDS_BIGENDIAN)
ADD_DEFINE(WORDS_BIGENDIAN)
ENDIF(CMAKE_WORDS_BIGENDIAN)
IF(UNIX)
SET(LIBM "m")
TEST_COMPILER_VISIBILITY()
IF(APPLE)
ADD_DEFINE(SYS_DARWIN)
ELSE(APPLE)
CHECK_FUNCTION_DEFINE("#include <sys/sysinfo.h>" "get_nprocs" "()" HAVE_GET_
NPROCS)
IF(NOT HAVE_GET_NPROCS)
MESSAGE(STATUS "Hardcoding 2 threads usage")
ADD_DEFINE("NUM_THREADS 2")
ENDIF(NOT HAVE_GET_NPROCS)
ENDIF(APPLE)
ENDIF(UNIX)
# threads handling
FIND_PACKAGE(Threads)
IF(CMAKE_USE_WIN32_THREADS_INIT)
ADD_DEFINE(HAVE_WINDOWS_THREADS)
IF(MINGW)
ADD_DEFINE(MINGW_ALIGN_STACK_HACK)
ENDIF(MINGW)
ELSE(CMAKE_USE_WIN32_THREADS_INIT)
IF(CMAKE_USE_PTHREADS_INIT)
ADD_DEFINE(HAVE_POSIX_THREADS)
SET(ADD_LIBS ${ADD_LIBS} ${CMAKE_THREAD_LIBS_INIT})
ENDIF(CMAKE_USE_PTHREADS_INIT)
ENDIF(CMAKE_USE_WIN32_THREADS_INIT)
ADD_DEFINE("MAX_NUM_THREADS 32")
ADD_DEFINITIONS(-D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -D_LARGEFILE64_SOURCE
)
CHECK_INCLUDE_FILE_DEFINE(inttypes.h HAVE_INTTYPES_H)
CHECK_INCLUDE_FILE_DEFINE(byteswap.h HAVE_BYTESWAP_H)

# output GIT version to config.h

EXECUTE_PROCESS(COMMAND git log -1 --pretty=format:%h
OUTPUT_VARIABLE GIT_VERSION ERROR_QUIET)
IF(GIT_VERSION)
ADD_DEFINE("GIT_VERSION \"${GIT_VERSION}\"")
ENDIF(GIT_VERSION)
CHECK_POSIX_MEMALIGN()
# do SIMD stuff
IF(CMAKE_SYSTEM_MACHINE MATCHES "i.86" OR CMAKE_SYSTEM_MACHINE MATCHES "x86_64")
CHECK_MMX()
# MSVC doesn't have MMX support in x64 mode, so check for SSE independently
CHECK_SSE()
IF(HAVE_MMX OR HAVE_SSE)
INCLUDE_DIRECTORIES(${Aften_SOURCE_DIR}/libaften/x86)
SET(LIBAFTEN_SRCS ${LIBAFTEN_SRCS} ${LIBAFTEN_X86_SRCS})
ADD_DEFINE(HAVE_CPU_CAPS_DETECTION)
ENDIF(HAVE_MMX OR HAVE_SSE)
IF(HAVE_MMX)
SET(LIBAFTEN_SRCS ${LIBAFTEN_SRCS} ${LIBAFTEN_X86_MMX_SRCS})
SET(SIMD_FLAGS "${SIMD_FLAGS} ${MMX_FLAGS} -DUSE_MMX")
FOREACH(SRC ${LIBAFTEN_X86_MMX_SRCS})
SET_SOURCE_FILES_PROPERTIES(${SRC} PROPERTIES COMPILE_FLAGS ${SIMD_FLAGS
})
ENDFOREACH(SRC)
ADD_DEFINE(HAVE_MMX)
ENDIF(HAVE_MMX)
IF(HAVE_SSE)
SET(SIMD_FLAGS "${SIMD_FLAGS} ${SSE_FLAGS} -DUSE_SSE")
IF(NOT DOUBLE)
SET(LIBAFTEN_SRCS ${LIBAFTEN_SRCS} ${LIBAFTEN_X86_SSE_SRCS})
FOREACH(SRC ${LIBAFTEN_X86_SSE_SRCS})
SET_SOURCE_FILES_PROPERTIES(${SRC} PROPERTIES COMPILE_FLAGS ${SIMD_FLAGS
})
ENDFOREACH(SRC)
ENDIF(NOT DOUBLE)
ADD_DEFINE(HAVE_SSE)
CHECK_SSE2()
IF(HAVE_SSE2)
SET(SIMD_FLAGS "${SIMD_FLAGS} ${SSE2_FLAGS} -DUSE_SSE2")
SET(LIBAFTEN_SRCS ${LIBAFTEN_SRCS} ${LIBAFTEN_X86_SSE2_SRCS})
FOREACH(SRC ${LIBAFTEN_X86_SSE2_SRCS})
SET_SOURCE_FILES_PROPERTIES(${SRC} PROPERTIES COMPILE_FLAGS ${SIMD_FLAGS
})
ENDFOREACH(SRC)
ADD_DEFINE(HAVE_SSE2)
CHECK_SSE3()
IF(HAVE_SSE3)
SET(SIMD_FLAGS "${SIMD_FLAGS} ${SSE3_FLAGS} -DUSE_SSE3")
IF(NOT DOUBLE)
SET(LIBAFTEN_SRCS ${LIBAFTEN_SRCS} ${LIBAFTEN_X86_SSE3_SRCS})
FOREACH(SRC ${LIBAFTEN_X86_SSE3_SRCS})
SET_SOURCE_FILES_PROPERTIES(${SRC} PROPERTIES COMPILE_FLAGS ${SIMD_F
LAGS})

ENDFOREACH(SRC)
ENDIF(NOT DOUBLE)
ADD_DEFINE(HAVE_SSE3)
CHECK_CASTSI128()
ENDIF(HAVE_SSE3)
ENDIF(HAVE_SSE2)
ENDIF(HAVE_SSE)
ENDIF(CMAKE_SYSTEM_MACHINE MATCHES "i.86" OR CMAKE_SYSTEM_MACHINE MATCHES "x86_6
4")
IF(CMAKE_SYSTEM_MACHINE MATCHES "Power Macintosh" OR CMAKE_SYSTEM_MACHINE MATCHE
S "ppc")
CHECK_ALTIVEC()
IF(HAVE_ALTIVEC AND NOT DOUBLE)
INCLUDE_DIRECTORIES(${Aften_SOURCE_DIR}/libaften/ppc)
SET(LIBAFTEN_SRCS ${LIBAFTEN_SRCS} ${LIBAFTEN_PPC_SRCS})
SET(LIBAFTEN_SRCS ${LIBAFTEN_SRCS} ${LIBAFTEN_ALTIVEC_SRCS})
FOREACH(SRC ${LIBAFTEN_ALTIVEC_SRCS})
SET_SOURCE_FILES_PROPERTIES(${SRC} PROPERTIES COMPILE_FLAGS "-maltivec")
ENDFOREACH(SRC)
ADD_DEFINE(HAVE_ALTIVEC)
ENDIF(HAVE_ALTIVEC AND NOT DOUBLE)
ENDIF(CMAKE_SYSTEM_MACHINE MATCHES "Power Macintosh" OR CMAKE_SYSTEM_MACHINE MAT
CHES "ppc")
GENERATE_CONFIG_H()
SET(CMAKE_C_FLAGS "${ADD_CFLAGS} ${ADD_EXCLUSIVE_CFLAGS} ${CMAKE_C_FLAGS}")
IF(SHARED)
ADD_LIBRARY(aften SHARED ${LIBAFTEN_SRCS})
SET_TARGET_PROPERTIES(aften PROPERTIES VERSION ${SO_VERSION} SOVERSION ${SO_MA
JOR_VERSION})
SET_TARGET_PROPERTIES(aften PROPERTIES LINKER_LANGUAGE C)
SET_TARGET_PROPERTIES(aften PROPERTIES DEFINE_SYMBOL AFTEN_BUILD_LIBRARY)
TARGET_LINK_LIBRARIES(aften ${LIBM} ${ADD_LIBS})
SET(INSTALL_TARGETS ${INSTALL_TARGETS} aften)
ENDIF(SHARED)
ADD_LIBRARY(aften_static STATIC ${LIBAFTEN_SRCS})
#SET_TARGET_PROPERTIES(aften_static PROPERTIES OUTPUT_NAME aften)
SET_TARGET_PROPERTIES(aften_static PROPERTIES LINKER_LANGUAGE C)
SET_TARGET_PROPERTIES(aften_static PROPERTIES COMPILE_FLAGS -DAFTEN_BUILD_LIBRAR
Y)
TARGET_LINK_LIBRARIES(aften_static ${LIBM} ${ADD_LIBS})
# building a separate static lib for the pcm audio decoder
ADD_LIBRARY(aften_pcm STATIC ${PCM_SRCS})
ADD_EXECUTABLE(aften_exe ${AFTEN_SRCS})
SET_TARGET_PROPERTIES(aften_exe PROPERTIES OUTPUT_NAME aften)
SET_TARGET_PROPERTIES(aften_exe PROPERTIES LINKER_LANGUAGE C)
IF(WIN32)
# When linking to static aften, dllimport mustn't be used
SET_TARGET_PROPERTIES(aften_exe PROPERTIES COMPILE_FLAGS -DAFTEN_BUILD_LIBRARY
)

ENDIF(WIN32)
TARGET_LINK_LIBRARIES(aften_exe aften_pcm aften_static)
ADD_EXECUTABLE(wavinfo util/wavinfo.c)
TARGET_LINK_LIBRARIES(wavinfo aften_pcm)
ADD_EXECUTABLE(wavrms util/wavrms.c)
TARGET_LINK_LIBRARIES(wavrms aften_pcm ${LIBM})
ADD_EXECUTABLE(wavfilter util/wavfilter.c libaften/filter.c)
TARGET_LINK_LIBRARIES(wavfilter aften_pcm ${LIBM})
IF(BINDINGS_CXX)
MESSAGE("## WARNING: The C++ bindings are only lightly tested. Feed-back appre
ciated. ##")
Project(Aften CXX)
SET(CMAKE_CXX_FLAGS_RELEASE "${ADD_CFLAGS} ${CMAKE_C_FLAGS_RELEASE}")
INCLUDE_DIRECTORIES(${Aften_SOURCE_DIR}/bindings)
ADD_LIBRARY(aftenxx SHARED bindings/aftenxx.cxx)
SET_TARGET_PROPERTIES(aftenxx PROPERTIES VERSION ${SO_VERSION} SOVERSION ${SO_
MAJOR_VERSION})
SET_TARGET_PROPERTIES(aftenxx PROPERTIES LINKER_LANGUAGE CXX)
SET_TARGET_PROPERTIES(aftenxx PROPERTIES DEFINE_SYMBOL AFTENXX_BUILD_LIBRARY)
TARGET_LINK_LIBRARIES(aftenxx aften)
SET(INSTALL_TARGETS ${INSTALL_TARGETS} aftenxx)
SET(INSTALL_HEADERS ${INSTALL_HEADERS} bindings/aftenxx.h)
ENDIF(BINDINGS_CXX)
IF(BINDINGS_CS)
MESSAGE("## WARNING: The C# bindings are not completed, but tested (see \"API
C#.txt\"). ##")
SET(AFTENSHARP_SRCS bindings/cs/AftenTypes.cs
bindings/cs/FrameEncoder.cs
bindings/cs/FrameEventArgs.cs
bindings/cs/Utility.cs)
IF(WIN32)
SET(WIN_SRCS "")
FOREACH(SRC ${AFTENSHARP_SRCS})
STRING(REPLACE "/" "\\" WIN_SRC ${SRC})
SET(WIN_SRCS ${WIN_SRCS} ${WIN_SRC})
ENDFOREACH(SRC ${AFTENSHARP_SRCS})
SET(AFTENSHARP_SRCS ${WIN_SRCS})
ENDIF(WIN32)
SET(AFTENSHARP_DLL ${Aften_BINARY_DIR}/AftenSharp.dll)
FIND_PROGRAM(
CSCOMPILER
NAMES csc gmcs)
IF(CSCOMPILER MATCHES "NOTFOUND")
MESSAGE(SEND_ERROR "Could not locate a supported C# compiler")
ENDIF(CSCOMPILER MATCHES "NOTFOUND")
ADD_CUSTOM_COMMAND(
OUTPUT ${AFTENSHARP_DLL}
COMMAND ${CSCOMPILER} -t:library -out:${AFTENSHARP_DLL} -o+ ${AFTENSHARP_SRC
S}
DEPENDS ${AFTENSHARP_SRCS}
WORKING_DIRECTORY ${Aften_SOURCE_DIR})
ADD_CUSTOM_TARGET(
AftenSharp
ALL
DEPENDS ${AFTENSHARP_DLL})
ENDIF(BINDINGS_CS)

INSTALL(TARGETS ${INSTALL_TARGETS} aften_exe wavinfo wavrms wavfilter

RUNTIME DESTINATION bin
LIBRARY DESTINATION lib${LIB_SUFFIX}
ARCHIVE DESTINATION lib${LIB_SUFFIX})
INSTALL(FILES ${INSTALL_HEADERS} libaften/aften.h libaften/aften-types.h DESTINA
TION include/aften)