Free Lossless Audio Codec (FLAC)

https://github.com/xiph/flac
Admin
FLAC is open-source software that reduces digital audio signal storage space without removing...
Tokens:31,247
Snippets:250
Trust Score:7.7
Update:3 weeks ago
Show doc for...
Tokens:
Raw
### Run tests and install with make

Source: https://github.com/xiph/flac/blob/master/README.md

Run tests and install the built libraries and headers after building.

```bash
/path/to/flac-build$ make test
/path/to/flac-build$ make install
```

--------------------------------

### Configure and install pkg-config file

Source: https://github.com/xiph/flac/blob/master/src/libFLAC/CMakeLists.txt

Generates flac.pc from flac.pc.in and installs it to the pkgconfig directory when INSTALL_PKGCONFIG_MODULES is enabled.

```cmake
if(INSTALL_PKGCONFIG_MODULES)
    set(prefix "${CMAKE_INSTALL_PREFIX}")
    set(exec_prefix "${CMAKE_INSTALL_PREFIX}")
    set(libdir "${CMAKE_INSTALL_FULL_LIBDIR}")
    set(includedir "${CMAKE_INSTALL_FULL_INCLUDEDIR}")
    configure_file(flac.pc.in flac.pc @ONLY)
    install(FILES "${CMAKE_CURRENT_BINARY_DIR}/flac.pc"
        DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
endif()
```

--------------------------------

### Install FLAC headers

Source: https://github.com/xiph/flac/blob/master/CMakeLists.txt

Installs public headers from include/FLAC and include/FLAC++ to the appropriate include directories.

```cmake
file(GLOB FLAC_HEADERS "include/FLAC/*.h")
file(GLOB FLAC++_HEADERS "include/FLAC++/*.h")
install(FILES ${FLAC_HEADERS} DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/FLAC")
install(FILES ${FLAC++_HEADERS} DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/FLAC++")
```

--------------------------------

### Install FLAC library

Source: https://github.com/xiph/flac/blob/master/src/libFLAC/CMakeLists.txt

Installs the FLAC library to the appropriate directories based on the build type.

```cmake
install(TARGETS FLAC EXPORT targets
    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}/"
    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}/"
    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}/")
```

--------------------------------

### Install man pages with pandoc

Source: https://github.com/xiph/flac/blob/master/CMakeLists.txt

When INSTALL_MANPAGES is enabled, finds pandoc and generates man pages and HTML documentation from Markdown sources. Falls back to prebuilt man pages if pandoc is unavailable, and errors if neither exists.

```cmake
if(INSTALL_MANPAGES)
    find_program (HAVE_PANDOC pandoc)
    if(HAVE_PANDOC)
        file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/man")
        add_custom_command(
            OUTPUT man/flac.1
            COMMAND pandoc --standalone --to man "${CMAKE_SOURCE_DIR}/man/flac.md" > man/flac.1
            )
        add_custom_command(
            OUTPUT man/metaflac.1
            COMMAND pandoc --standalone --to man "${CMAKE_SOURCE_DIR}/man/metaflac.md" > man/metaflac.1
            )
        add_custom_command(
            OUTPUT man/flac.html
            COMMAND pandoc --standalone --embed-resources --to html "${CMAKE_SOURCE_DIR}/man/flac.md" > man/flac.html || pandoc --self-contained --to html "${CMAKE_SOURCE_DIR}/man/flac.md" > man/flac.html
            )
        add_custom_command(
            OUTPUT man/metaflac.html
            COMMAND pandoc --standalone --embed-resources --to html "${CMAKE_SOURCE_DIR}/man/metaflac.md" > man/metaflac.html || pandoc --self-contained --to html "${CMAKE_SOURCE_DIR}/man/metaflac.md" > man/metaflac.html
            )
        add_custom_target(man ALL DEPENDS man/flac.1 man/metaflac.1 man/flac.html man/metaflac.html)
        install(FILES "${CMAKE_BINARY_DIR}/man/flac.1" "${CMAKE_BINARY_DIR}/man/metaflac.1" DESTINATION "${CMAKE_INSTALL_MANDIR}/man1")
    else()
        if(EXISTS "${CMAKE_SOURCE_DIR}/man/flac.1" AND EXISTS "${CMAKE_SOURCE_DIR}/man/metaflac.1")
            install(FILES "man/flac.1" "man/metaflac.1" DESTINATION "${CMAKE_INSTALL_MANDIR}/man1")
        else()
            message(SEND_ERROR "Pandoc nor prebuild manpages are found. Cannot install manpages. Set INSTALL_MANPAGES to OFF to build without man pages")
        endif()
    endif()
endif()
```

