sam/sfizz
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

More windows cleanups

Browse source
This commit is contained in:
Paul Ferrand 2020-01-19 00:22:16 +01:00
parent 66052a9ef7
commit d1979d6674
5 changed files with 97 additions and 48 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
CMakeLists.txt
View file

@ -1,4 +1,5 @@
cmake_minimum_required (VERSION 3.13)
cmake_policy(SET CMP0091 NEW)
project (sfizz VERSION 1.0.0 LANGUAGES CXX C)
# External configuration CMake scripts

2
README.md
View file

@ -64,7 +64,7 @@ cd vcpkg
Assuming you want to build for x64, install the relevant packages as follows
```powershell
.\vcpkg.exe install libsndfile:x64-windows-static zlib:x64-windows-static libsamplerate:x64-windows-static
.\vcpkg.exe install libsndfile:x64-windows-static zlib:x64-windows-static libsamplerate:x64-windows-static benchmark:x64-windows-static
```
In the sfizz source directory, you can then build with CMake as usual, although you should clone the windows branch:

91
benchmarks/CMakeLists.txt
View file

@ -6,120 +6,150 @@ set(BENCHMARK_SIMD_SOURCES ${SFIZZ_SIMD_SOURCES})
list(TRANSFORM BENCHMARK_SIMD_SOURCES PREPEND "../src/")
add_executable(bm_opf_high_vs_low BM_OPF_high_vs_low.cpp)
target_link_libraries(bm_opf_high_vs_low PRIVATE benchmark absl::span)
target_link_libraries(bm_opf_high_vs_low PRIVATE absl::span)
sfizz_link_benchmark(bm_opf_high_vs_low)
target_include_directories(bm_opf_high_vs_low PRIVATE ../src/sfizz ../src/external)
add_executable(bm_write BM_writeInterleaved.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_write PRIVATE benchmark absl::span)
target_link_libraries(bm_write PRIVATE absl::span)
sfizz_link_benchmark(bm_write)
target_include_directories(bm_write PRIVATE ../src/sfizz ../src/external)
add_executable(bm_read BM_readInterleaved.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_read PRIVATE benchmark absl::span)
target_link_libraries(bm_read PRIVATE absl::span)
sfizz_link_benchmark(bm_read)
target_include_directories(bm_read PRIVATE ../src/sfizz ../src/external)
add_executable(bm_fill BM_fill.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_fill PRIVATE benchmark absl::span)
target_link_libraries(bm_fill PRIVATE absl::span)
sfizz_link_benchmark(bm_fill)
target_include_directories(bm_fill PRIVATE ../src/sfizz ../src/external)
add_executable(bm_mathfuns BM_mathfuns.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_mathfuns PRIVATE benchmark absl::span)
target_link_libraries(bm_mathfuns PRIVATE absl::span)
sfizz_link_benchmark(bm_mathfuns)
target_include_directories(bm_mathfuns PRIVATE ../src/sfizz ../src/external)
add_executable(bm_gain BM_gain.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_gain PRIVATE benchmark absl::span)
target_link_libraries(bm_gain PRIVATE absl::span)
sfizz_link_benchmark(bm_gain)
target_include_directories(bm_gain PRIVATE ../src/sfizz ../src/external)
add_executable(bm_divide BM_divide.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_divide PRIVATE benchmark absl::span)
target_link_libraries(bm_divide PRIVATE absl::span)
sfizz_link_benchmark(bm_divide)
target_include_directories(bm_divide PRIVATE ../src/sfizz ../src/external)
add_executable(bm_looping BM_looping.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_looping PRIVATE benchmark absl::span absl::algorithm)
target_link_libraries(bm_looping PRIVATE absl::span absl::algorithm)
sfizz_link_benchmark(bm_looping)
target_include_directories(bm_looping PRIVATE ../src/sfizz ../src/external)
add_executable(bm_saturating BM_saturating.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_saturating PRIVATE benchmark absl::span absl::algorithm)
target_link_libraries(bm_saturating PRIVATE absl::span absl::algorithm)
sfizz_link_benchmark(bm_saturating)
target_include_directories(bm_saturating PRIVATE ../src/sfizz ../src/external)
add_executable(bm_ramp BM_ramp.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_ramp PRIVATE benchmark absl::span absl::algorithm)
target_link_libraries(bm_ramp PRIVATE absl::span absl::algorithm)
sfizz_link_benchmark(bm_ramp)
target_include_directories(bm_ramp PRIVATE ../src/sfizz ../src/external)
add_executable(bm_ADSR BM_ADSR.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_ADSR PRIVATE benchmark absl::span absl::algorithm)
target_link_libraries(bm_ADSR PRIVATE absl::span absl::algorithm)
sfizz_link_benchmark(bm_ADSR)
target_include_directories(bm_ADSR PRIVATE ../src/sfizz ../src/external)
add_executable(bm_add BM_add.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_add PRIVATE benchmark absl::span absl::algorithm)
target_link_libraries(bm_add PRIVATE absl::span absl::algorithm)
sfizz_link_benchmark(bm_add)
target_include_directories(bm_add PRIVATE ../src/sfizz ../src/external)
add_executable(bm_multiplyAdd BM_multiplyAdd.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_multiplyAdd PRIVATE benchmark absl::span absl::algorithm)
target_link_libraries(bm_multiplyAdd PRIVATE absl::span absl::algorithm)
sfizz_link_benchmark(bm_multiplyAdd)
target_include_directories(bm_multiplyAdd PRIVATE ../src/sfizz ../src/external)
add_executable(bm_subtract BM_subtract.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_subtract PRIVATE benchmark absl::span absl::algorithm)
target_link_libraries(bm_subtract PRIVATE absl::span absl::algorithm)
sfizz_link_benchmark(bm_subtract)
target_include_directories(bm_subtract PRIVATE ../src/sfizz ../src/external)
add_executable(bm_copy BM_copy.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_copy PRIVATE benchmark absl::span absl::algorithm)
target_link_libraries(bm_copy PRIVATE absl::span absl::algorithm)
sfizz_link_benchmark(bm_copy)
target_include_directories(bm_copy PRIVATE ../src/sfizz ../src/external)
add_executable(bm_pan BM_pan.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_pan PRIVATE benchmark absl::span absl::algorithm)
target_link_libraries(bm_pan PRIVATE absl::span absl::algorithm)
sfizz_link_benchmark(bm_pan)
target_include_directories(bm_pan PRIVATE ../src/sfizz ../src/external)
add_executable(bm_mean BM_mean.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_mean PRIVATE benchmark absl::span absl::algorithm)
target_link_libraries(bm_mean PRIVATE absl::span absl::algorithm)
sfizz_link_benchmark(bm_mean)
target_include_directories(bm_mean PRIVATE ../src/sfizz ../src/external)
add_executable(bm_meanSquared BM_meanSquared.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_meanSquared PRIVATE benchmark absl::span absl::algorithm)
target_link_libraries(bm_meanSquared PRIVATE absl::span absl::algorithm)
sfizz_link_benchmark(bm_meanSquared)
target_include_directories(bm_meanSquared PRIVATE ../src/sfizz ../src/external)
add_executable(bm_cumsum BM_cumsum.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_cumsum PRIVATE benchmark absl::span absl::algorithm)
target_link_libraries(bm_cumsum PRIVATE absl::span absl::algorithm)
sfizz_link_benchmark(bm_cumsum)
target_include_directories(bm_cumsum PRIVATE ../src/sfizz ../src/external)
add_executable(bm_diff BM_diff.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_diff PRIVATE benchmark absl::span absl::algorithm)
target_link_libraries(bm_diff PRIVATE absl::span absl::algorithm)
sfizz_link_benchmark(bm_diff)
target_include_directories(bm_diff PRIVATE ../src/sfizz ../src/external)
add_executable(bm_interpolationCast BM_interpolationCast.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_interpolationCast PRIVATE benchmark absl::span absl::algorithm)
target_link_libraries(bm_interpolationCast PRIVATE absl::span absl::algorithm)
sfizz_link_benchmark(bm_interpolationCast)
target_include_directories(bm_interpolationCast PRIVATE ../src/sfizz ../src/external)
add_executable(bm_pointerIterationOrOffsets BM_pointerIterationOrOffsets.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_pointerIterationOrOffsets PRIVATE benchmark absl::span absl::algorithm)
target_link_libraries(bm_pointerIterationOrOffsets PRIVATE absl::span absl::algorithm)
sfizz_link_benchmark(bm_pointerIterationOrOffsets)
target_include_directories(bm_pointerIterationOrOffsets PRIVATE ../src/sfizz ../src/external)
if (NOT WIN32)
add_executable(bm_resample BM_resample.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_resample PRIVATE benchmark absl::span absl::algorithm)
target_link_libraries(bm_resample PRIVATE absl::span absl::algorithm)
sfizz_link_benchmark(bm_resample)
sfizz_link_libsndfile(bm_resample)
sfizz_link_libsamplerate(bm_resample)
target_include_directories(bm_resample PRIVATE ../src/sfizz ../src/external)
endif()
add_executable(bm_envelopes BM_envelopes.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_envelopes PRIVATE benchmark absl::span absl::algorithm)
target_link_libraries(bm_envelopes PRIVATE absl::span absl::algorithm)
sfizz_link_benchmark(bm_envelopes)
target_include_directories(bm_envelopes PRIVATE ../src/sfizz ../src/external)
add_executable(bm_wavfile BM_wavfile.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_wavfile PRIVATE benchmark absl::span absl::algorithm)
target_link_libraries(bm_wavfile PRIVATE absl::span absl::algorithm)
sfizz_link_benchmark(bm_wavfile)
sfizz_link_libsndfile(bm_wavfile)
target_include_directories(bm_wavfile PRIVATE ../src/sfizz ../src/external)
add_executable(bm_flacfile BM_flacfile.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_flacfile PRIVATE benchmark absl::span absl::algorithm)
target_link_libraries(bm_flacfile PRIVATE absl::span absl::algorithm)
sfizz_link_benchmark(bm_flacfile)
sfizz_link_libsndfile(bm_flacfile)
target_include_directories(bm_flacfile PRIVATE ../src/sfizz ../src/external)
add_executable(bm_readChunk BM_readChunk.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_readChunk PRIVATE benchmark absl::span absl::algorithm)
target_link_libraries(bm_readChunk PRIVATE absl::span absl::algorithm)
sfizz_link_benchmark(bm_readChunk)
sfizz_link_libsndfile(bm_readChunk)
target_include_directories(bm_readChunk PRIVATE ../src/sfizz ../src/external)
add_executable(bm_resampleChunk BM_resampleChunk.cpp ${BENCHMARK_SIMD_SOURCES})
target_link_libraries(bm_resampleChunk PRIVATE benchmark absl::span absl::algorithm)
target_link_libraries(bm_resampleChunk PRIVATE absl::span absl::algorithm)
sfizz_link_benchmark(bm_resampleChunk)
sfizz_link_libsndfile(bm_resampleChunk)
target_include_directories(bm_resampleChunk PRIVATE ../src/sfizz ../src/external)
@ -147,13 +177,16 @@ add_dependencies(sfizz_benchmarks
bm_subtract
bm_multiplyAdd
bm_readChunk
bm_resample
bm_resampleChunk
bm_envelopes
bm_wavfile
bm_flacfile
)
if (NOT WIN32)
add_dependencies(sfizz_benchmarks bm_resample)
endif()
file(COPY "sample1.wav" DESTINATION ${CMAKE_BINARY_DIR}/benchmarks)
file(COPY "sample2.wav" DESTINATION ${CMAKE_BINARY_DIR}/benchmarks)
file(COPY "sample3.wav" DESTINATION ${CMAKE_BINARY_DIR}/benchmarks)

