[deb_x265.git] / source / CMakeLists.txt

# vim: syntax=cmake
if(NOT CMAKE_BUILD_TYPE)
    # default to Release build for GCC builds
    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 MinSizeRel."
        FORCE)
endif()
message(STATUS "cmake version ${CMAKE_VERSION}")
if(POLICY CMP0025)
    cmake_policy(SET CMP0025 OLD) # report Apple's Clang as just Clang
endif()
if(POLICY CMP0042)
    cmake_policy(SET CMP0042 NEW) # MACOSX_RPATH
endif()

project (x265)
cmake_minimum_required (VERSION 2.8.8) # OBJECT libraries require 2.8.8
include(CheckIncludeFiles)
include(CheckFunctionExists)
include(CheckSymbolExists)
include(CheckCXXCompilerFlag)

# X265_BUILD must be incremented each time the public API is changed
set(X265_BUILD 35)
configure_file("${PROJECT_SOURCE_DIR}/x265.def.in"
               "${PROJECT_BINARY_DIR}/x265.def")
configure_file("${PROJECT_SOURCE_DIR}/x265_config.h.in"
               "${PROJECT_BINARY_DIR}/x265_config.h")

SET(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake" "${CMAKE_MODULE_PATH}")

option(CHECKED_BUILD "Enable run-time sanity checks (debugging)" OFF)
if(CHECKED_BUILD)
    add_definitions(-DCHECKED_BUILD=1)
endif()

# System architecture detection
string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" SYSPROC)
set(X86_ALIASES x86 i386 i686 x86_64 amd64)
list(FIND X86_ALIASES "${SYSPROC}" X86MATCH)
if("${SYSPROC}" STREQUAL "" OR X86MATCH GREATER "-1")
    message(STATUS "Detected x86 target processor")
    set(X86 1)
    add_definitions(-DX265_ARCH_X86=1)
    if("${CMAKE_SIZEOF_VOID_P}" MATCHES 8)
        set(X64 1)
        add_definitions(-DX86_64=1)
    endif()
elseif(${SYSPROC} STREQUAL "armv6l")
    message(STATUS "Detected ARM target processor")
    set(ARM 1)
    add_definitions(-DX265_ARCH_ARM=1 -DHAVE_ARMV6=1)
else()
    message(STATUS "CMAKE_SYSTEM_PROCESSOR value `${CMAKE_SYSTEM_PROCESSOR}` is unknown")
    message(STATUS "Please add this value near ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE}")
endif()

if(UNIX)
    SET(PLATFORM_LIBS pthread)
    find_library(LIBRT rt)
    if(LIBRT)
        set(PLATFORM_LIBS ${PLATFORM_LIBS} rt)
    endif()
endif(UNIX)

# Compiler detection
if(CMAKE_GENERATOR STREQUAL "Xcode")
  set(XCODE 1)
endif()
if (APPLE)
  add_definitions(-DMACOS)
endif()

if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
    set(CLANG 1)
endif()
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
    set(INTEL_CXX 1)
endif()
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
    set(GCC 1)
endif()

if(INTEL_CXX AND WIN32)
    # treat icl roughly like MSVC
    set(MSVC 1)
endif()
if(MSVC)
    option(STATIC_LINK_CRT "Statically link C runtime for release builds" OFF)
    if (STATIC_LINK_CRT)
        set(CompilerFlags CMAKE_CXX_FLAGS_RELEASE CMAKE_C_FLAGS_RELEASE)
        foreach(CompilerFlag ${CompilerFlags})
            string(REPLACE "/MD" "/MT" ${CompilerFlag} "${${CompilerFlag}}")
        endforeach()
    endif (STATIC_LINK_CRT)
    add_definitions(/W4)  # Full warnings
    add_definitions(/Ob2) # always inline
    add_definitions(/MP)  # multithreaded build

    # disable Microsofts suggestions for proprietary secure APIs
    add_definitions(/D_CRT_SECURE_NO_WARNINGS)

    check_include_files(stdint.h HAVE_STDINT_H)
    if(NOT HAVE_STDINT_H)
        include_directories(compat/msvc)
    endif()
endif(MSVC)

check_include_files(inttypes.h HAVE_INT_TYPES_H)
if(HAVE_INT_TYPES_H)
    add_definitions(-DHAVE_INT_TYPES_H=1)
endif()

if(INTEL_CXX AND UNIX)
    set(GCC 1) # treat icpc roughly like gcc
elseif(CLANG)
    set(GCC 1) # treat clang roughly like gcc
elseif(CMAKE_COMPILER_IS_GNUCXX)
    set(GCC 1)
endif()
if(GCC)
    add_definitions(-Wall -Wextra -Wshadow)
    add_definitions(-D__STDC_LIMIT_MACROS=1)
    if(X64 AND NOT WIN32)
        add_definitions(-fPIC)
    endif(X64 AND NOT WIN32)
    if(X86 AND NOT X64)
        add_definitions(-march=i686)
    endif()
    if(ARM)
        add_definitions(-march=armv6 -mfloat-abi=hard -mfpu=vfp)
    endif()
    check_cxx_compiler_flag(-Wno-narrowing CC_HAS_NO_NARROWING) 
    check_cxx_compiler_flag(-Wno-array-bounds CC_HAS_NO_ARRAY_BOUNDS) 
    if (CC_HAS_NO_ARRAY_BOUNDS)
        add_definitions(-Wno-array-bounds) # these are unhelpful
    endif()
    check_cxx_compiler_flag(-ffast-math CC_HAS_FAST_MATH) 
    if (CC_HAS_FAST_MATH)
        add_definitions(-ffast-math)
    endif()
    check_cxx_compiler_flag(-mstackrealign CC_HAS_STACK_REALIGN) 
    if (CC_HAS_STACK_REALIGN)
        add_definitions(-mstackrealign)
    endif()
    # Disable exceptions. Reduce executable size, increase compability.
    check_cxx_compiler_flag(-fno-exceptions CC_HAS_FNO_EXCEPTIONS_FLAG)
    if(CC_HAS_FNO_EXCEPTIONS_FLAG)
        add_definitions(-fno-exceptions)
    endif()
    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -dumpversion OUTPUT_VARIABLE CC_VERSION)