--------------------------------

### Build FLAC with make

Source: https://github.com/xiph/flac/blob/master/README.md

Start the build after CMake has generated the build scripts.

```bash
/path/to/flac-build$ make
```

--------------------------------

### Build FLAC with autotools

Source: https://github.com/xiph/flac/blob/master/README.md

Standard build sequence for FLAC with GNU autotools. Run ./configure (optionally with flags from ./configure --help), then make, optionally make check (can take about an hour and should not be run as root), and finally sudo make install.

```bash
./configure
make && make check
sudo make install
```

--------------------------------

### Add subdirectories

Source: https://github.com/xiph/flac/blob/master/CMakeLists.txt

Adds subdirectories for src, doc, examples, and test based on build options.

```cmake
add_subdirectory("src")
if(BUILD_DOCS)
    add_subdirectory("doc")
endif()
if(BUILD_EXAMPLES)
    add_subdirectory("examples")
endif()
if(BUILD_TESTING)
    add_subdirectory("test")
endif()
```

--------------------------------

### Install CMake package config files

Source: https://github.com/xiph/flac/blob/master/CMakeLists.txt

Exports the FLAC targets and generates/installs flac-config.cmake and flac-config-version.cmake when INSTALL_CMAKE_CONFIG_MODULE is enabled.

```cmake
if(INSTALL_CMAKE_CONFIG_MODULE)
    install(
        EXPORT targets
        DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
        NAMESPACE FLAC::)
    export(EXPORT targets NAMESPACE FLAC:: FILE FLACTargets.cmake)

    configure_package_config_file(
        ${PROJECT_SOURCE_DIR}/flac-config.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/flac-config.cmake
        INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
    write_basic_package_version_file(
        ${CMAKE_CURRENT_BINARY_DIR}/flac-config-version.cmake COMPATIBILITY AnyNewerVersion)

    install(
        FILES ${CMAKE_CURRENT_BINARY_DIR}/flac-config.cmake ${CMAKE_CURRENT_BINARY_DIR}/flac-config-version.cmake
        DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
    )

    install(
        FILES
            "${CMAKE_CURRENT_BINARY_DIR}/flac-config.cmake"
            "${CMAKE_CURRENT_BINARY_DIR}/flac-config-version.cmake"
        DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
endif()
```

--------------------------------

### Encode a file starting with a dash using --

Source: https://github.com/xiph/flac/blob/master/man/flac.md

Use -- to signal the end of options when encoding or decoding files that start with a dash, so the filenames are not treated as options.

```bash
flac -V -- -01-filename.wav
```

--------------------------------

### Set FLAC compile definitions and includes

Source: https://github.com/xiph/flac/blob/master/src/libFLAC/CMakeLists.txt

Configures compile definitions for shared/static builds, sets include directories for build and install, and links against math library and Ogg if available.

```cmake
target_compile_definitions(FLAC
    PRIVATE $<$<BOOL:${BUILD_SHARED_LIBS}>:FLAC_API_EXPORTS>
    PUBLIC $<$<NOT:$<BOOL:${BUILD_SHARED_LIBS}>>:FLAC__NO_DLL>)
if(NOT WIN32)
    target_compile_definitions(FLAC PRIVATE $<$<BOOL:${BUILD_SHARED_LIBS}>:FLAC__USE_VISIBILITY_ATTR>)
endif()
target_include_directories(FLAC INTERFACE
    "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>"
    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
target_link_libraries(FLAC PUBLIC $<$<BOOL:${HAVE_LROUND}>:m>)
if(TARGET Ogg::ogg)
    target_link_libraries(FLAC PUBLIC Ogg::ogg)
endif()
```

--------------------------------

### Build with Ninja generator