14
cmake/SfizzConfig.cmake
View file

@ -22,25 +22,35 @@ endif()
if (WIN32)
find_package(LibSndFile REQUIRED)
find_package(benchmark CONFIG REQUIRED)
find_path(SNDFILE_INCLUDE_DIR sndfile.hh)
find_path(SAMPLERATE_INCLUDE_DIR samplerate.h)
set(CMAKE_CXX_STANDARD 17)
add_compile_options(/Zc:__cplusplus)
set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
endif()
function(SFIZZ_LINK_LIBSNDFILE TARGET)
if (WIN32)
target_link_libraries (${TARGET} PRIVATE sndfile-static)
target_include_directories(${TARGET} PRIVATE ${SNDFILE_INCLUDE_DIR})
target_include_directories(${TARGET} PUBLIC ${SNDFILE_INCLUDE_DIR})
else()
target_link_libraries(${TARGET} PRIVATE sndfile)
endif()
endfunction(SFIZZ_LINK_LIBSNDFILE)
function(SFIZZ_LINK_BENCHMARK TARGET)
if (WIN32)
target_link_libraries (${TARGET} PRIVATE benchmark::benchmark benchmark::benchmark_main)
else()
target_link_libraries(${TARGET} PRIVATE benchmark)
endif()
endfunction(SFIZZ_LINK_BENCHMARK)
function(SFIZZ_LINK_LIBSAMPLERATE TARGET)
if (WIN32)
target_link_libraries (${TARGET} PRIVATE samplerate)
target_include_directories(${TARGET} PRIVATE ${SAMPLERATE_INCLUDE_DIR})
target_include_directories(${TARGET} PUBLIC ${SAMPLERATE_INCLUDE_DIR})
else()
target_link_libraries(${TARGET} PRIVATE samplerate)
endif()