endif(GCC)

find_package(Yasm)
if(YASM_FOUND AND X86)
    if (YASM_VERSION_STRING VERSION_LESS "1.2.0")
        message(STATUS "Yasm version ${YASM_VERSION_STRING} is too old. 1.2.0 or later required")
        option(ENABLE_ASSEMBLY "Enable use of assembly coded primitives" OFF)
    else()
        message(STATUS "Found Yasm ${YASM_VERSION_STRING} to build assembly primitives")
        option(ENABLE_ASSEMBLY "Enable use of assembly coded primitives" ON)
    endif()
endif()

# Build options
set(LIB_INSTALL_DIR lib CACHE STRING "Install location of libraries")
set(BIN_INSTALL_DIR bin CACHE STRING "Install location of executables")

if(X64)
    # NOTE: We only officially support 16bit-per-pixel compiles of x265
    # on 64bit architectures. 16bpp plus large resolution plus slow
    # preset plus 32bit address space usually means malloc failure.  You
    # can disable this if(X64) check if you desparately need a 32bit
    # build with 10bit/12bit support, but this violates the "shrink wrap
    # license" so to speak.  If it breaks you get to keep both halves.
    option(HIGH_BIT_DEPTH "Store pixels as 16bit values" OFF)
endif(X64)
if(HIGH_BIT_DEPTH)
    add_definitions(-DHIGH_BIT_DEPTH=1)
else(HIGH_BIT_DEPTH)
    add_definitions(-DHIGH_BIT_DEPTH=0)
endif(HIGH_BIT_DEPTH)

option(WARNINGS_AS_ERRORS "Stop compiles on first warning" OFF)
if(WARNINGS_AS_ERRORS)
    if(GCC)
        add_definitions(-Werror)
    elseif(MSVC)
        add_definitions(/WX)
    endif()
endif(WARNINGS_AS_ERRORS)


option(ENABLE_PPA "Enable PPA profiling instrumentation" OFF)
if(ENABLE_PPA)
    add_definitions(-DENABLE_PPA)
    add_subdirectory(PPA)
    SET(PLATFORM_LIBS ${PLATFORM_LIBS} PPA)
    if(UNIX)
        SET(PLATFORM_LIBS ${PLATFORM_LIBS} dl)
    endif(UNIX)
endif(ENABLE_PPA)

if (WIN32)
    # Visual leak detector
    find_package(VLD QUIET)
    if(VLD_FOUND)
        add_definitions(-DHAVE_VLD)
        include_directories(${VLD_INCLUDE_DIRS})
        set(PLATFORM_LIBS ${PLATFORM_LIBS} ${VLD_LIBRARIES})
        link_directories(${VLD_LIBRARY_DIRS})
    endif()
    option(WINXP_SUPPORT "Make binaries compatible with Windows XP" OFF)
    if(WINXP_SUPPORT)
        # force use of workarounds for CONDITION_VARIABLE and atomic
        # intrinsics introduced after XP
        add_definitions(-D_WIN32_WINNT=_WIN32_WINNT_WINXP)
    endif()
endif()