Source: https://github.com/xiph/flac/blob/master/README.md

Use the Ninja generator instead of the default build system. The first command configures with -GNinja, the second builds with ninja.

```bash
/path/to/flac-build$ cmake /path/to/flac-source -GNinja
/path/to/flac-build$ ninja
```

--------------------------------

### Add include directories and definitions

Source: https://github.com/xiph/flac/blob/master/CMakeLists.txt

Adds include directories and definitions for config header and MSVC-specific warnings.

```cmake
include_directories("include")

include_directories("${CMAKE_CURRENT_BINARY_DIR}")
add_definitions(-DHAVE_CONFIG_H)

if(MSVC)
    add_definitions(
        -D_CRT_SECURE_NO_WARNINGS
        -D_USE_MATH_DEFINES)
endif()
if(CMAKE_BUILD_TYPE STREQUAL Debug OR CMAKE_BUILD_TYPE STREQUAL RelWithDebInfo)
    add_definitions(-DFLAC__OVERFLOW_DETECT)
endif()
```

--------------------------------

### Configure config.h from template

Source: https://github.com/xiph/flac/blob/master/CMakeLists.txt

Generates config.h from config.cmake.h.in using CMake's configure_file command.

```cmake
configure_file(config.cmake.h.in config.h)
```

--------------------------------

### Set folder properties for targets

Source: https://github.com/xiph/flac/blob/master/CMakeLists.txt

Configures folder organization for targets in IDEs like MSVC. Sets the USE_FOLDERS property globally and assigns targets to Libraries, Programs, Tests, Examples, and Utils folders based on build options.

```cmake
set_property(GLOBAL PROPERTY USE_FOLDERS ON)

set_target_properties(FLAC grabbag getopt replaygain_analysis replaygain_synthesis utf8 PROPERTIES FOLDER Libraries)
if(BUILD_CXXLIBS)
    set_target_properties(FLAC++ PROPERTIES FOLDER Libraries)
endif()
if(BUILD_PROGRAMS)
    set_target_properties(flacapp metaflac PROPERTIES FOLDER Programs)
endif()
if(BUILD_TESTING)
    set_target_properties(test_libFLAC test_libs_common test_picture test_seeking test_streams test_cuesheet PROPERTIES FOLDER Tests)
	if(BUILD_CXXLIBS)
	    set_target_properties(test_libFLAC++ PROPERTIES FOLDER Tests)
	endif()
endif()
if(BUILD_EXAMPLES)
    set_target_properties(decode_file encode_file PROPERTIES FOLDER Examples)
    if(BUILD_CXXLIBS)
        set_target_properties(decode_file_cxx encode_file_cxx PROPERTIES FOLDER Examples)
    endif()
endif()
if(BUILD_UTILS)
    set_target_properties(flacdiff flactimer PROPERTIES FOLDER Utils)
endif()
```

--------------------------------

### List CMake options with -LH

Source: https://github.com/xiph/flac/blob/master/README.md

List available CMake options (e.g., building C++ lib or docs) using the -LH flag.

```bash
/path/to/flac-build$ cmake /path/to/flac-source -LH
```

--------------------------------

### Encode and add tags from file and command line

Source: https://github.com/xiph/flac/blob/master/man/flac.md

Encodes every .wav file in the directory and adds the specified tags to each file. Warning: this wipes all existing tags when the input is (Ogg) FLAC, not just those listed. Use metaflac to tag FLAC files.

```shell
flac --tag-from-file="ALBUM=albumtitle.txt" -T "ARTIST=Queen" *.wav
```

--------------------------------

### CMake configuration for getopt static library

Source: https://github.com/xiph/flac/blob/master/src/share/getopt/CMakeLists.txt

Defines the getopt static library and handles platform-specific dependencies. Checks for string.h, finds Intl on non-Windows, and conditionally links Intl when found.

```cmake
check_include_file("string.h" HAVE_STRING_H)

if(NOT WIN32)
    find_package(Intl)
endif()

add_library(getopt STATIC getopt.c getopt1.c)

if(Intl_FOUND)
    target_include_directories(getopt PRIVATE ${Intl_INCLUDE_DIRS})
    target_link_libraries(getopt PUBLIC ${Intl_LIBRARIES})
    target_compile_definitions(getopt PRIVATE HAVE_LIBINTL_H)
endif()
```