37
src/CMakeLists.txt
View file

@ -19,22 +19,27 @@ target_include_directories (sfizz_parser PUBLIC sfizz)
target_include_directories (sfizz_parser PUBLIC external)
target_link_libraries (sfizz_parser PRIVATE absl::strings)
add_library (sfizz_objects OBJECT)
target_sources(sfizz_objects PRIVATE ${SFIZZ_SOURCES})
target_include_directories (sfizz_objects PUBLIC external)
target_link_libraries (sfizz_objects PUBLIC absl::strings absl::span)
target_link_libraries (sfizz_objects PRIVATE sfizz_parser absl::flat_hash_map Threads::Threads)
if (UNIX AND NOT APPLE)
target_link_libraries (sfizz_objects PRIVATE atomic)
endif()
sfizz_link_libsndfile(sfizz_objects)
# Sfizz core library
add_library(sfizz STATIC)
target_sources(sfizz PRIVATE ${SFIZZ_SOURCES} sfizz/sfizz_wrapper.cpp)
target_include_directories (sfizz PUBLIC .)
target_include_directories (sfizz PUBLIC external)
target_link_libraries (sfizz PUBLIC absl::strings absl::span)
target_link_libraries (sfizz PRIVATE sfizz_parser absl::flat_hash_map Threads::Threads)
sfizz_link_libsndfile(sfizz)
add_library(sfizz_static STATIC)
target_sources(sfizz_static PRIVATE sfizz/sfizz_wrapper.cpp)
target_link_libraries (sfizz_static PRIVATE sfizz_objects)
target_include_directories (sfizz_static PUBLIC .)
target_include_directories (sfizz_static PUBLIC external) # Object dependency is not transitive?
target_link_libraries (sfizz_static PUBLIC absl::strings absl::span) # Object dependency is not transitive?
sfizz_enable_lto_if_needed(sfizz)
if (UNIX AND NOT APPLE)
target_link_libraries (sfizz PRIVATE atomic)
endif()
add_library (sfizz::parser ALIAS sfizz_parser)
add_library (sfizz::sfizz ALIAS sfizz)
add_library (sfizz::sfizz ALIAS sfizz_static)
# install(TARGETS sfizz_parser DESTINATION . EXCLUDE_FROM_ALL)
# install(TARGETS sfizz DESTINATION . EXCLUDE_FROM_ALL)
@ -42,12 +47,12 @@ add_library (sfizz::sfizz ALIAS sfizz)
# Shared library and installation target
if (SFIZZ_SHARED)
add_library (sfizz_shared SHARED)
target_compile_options(sfizz_shared PRIVATE -DSFIZZ_EXPORT_SYMBOLS)
target_sources(sfizz_shared PRIVATE ${SFIZZ_SOURCES} sfizz/sfizz_wrapper.cpp)
target_sources(sfizz_shared PRIVATE sfizz/sfizz_wrapper.cpp)
target_include_directories (sfizz_shared PRIVATE .)
target_link_libraries (sfizz_shared PRIVATE sfizz_parser absl::flat_hash_map Threads::Threads absl::strings absl::span)
target_link_libraries (sfizz_shared PRIVATE sfizz_objects)
target_compile_definitions(sfizz_shared PRIVATE SFIZZ_EXPORT_SYMBOLS)
set_target_properties (sfizz_shared PROPERTIES OUTPUT_NAME sfizz PUBLIC_HEADER sfizz.h)
sfizz_link_libsndfile(sfizz_shared)
# sfizz_link_libsndfile(sfizz_shared)
sfizz_enable_lto_if_needed(sfizz_shared)
configure_file (${PROJECT_SOURCE_DIR}/scripts/sfizz.pc.in sfizz.pc @ONLY)
if (UNIX)