include(version) # determine X265_VERSION and X265_LATEST_TAG
include_directories(. common encoder "${PROJECT_BINARY_DIR}")
add_subdirectory(encoder)
add_subdirectory(common)

if((MSVC_IDE OR XCODE) AND ENABLE_ASSEMBLY)
    # this is required because of this cmake bug
    # http://www.cmake.org/Bug/print_bug_page.php?bug_id=8170
    if(WIN32)
        set(SUFFIX obj)
    else()
        set(SUFFIX o)
    endif()
    foreach(ASM ${MSVC_ASMS})
        set(YASM_SRC ${CMAKE_CURRENT_SOURCE_DIR}/common/x86/${ASM})
        list(APPEND YASM_SRCS ${YASM_SRC})
        list(APPEND YASM_OBJS ${ASM}.${SUFFIX})
        add_custom_command(
            OUTPUT ${ASM}.${SUFFIX}
            COMMAND ${YASM_EXECUTABLE} ARGS ${YASM_FLAGS} ${YASM_SRC} -o ${ASM}.${SUFFIX}
            DEPENDS ${YASM_SRC})
    endforeach()
endif()

source_group(ASM FILES ${YASM_SRCS})
add_library(x265-static STATIC $<TARGET_OBJECTS:encoder> $<TARGET_OBJECTS:common> ${YASM_OBJS} ${YASM_SRCS})
if(NOT MSVC)
    set_target_properties(x265-static PROPERTIES OUTPUT_NAME x265)
endif()
install(TARGETS x265-static
    LIBRARY DESTINATION ${LIB_INSTALL_DIR}
    ARCHIVE DESTINATION ${LIB_INSTALL_DIR})
install(FILES x265.h "${PROJECT_BINARY_DIR}/x265_config.h" DESTINATION include)

if(CMAKE_RC_COMPILER)
    # The resource compiler does not need CFLAGS or macro defines. It
    # often breaks them
    string(REPLACE "<FLAGS>" "" CMAKE_RC_COMPILE_OBJECT "${CMAKE_RC_COMPILE_OBJECT}")
    string(REPLACE "<DEFINES>" "" CMAKE_RC_COMPILE_OBJECT "${CMAKE_RC_COMPILE_OBJECT}")

    # convert X265_LATEST_TAG (ex: 0.7) and X265_TAG_DISTANCE (ex: 103) to
    # @X265_VERSION_MAJOR@,@X265_VERSION_MINOR@,@X265_BRANCH_ID@,@X265_TAG_DISTANCE@
    string(REPLACE "." ";" VERSION_LIST "${X265_LATEST_TAG}")
    list(GET VERSION_LIST 0 X265_VERSION_MAJOR)
    list(GET VERSION_LIST 1 X265_VERSION_MINOR)
    set(X265_BRANCH_ID 0) # TODO: 0 - stable, 1 - default or other
    set(X265_RC_FILE "${CMAKE_CURRENT_BINARY_DIR}/x265.rc")
    configure_file("${CMAKE_CURRENT_SOURCE_DIR}/x265.rc.in" "${X265_RC_FILE}" @ONLY)
endif()

if(NOT (MSVC_IDE OR XCODE))
    add_custom_target(clean-generated COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/clean-generated.cmake)
endif()

option(ENABLE_SHARED "Build shared library" ON)
if(ENABLE_SHARED)
    add_library(x265-shared SHARED "${PROJECT_BINARY_DIR}/x265.def" ${YASM_OBJS}
                ${X265_RC_FILE} $<TARGET_OBJECTS:encoder> $<TARGET_OBJECTS:common>)
    target_link_libraries(x265-shared ${PLATFORM_LIBS})
    if(MSVC)
        set_target_properties(x265-shared PROPERTIES OUTPUT_NAME libx265)
    else()
        set_target_properties(x265-shared PROPERTIES OUTPUT_NAME x265)
    endif()
    if(UNIX)
        set_target_properties(x265-shared PROPERTIES VERSION ${X265_BUILD})
        if(APPLE)
            set_target_properties(x265-shared PROPERTIES MACOSX_RPATH 1)
        else()
            set_target_properties(x265-shared PROPERTIES LINK_FLAGS "-Wl,-Bsymbolic,-znoexecstack")
        endif()
    endif()
    set_target_properties(x265-shared PROPERTIES SOVERSION ${X265_BUILD})
    if(X265_LATEST_TAG)
        if(WINDOWS)
            set_target_properties(x265-shared PROPERTIES VERSION ${X265_LATEST_TAG})
        endif()
        # shared library is not installed if a tag is not found
        install(TARGETS x265-shared
                LIBRARY DESTINATION ${LIB_INSTALL_DIR}
                ARCHIVE DESTINATION ${LIB_INSTALL_DIR}
                RUNTIME DESTINATION ${BIN_INSTALL_DIR})
    endif()