--------------------------------

### Configure common.sh and set test variables

Source: https://github.com/xiph/flac/blob/master/test/CMakeLists.txt

Sets source and build directories, conditionally sets GIT_COMMIT_VERSION_HASH, and configures common.sh.in to common.sh.

```cmake
set(top_srcdir "${PROJECT_SOURCE_DIR}")
set(top_builddir "${PROJECT_BINARY_DIR}")
if(NOT GIT_COMMIT_TAG AND GIT_COMMIT_HASH AND GIT_COMMIT_DATE)
    set(GIT_COMMIT_VERSION_HASH yes)
endif()

configure_file(common.sh.in common.sh @ONLY)
```

--------------------------------

### Add FORTIFY_SOURCE definition

Source: https://github.com/xiph/flac/blob/master/CMakeLists.txt

Adds -D_FORTIFY_SOURCE=2 when WITH_FORTIFY_SOURCE and HAVE_LIBSSP are set.

```cmake
if(WITH_FORTIFY_SOURCE AND HAVE_LIBSSP)
  add_definitions(-D_FORTIFY_SOURCE=2)
endif()
```

--------------------------------

### Generate Xcode project with -GXcode

Source: https://github.com/xiph/flac/blob/master/README.md

Generate an Xcode project using the -GXcode generator. Use cmake --help to see all available generators.

```bash
/path/to/flac-build$ cmake /path/to/flac-source -GXcode
```

--------------------------------

### Define FLAC library target

Source: https://github.com/xiph/flac/blob/master/src/libFLAC/CMakeLists.txt

Creates the FLAC library target with all source files, including conditional sources for Windows and Ogg support. Sets the project label and adds assembly object files if available.

```cmake
include_directories("include")

add_library(FLAC
    bitmath.c
    bitreader.c
    bitwriter.c
    cpu.c
    crc.c
    fixed.c
    fixed_intrin_sse2.c
    fixed_intrin_ssse3.c
    fixed_intrin_sse42.c
    fixed_intrin_avx2.c
    float.c
    format.c
    lpc.c
    lpc_intrin_neon.c
    lpc_intrin_sse2.c
    lpc_intrin_sse41.c
    lpc_intrin_avx2.c
    lpc_intrin_fma.c
    md5.c
    memory.c
    metadata_iterators.c
    metadata_object.c
    stream_decoder.c
    stream_encoder.c
    stream_encoder_intrin_sse2.c
    stream_encoder_intrin_ssse3.c
    stream_encoder_intrin_avx2.c
    stream_encoder_framing.c
    version.rc
    window.c
    $<$<BOOL:${WIN32}>:../../include/share/win_utf8_io.h>
    $<$<BOOL:${WIN32}>:../share/win_utf8_io/win_utf8_io.c>
    $<$<BOOL:${OGG_FOUND}>:ogg_decoder_aspect.c>
    $<$<BOOL:${OGG_FOUND}>:ogg_encoder_aspect.c>
    $<$<BOOL:${OGG_FOUND}>:ogg_helper.c>
    $<$<BOOL:${OGG_FOUND}>:ogg_mapping.c>)
set_property(TARGET FLAC PROPERTY PROJECT_LABEL "libFLAC")
if(TARGET FLAC-asm)
    target_sources(FLAC PRIVATE $<TARGET_OBJECTS:FLAC-asm>)
endif()
```

--------------------------------

### Register program tests with dependencies

Source: https://github.com/xiph/flac/blob/master/test/CMakeLists.txt

Adds tests for generate_streams, flac, metaflac, replaygain, seeking, streams, and compression, with dependencies on generate_streams and a UTF-8 test on Windows.

```cmake
if(BUILD_PROGRAMS)
    add_test(NAME generate_streams
        COMMAND ${BUSYBOX_EXE} ${BUSYBOX_CMD} "${CMAKE_CURRENT_SOURCE_DIR}/generate_streams.sh"
        WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
    add_test(NAME flac
        COMMAND ${BUSYBOX_EXE} ${BUSYBOX_CMD} "${CMAKE_CURRENT_SOURCE_DIR}/test_flac.sh"
        WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
    # UTF-8 must be tested separately on Windows because busybox-w32 doesn't support UTF-8
    if(BUSYBOX_EXE)
        add_test(NAME flac_utf8_test COMMAND $<TARGET_FILE:flacapp> -t
            "${CMAKE_CURRENT_SOURCE_DIR}/flac-to-flac-metadata-test-files/שלום.flac"
            "${CMAKE_CURRENT_SOURCE_DIR}/flac-to-flac-metadata-test-files/Prøve.flac"
            "${CMAKE_CURRENT_SOURCE_DIR}/flac-to-flac-metadata-test-files/🤔.flac")
        list(APPEND ALL_TESTS flac_utf8_test)
    endif()
    file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/metaflac-test-files")
    add_test(NAME metaflac
        COMMAND ${BUSYBOX_EXE} ${BUSYBOX_CMD} "${CMAKE_CURRENT_SOURCE_DIR}/test_metaflac.sh"
        WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
    add_test(NAME replaygain
        COMMAND ${BUSYBOX_EXE} ${BUSYBOX_CMD} "${CMAKE_CURRENT_SOURCE_DIR}/test_replaygain.sh"
        WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
    add_test(NAME seeking
        COMMAND ${BUSYBOX_EXE} ${BUSYBOX_CMD} "${CMAKE_CURRENT_SOURCE_DIR}/test_seeking.sh"
        WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
    add_test(NAME streams
        COMMAND ${BUSYBOX_EXE} ${BUSYBOX_CMD} "${CMAKE_CURRENT_SOURCE_DIR}/test_streams.sh"
        WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
    #   increase this if standard 1500 seconds are not enough
    #   set_tests_properties(streams PROPERTIES TIMEOUT 1500)
    add_test(NAME compression
        COMMAND ${BUSYBOX_EXE} ${BUSYBOX_CMD} "${CMAKE_CURRENT_SOURCE_DIR}/test_compression.sh"
        WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
    set_tests_properties(flac metaflac replaygain seeking streams compression PROPERTIES DEPENDS generate_streams)
    list(APPEND ALL_TESTS generate_streams flac metaflac replaygain seeking streams compression)
endif()
```

--------------------------------

### Generate build scripts with cmake

Source: https://github.com/xiph/flac/blob/master/README.md

Generate build scripts for the default build system (e.g., Makefiles for UNIX) using CMake's CLI. The first command is for Unix-like shells, the second for Windows shells (assuming cmake is in %PATH%).

```bash
/path/to/flac-build$ cmake /path/to/flac-source
```

```batch
C:\path\to\flac-build> cmake \path\to\flac-source
```

--------------------------------

### Encode with combined short options and end-of-options marker

Source: https://github.com/xiph/flac/blob/master/man/flac.md

Combines short options: -V, -j 2, -m, -3, -f, -o Track07.flac, and uses -- to treat -7.wav as a filename. Encodes -7.wav to Track07.flac, overwriting if Track04.flac exists, uses preset -3 with -m, two CPU threads, and verifies the output.

```shell
flac -Vj2 -m3fo Track07.flac  -- -7.wav
```

--------------------------------

### Add compile options

Source: https://github.com/xiph/flac/blob/master/CMakeLists.txt

Adds compiler options for MSVC, -Werror, -Weffc++, and -Wdeclaration-after-statement.

```cmake
add_compile_options(
    $<$<BOOL:${MSVC}>:/wd4267>
    $<$<BOOL:${MSVC}>:/wd4996>
    $<$<BOOL:${ENABLE_WERROR}>:-Werror>
    $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<BOOL:${HAVE_WEFFCXX_FLAG}>>:-Weffc++>
    $<$<AND:$<COMPILE_LANGUAGE:C>,$<BOOL:${HAVE_DECL_AFTER_STMT_FLAG}>>:-Wdeclaration-after-statement>)
```

--------------------------------

### Register grabbag test

Source: https://github.com/xiph/flac/blob/master/test/CMakeLists.txt

Creates a cuesheets directory and adds the grabbag test using test_grabbag.sh.