endif()

if(X265_LATEST_TAG)
    # convert lists of link libraries into -lstdc++ -lm etc..
    foreach(LIB ${CMAKE_CXX_IMPLICIT_LINK_LIBRARIES} ${PLATFORM_LIBS})
        if(IS_ABSOLUTE ${LIB} AND EXISTS ${LIB})
            list(APPEND PLIBLIST "${LIB}")
        else()
            list(APPEND PLIBLIST "-l${LIB}")
        endif()
    endforeach()
    if(PLIBLIST)
        # blacklist of libraries that should not be in Libs.private
        list(REMOVE_ITEM PLIBLIST "-lc" "-lpthread")
        string(REPLACE ";" " " PRIVATE_LIBS "${PLIBLIST}")
    else()
        set(PRIVATE_LIBS "")
    endif(PLIBLIST)

    # Produce a pkg-config file
    configure_file("x265.pc.in" "x265.pc" @ONLY)
    install(FILES       "${CMAKE_CURRENT_BINARY_DIR}/x265.pc"
            DESTINATION "${CMAKE_INSTALL_PREFIX}/${LIB_INSTALL_DIR}/pkgconfig")
endif()

if(NOT WIN32)
    configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in"
                   "${CMAKE_CURRENT_BINARY_DIR}/cmake/cmake_uninstall.cmake"
                   IMMEDIATE @ONLY)
    add_custom_target(uninstall
                      "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake/cmake_uninstall.cmake")
endif()