```cmake
file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/cuesheets")
add_test(NAME grabbag
    COMMAND ${BUSYBOX_EXE} ${BUSYBOX_CMD} "${CMAKE_CURRENT_SOURCE_DIR}/test_grabbag.sh"
    WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
```

--------------------------------

### CMake options and checks for libFLAC

Source: https://github.com/xiph/flac/blob/master/src/libFLAC/CMakeLists.txt

Sets the WITH_ASM option and performs checks for cpuid.h, sys/param.h, and the lround function. Includes CMake modules for CPU architecture and NEON checks.

```cmake
option(WITH_ASM "Use any assembly optimization routines" ON)

check_include_file("cpuid.h" HAVE_CPUID_H)
check_include_file("sys/param.h" HAVE_SYS_PARAM_H)

set(CMAKE_REQUIRED_LIBRARIES m)
check_function_exists(lround HAVE_LROUND)

include(CheckCSourceCompiles)
include(CheckCPUArch)
include(CheckA64NEON)
```

--------------------------------

### Place OGG sources in flac-source/ogg

Source: https://github.com/xiph/flac/blob/master/README.md

Place the OGG sources directly in the FLAC source directory as a subdirectory named 'ogg' to have CMake build OGG alongside FLAC.

```text
/path/to/flac-source/ogg
```

--------------------------------

### Check and apply associative math flags

Source: https://github.com/xiph/flac/blob/master/src/libFLAC/CMakeLists.txt

Checks for compiler support of associative math flags and applies them, or uses /fp:fast for MSVC.

```cmake
check_c_compiler_flag("-fassociative-math -fno-signed-zeros -fno-trapping-math -freciprocal-math" HAVE_ASSOC_MATH)

if(MSVC)
        target_compile_options(FLAC BEFORE PRIVATE "/fp:fast")
else()
    if(HAVE_ASSOC_MATH)
        target_compile_options(FLAC BEFORE PRIVATE -fassociative-math -fno-signed-zeros -fno-trapping-math -freciprocal-math)
    endif()
endif()
```

--------------------------------

### Specify OGG path with -DOGG_ROOT

Source: https://github.com/xiph/flac/blob/master/README.md

Help CMake find OGG by specifying its exact path with -DOGG_ROOT when CMake fails to locate it.

```bash
/path/to/flac-build$ cmake /path/to/flac-source -DOGG_ROOT=/path/to/ogg
```

--------------------------------

### Encode and delete input file on success

Source: https://github.com/xiph/flac/blob/master/man/flac.md

Encodes abc.wav to abc.flac and deletes the input file if there were no errors.

```shell
flac --delete-input-file abc.wav
```

--------------------------------

### Link libssp for MinGW stack protection

Source: https://github.com/xiph/flac/blob/master/CMakeLists.txt

For MinGW with stack protection, finds and links libssp, exporting it in pkg-config. Otherwise sets HAVE_LIBSSP.

```cmake
if(MINGW AND (WITH_FORTIFY_SOURCE OR WITH_STACK_PROTECTOR))
  check_library_exists("ssp.a"  __stack_chk_fail "" HAVE_LIBSSP)
  if(NOT HAVE_LIBSSP)
    message(WARNING "Could not find libssp in MinGW, stack protection and/or FORTIFY_SOURCE are unavailable")
  else()
    link_libraries("ssp.a")
    # static libraries don't carry over other static libraries in mingw
    # we need to export it in the pkg-config
    set(FLAC_STATIC_LIBS "${FLAC_STATIC_LIBS} -lssp")
  endif()
elseif(NOT MSVC)
  set(HAVE_LIBSSP 1)
endif()
```

--------------------------------

### Set Windows executable extension

Source: https://github.com/xiph/flac/blob/master/test/CMakeLists.txt

Sets the EXEEXT variable to .exe on Windows platforms.

```cmake
if(WIN32)
    set(EXEEXT .exe)
endif()
```

--------------------------------

### Encode and verify output

Source: https://github.com/xiph/flac/blob/master/man/flac.md

Encodes abc.wav to abc.flac and internally decodes abc.flac to verify it matches the input.

```shell
flac --verify abc.wav
```

```shell
flac -V abc.wav
```
Tokens:
Raw