# Main CLI application
option(ENABLE_CLI "Build standalone CLI application" ON)
if(ENABLE_CLI)
    file(GLOB InputFiles input/*.cpp input/*.h)
    file(GLOB OutputFiles output/*.cpp output/*.h)
    file(GLOB FilterFiles filters/*.cpp filters/*.h)
    source_group(input FILES ${InputFiles})
    source_group(output FILES ${OutputFiles})
    source_group(filters FILES ${FilterFiles})

    check_include_files(getopt.h HAVE_GETOPT_H)
    if(NOT HAVE_GETOPT_H)
        if(MSVC)
            set_source_files_properties(compat/getopt/getopt.c PROPERTIES COMPILE_FLAGS "/wd4100 /wd4131 -DHAVE_STRING_H=1")
        endif(MSVC)
        include_directories(compat/getopt)
        set(GETOPT compat/getopt/getopt.c compat/getopt/getopt.h)
    endif(NOT HAVE_GETOPT_H)

    if(XCODE)
        # Xcode seems unable to link the CLI with libs, so link as one targget
        add_executable(cli ../COPYING ${InputFiles} ${OutputFiles} ${FilterFiles} ${GETOPT} x265.cpp x265.h
                           $<TARGET_OBJECTS:encoder> $<TARGET_OBJECTS:common> ${YASM_OBJS} ${YASM_SRCS})
    else()
        add_executable(cli ../COPYING ${InputFiles} ${OutputFiles} ${FilterFiles} ${GETOPT} ${X265_RC_FILE} x265.cpp x265.h)
        if(WIN32 OR NOT ENABLE_SHARED OR INTEL_CXX)
            # The CLI cannot link to the shared library on Windows, it
            # requires internal APIs not exported from the DLL
            target_link_libraries(cli x265-static ${PLATFORM_LIBS})
        else()
            target_link_libraries(cli x265-shared ${PLATFORM_LIBS})
        endif()
    endif()
    set_target_properties(cli PROPERTIES OUTPUT_NAME x265)

    install(TARGETS cli DESTINATION ${BIN_INSTALL_DIR})
endif(ENABLE_CLI)

if(ENABLE_ASSEMBLY AND NOT XCODE)
    option(ENABLE_TESTS "Enable Unit Tests" OFF)
    if(ENABLE_TESTS)
        add_subdirectory(test)
    endif()
endif()
Commit	Line	Data
72b9787e JB	1	# vim: syntax=cmake
	2	if(NOT CMAKE_BUILD_TYPE)
	3	# default to Release build for GCC builds
	4	set(CMAKE_BUILD_TYPE Release CACHE STRING
	5	"Choose the type of build, options are: None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel."
	6	FORCE)
	7	endif()
	8	message(STATUS "cmake version ${CMAKE_VERSION}")
	9	if(POLICY CMP0025)
	10	cmake_policy(SET CMP0025 OLD) # report Apple's Clang as just Clang
	11	endif()
	12	if(POLICY CMP0042)
	13	cmake_policy(SET CMP0042 NEW) # MACOSX_RPATH
	14	endif()
	15
	16	project (x265)
	17	cmake_minimum_required (VERSION 2.8.8) # OBJECT libraries require 2.8.8
	18	include(CheckIncludeFiles)
	19	include(CheckFunctionExists)
	20	include(CheckSymbolExists)
	21	include(CheckCXXCompilerFlag)
	22
	23	# X265_BUILD must be incremented each time the public API is changed
	24	set(X265_BUILD 35)
	25	configure_file("${PROJECT_SOURCE_DIR}/x265.def.in"
	26	"${PROJECT_BINARY_DIR}/x265.def")
	27	configure_file("${PROJECT_SOURCE_DIR}/x265_config.h.in"
	28	"${PROJECT_BINARY_DIR}/x265_config.h")
	29
	30	SET(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake" "${CMAKE_MODULE_PATH}")
	31
	32	option(CHECKED_BUILD "Enable run-time sanity checks (debugging)" OFF)
	33	if(CHECKED_BUILD)
	34	add_definitions(-DCHECKED_BUILD=1)
	35	endif()
	36
	37	# System architecture detection
	38	string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" SYSPROC)
	39	set(X86_ALIASES x86 i386 i686 x86_64 amd64)
	40	list(FIND X86_ALIASES "${SYSPROC}" X86MATCH)
	41	if("${SYSPROC}" STREQUAL "" OR X86MATCH GREATER "-1")
	42	message(STATUS "Detected x86 target processor")
	43	set(X86 1)
	44	add_definitions(-DX265_ARCH_X86=1)
	45	if("${CMAKE_SIZEOF_VOID_P}" MATCHES 8)
	46	set(X64 1)
	47	add_definitions(-DX86_64=1)
	48	endif()
	49	elseif(${SYSPROC} STREQUAL "armv6l")
	50	message(STATUS "Detected ARM target processor")
	51	set(ARM 1)
	52	add_definitions(-DX265_ARCH_ARM=1 -DHAVE_ARMV6=1)
	53	else()
	54	message(STATUS "CMAKE_SYSTEM_PROCESSOR value `${CMAKE_SYSTEM_PROCESSOR}` is unknown")
	55	message(STATUS "Please add this value near ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE}")
	56	endif()
	57
	58	if(UNIX)
	59	SET(PLATFORM_LIBS pthread)
	60	find_library(LIBRT rt)
	61	if(LIBRT)
	62	set(PLATFORM_LIBS ${PLATFORM_LIBS} rt)
	63	endif()
	64	endif(UNIX)
65
66	# Compiler detection
67	if(CMAKE_GENERATOR STREQUAL "Xcode")
68	set(XCODE 1)
69	endif()
70	if (APPLE)
71	add_definitions(-DMACOS)
72	endif()
73
74	if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
75	set(CLANG 1)
76	endif()
77	if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
78	set(INTEL_CXX 1)
79	endif()
80	if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
81	set(GCC 1)
82	endif()
83
84	if(INTEL_CXX AND WIN32)
85	# treat icl roughly like MSVC
86	set(MSVC 1)
87	endif()
88	if(MSVC)
89	option(STATIC_LINK_CRT "Statically link C runtime for release builds" OFF)
90	if (STATIC_LINK_CRT)
91	set(CompilerFlags CMAKE_CXX_FLAGS_RELEASE CMAKE_C_FLAGS_RELEASE)
92	foreach(CompilerFlag ${CompilerFlags})
93	string(REPLACE "/MD" "/MT" ${CompilerFlag} "${${CompilerFlag}}")
94	endforeach()
95	endif (STATIC_LINK_CRT)
96	add_definitions(/W4) # Full warnings
97	add_definitions(/Ob2) # always inline
98	add_definitions(/MP) # multithreaded build
99
100	# disable Microsofts suggestions for proprietary secure APIs
101	add_definitions(/D_CRT_SECURE_NO_WARNINGS)
102
103	check_include_files(stdint.h HAVE_STDINT_H)
104	if(NOT HAVE_STDINT_H)
105	include_directories(compat/msvc)
106	endif()
107	endif(MSVC)
108
109	check_include_files(inttypes.h HAVE_INT_TYPES_H)
110	if(HAVE_INT_TYPES_H)
111	add_definitions(-DHAVE_INT_TYPES_H=1)
112	endif()
113
114	if(INTEL_CXX AND UNIX)
115	set(GCC 1) # treat icpc roughly like gcc
116	elseif(CLANG)
117	set(GCC 1) # treat clang roughly like gcc
118	elseif(CMAKE_COMPILER_IS_GNUCXX)
119	set(GCC 1)
120	endif()
121	if(GCC)
122	add_definitions(-Wall -Wextra -Wshadow)
123	add_definitions(-D__STDC_LIMIT_MACROS=1)
124	if(X64 AND NOT WIN32)
125	add_definitions(-fPIC)
126	endif(X64 AND NOT WIN32)
127	if(X86 AND NOT X64)
128	add_definitions(-march=i686)
129	endif()
130	if(ARM)
131	add_definitions(-march=armv6 -mfloat-abi=hard -mfpu=vfp)
132	endif()
133	check_cxx_compiler_flag(-Wno-narrowing CC_HAS_NO_NARROWING)
134	check_cxx_compiler_flag(-Wno-array-bounds CC_HAS_NO_ARRAY_BOUNDS)
135	if (CC_HAS_NO_ARRAY_BOUNDS)
136	add_definitions(-Wno-array-bounds) # these are unhelpful
137	endif()
138	check_cxx_compiler_flag(-ffast-math CC_HAS_FAST_MATH)
139	if (CC_HAS_FAST_MATH)
140	add_definitions(-ffast-math)
141	endif()
142	check_cxx_compiler_flag(-mstackrealign CC_HAS_STACK_REALIGN)
143	if (CC_HAS_STACK_REALIGN)
144	add_definitions(-mstackrealign)
145	endif()
146	# Disable exceptions. Reduce executable size, increase compability.
147	check_cxx_compiler_flag(-fno-exceptions CC_HAS_FNO_EXCEPTIONS_FLAG)
148	if(CC_HAS_FNO_EXCEPTIONS_FLAG)
149	add_definitions(-fno-exceptions)
150	endif()
151	execute_process(COMMAND ${CMAKE_CXX_COMPILER} -dumpversion OUTPUT_VARIABLE CC_VERSION)
152	endif(GCC)
153
154	find_package(Yasm)
155	if(YASM_FOUND AND X86)
156	if (YASM_VERSION_STRING VERSION_LESS "1.2.0")
157	message(STATUS "Yasm version ${YASM_VERSION_STRING} is too old. 1.2.0 or later required")
158	option(ENABLE_ASSEMBLY "Enable use of assembly coded primitives" OFF)
159	else()
160	message(STATUS "Found Yasm ${YASM_VERSION_STRING} to build assembly primitives")
161	option(ENABLE_ASSEMBLY "Enable use of assembly coded primitives" ON)
162	endif()
163	endif()
164
165	# Build options
166	set(LIB_INSTALL_DIR lib CACHE STRING "Install location of libraries")
167	set(BIN_INSTALL_DIR bin CACHE STRING "Install location of executables")
168
169	if(X64)
170	# NOTE: We only officially support 16bit-per-pixel compiles of x265
171	# on 64bit architectures. 16bpp plus large resolution plus slow
172	# preset plus 32bit address space usually means malloc failure. You
173	# can disable this if(X64) check if you desparately need a 32bit
174	# build with 10bit/12bit support, but this violates the "shrink wrap
175	# license" so to speak. If it breaks you get to keep both halves.
176	option(HIGH_BIT_DEPTH "Store pixels as 16bit values" OFF)
177	endif(X64)
178	if(HIGH_BIT_DEPTH)
179	add_definitions(-DHIGH_BIT_DEPTH=1)
180	else(HIGH_BIT_DEPTH)
181	add_definitions(-DHIGH_BIT_DEPTH=0)
182	endif(HIGH_BIT_DEPTH)
183
184	option(WARNINGS_AS_ERRORS "Stop compiles on first warning" OFF)
185	if(WARNINGS_AS_ERRORS)
186	if(GCC)
187	add_definitions(-Werror)
188	elseif(MSVC)
189	add_definitions(/WX)
190	endif()
191	endif(WARNINGS_AS_ERRORS)
192
193
194	option(ENABLE_PPA "Enable PPA profiling instrumentation" OFF)
195	if(ENABLE_PPA)
196	add_definitions(-DENABLE_PPA)
197	add_subdirectory(PPA)
198	SET(PLATFORM_LIBS ${PLATFORM_LIBS} PPA)
199	if(UNIX)
200	SET(PLATFORM_LIBS ${PLATFORM_LIBS} dl)
201	endif(UNIX)
202	endif(ENABLE_PPA)
203
204	if (WIN32)
205	# Visual leak detector
206	find_package(VLD QUIET)
207	if(VLD_FOUND)
208	add_definitions(-DHAVE_VLD)
209	include_directories(${VLD_INCLUDE_DIRS})
210	set(PLATFORM_LIBS ${PLATFORM_LIBS} ${VLD_LIBRARIES})
211	link_directories(${VLD_LIBRARY_DIRS})
212	endif()
213	option(WINXP_SUPPORT "Make binaries compatible with Windows XP" OFF)
214	if(WINXP_SUPPORT)
215	# force use of workarounds for CONDITION_VARIABLE and atomic
216	# intrinsics introduced after XP
217	add_definitions(-D_WIN32_WINNT=_WIN32_WINNT_WINXP)
218	endif()
219	endif()
220
221	include(version) # determine X265_VERSION and X265_LATEST_TAG
222	include_directories(. common encoder "${PROJECT_BINARY_DIR}")
223	add_subdirectory(encoder)
224	add_subdirectory(common)
225
226	if((MSVC_IDE OR XCODE) AND ENABLE_ASSEMBLY)
227	# this is required because of this cmake bug
228	# http://www.cmake.org/Bug/print_bug_page.php?bug_id=8170
229	if(WIN32)
230	set(SUFFIX obj)
231	else()
232	set(SUFFIX o)
233	endif()
234	foreach(ASM ${MSVC_ASMS})
235	set(YASM_SRC ${CMAKE_CURRENT_SOURCE_DIR}/common/x86/${ASM})
236	list(APPEND YASM_SRCS ${YASM_SRC})
237	list(APPEND YASM_OBJS ${ASM}.${SUFFIX})
238	add_custom_command(
239	OUTPUT ${ASM}.${SUFFIX}
240	COMMAND ${YASM_EXECUTABLE} ARGS ${YASM_FLAGS} ${YASM_SRC} -o ${ASM}.${SUFFIX}
241	DEPENDS ${YASM_SRC})
242	endforeach()
243	endif()
244
245	source_group(ASM FILES ${YASM_SRCS})
246	add_library(x265-static STATIC $<TARGET_OBJECTS:encoder> $<TARGET_OBJECTS:common> ${YASM_OBJS} ${YASM_SRCS})
247	if(NOT MSVC)
248	set_target_properties(x265-static PROPERTIES OUTPUT_NAME x265)
249	endif()
250	install(TARGETS x265-static
251	LIBRARY DESTINATION ${LIB_INSTALL_DIR}
252	ARCHIVE DESTINATION ${LIB_INSTALL_DIR})
253	install(FILES x265.h "${PROJECT_BINARY_DIR}/x265_config.h" DESTINATION include)
254
255	if(CMAKE_RC_COMPILER)
256	# The resource compiler does not need CFLAGS or macro defines. It
257	# often breaks them
258	string(REPLACE "<FLAGS>" "" CMAKE_RC_COMPILE_OBJECT "${CMAKE_RC_COMPILE_OBJECT}")
259	string(REPLACE "<DEFINES>" "" CMAKE_RC_COMPILE_OBJECT "${CMAKE_RC_COMPILE_OBJECT}")
260
261	# convert X265_LATEST_TAG (ex: 0.7) and X265_TAG_DISTANCE (ex: 103) to
262	# @X265_VERSION_MAJOR@,@X265_VERSION_MINOR@,@X265_BRANCH_ID@,@X265_TAG_DISTANCE@
263	string(REPLACE "." ";" VERSION_LIST "${X265_LATEST_TAG}")
264	list(GET VERSION_LIST 0 X265_VERSION_MAJOR)
265	list(GET VERSION_LIST 1 X265_VERSION_MINOR)
266	set(X265_BRANCH_ID 0) # TODO: 0 - stable, 1 - default or other
267	set(X265_RC_FILE "${CMAKE_CURRENT_BINARY_DIR}/x265.rc")
268	configure_file("${CMAKE_CURRENT_SOURCE_DIR}/x265.rc.in" "${X265_RC_FILE}" @ONLY)
269	endif()
270
271	if(NOT (MSVC_IDE OR XCODE))
272	add_custom_target(clean-generated COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/clean-generated.cmake)
273	endif()
274
275	option(ENABLE_SHARED "Build shared library" ON)
276	if(ENABLE_SHARED)
277	add_library(x265-shared SHARED "${PROJECT_BINARY_DIR}/x265.def" ${YASM_OBJS}
278	${X265_RC_FILE} $<TARGET_OBJECTS:encoder> $<TARGET_OBJECTS:common>)
279	target_link_libraries(x265-shared ${PLATFORM_LIBS})
280	if(MSVC)
281	set_target_properties(x265-shared PROPERTIES OUTPUT_NAME libx265)
282	else()
283	set_target_properties(x265-shared PROPERTIES OUTPUT_NAME x265)
284	endif()
285	if(UNIX)
286	set_target_properties(x265-shared PROPERTIES VERSION ${X265_BUILD})
287	if(APPLE)
288	set_target_properties(x265-shared PROPERTIES MACOSX_RPATH 1)
289	else()
290	set_target_properties(x265-shared PROPERTIES LINK_FLAGS "-Wl,-Bsymbolic,-znoexecstack")
291	endif()
292	endif()
293	set_target_properties(x265-shared PROPERTIES SOVERSION ${X265_BUILD})
294	if(X265_LATEST_TAG)
295	if(WINDOWS)
296	set_target_properties(x265-shared PROPERTIES VERSION ${X265_LATEST_TAG})
297	endif()
298	# shared library is not installed if a tag is not found
299	install(TARGETS x265-shared
300	LIBRARY DESTINATION ${LIB_INSTALL_DIR}
301	ARCHIVE DESTINATION ${LIB_INSTALL_DIR}
302	RUNTIME DESTINATION ${BIN_INSTALL_DIR})
303	endif()
304	endif()
305
306	if(X265_LATEST_TAG)
307	# convert lists of link libraries into -lstdc++ -lm etc..
308	foreach(LIB ${CMAKE_CXX_IMPLICIT_LINK_LIBRARIES} ${PLATFORM_LIBS})
309	if(IS_ABSOLUTE ${LIB} AND EXISTS ${LIB})
310	list(APPEND PLIBLIST "${LIB}")
311	else()
312	list(APPEND PLIBLIST "-l${LIB}")
313	endif()
314	endforeach()
315	if(PLIBLIST)
316	# blacklist of libraries that should not be in Libs.private
317	list(REMOVE_ITEM PLIBLIST "-lc" "-lpthread")
318	string(REPLACE ";" " " PRIVATE_LIBS "${PLIBLIST}")
319	else()
320	set(PRIVATE_LIBS "")
321	endif(PLIBLIST)
322
323	# Produce a pkg-config file
324	configure_file("x265.pc.in" "x265.pc" @ONLY)
325	install(FILES "${CMAKE_CURRENT_BINARY_DIR}/x265.pc"
326	DESTINATION "${CMAKE_INSTALL_PREFIX}/${LIB_INSTALL_DIR}/pkgconfig")
327	endif()
328
329	if(NOT WIN32)
330	configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in"
331	"${CMAKE_CURRENT_BINARY_DIR}/cmake/cmake_uninstall.cmake"
332	IMMEDIATE @ONLY)
333	add_custom_target(uninstall
334	"${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake/cmake_uninstall.cmake")
335	endif()
336
337	# Main CLI application
338	option(ENABLE_CLI "Build standalone CLI application" ON)
339	if(ENABLE_CLI)
340	file(GLOB InputFiles input/.cpp input/.h)
341	file(GLOB OutputFiles output/.cpp output/.h)
342	file(GLOB FilterFiles filters/.cpp filters/.h)
343	source_group(input FILES ${InputFiles})
344	source_group(output FILES ${OutputFiles})
345	source_group(filters FILES ${FilterFiles})
346
347	check_include_files(getopt.h HAVE_GETOPT_H)
348	if(NOT HAVE_GETOPT_H)
349	if(MSVC)
350	set_source_files_properties(compat/getopt/getopt.c PROPERTIES COMPILE_FLAGS "/wd4100 /wd4131 -DHAVE_STRING_H=1")
351	endif(MSVC)
352	include_directories(compat/getopt)
353	set(GETOPT compat/getopt/getopt.c compat/getopt/getopt.h)
354	endif(NOT HAVE_GETOPT_H)
355
356	if(XCODE)
357	# Xcode seems unable to link the CLI with libs, so link as one targget
358	add_executable(cli ../COPYING ${InputFiles} ${OutputFiles} ${FilterFiles} ${GETOPT} x265.cpp x265.h
359	$<TARGET_OBJECTS:encoder> $<TARGET_OBJECTS:common> ${YASM_OBJS} ${YASM_SRCS})
360	else()
361	add_executable(cli ../COPYING ${InputFiles} ${OutputFiles} ${FilterFiles} ${GETOPT} ${X265_RC_FILE} x265.cpp x265.h)
362	if(WIN32 OR NOT ENABLE_SHARED OR INTEL_CXX)
363	# The CLI cannot link to the shared library on Windows, it
364	# requires internal APIs not exported from the DLL
365	target_link_libraries(cli x265-static ${PLATFORM_LIBS})
366	else()
367	target_link_libraries(cli x265-shared ${PLATFORM_LIBS})
368	endif()
369	endif()
370	set_target_properties(cli PROPERTIES OUTPUT_NAME x265)
371
372	install(TARGETS cli DESTINATION ${BIN_INSTALL_DIR})
373	endif(ENABLE_CLI)
374
375	if(ENABLE_ASSEMBLY AND NOT XCODE)
376	option(ENABLE_TESTS "Enable Unit Tests" OFF)
377	if(ENABLE_TESTS)
378	add_subdirectory(test)
379	endif()
380	endif()