setup.py

# coding: utf-8
# /*##########################################################################
#
# Copyright (c) 2016-2025 European Synchrotron Radiation Facility
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# ###########################################################################*/
from __future__ import annotations

__authors__ = ["V.A. Sole", "T. Vincent"]
__license__ = "MIT"
__date__ = "05/12/2022"


from functools import lru_cache
from glob import glob
from pathlib import Path
import itertools
import logging
import os
import sys
import sysconfig
import tempfile
import platform
from functools import cached_property
from setuptools import setup, Distribution, Extension
from setuptools.command.build_ext import build_ext
from setuptools.command.build_py import build_py
from setuptools.command.build_clib import build_clib
from setuptools.command.build import build
from setuptools.errors import CompileError
from wheel.bdist_wheel import bdist_wheel

try:
    import pkgconfig
except ImportError:
    pkgconfig = None

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

try:
    import cpuinfo
except ModuleNotFoundError:
    raise ModuleNotFoundError("py-cpuinfo is required to build hdf5plugin, please install it.")
except Exception:  # cpuinfo raises Exception for unsupported architectures
    logger.warning("Architecture is not supported by cpuinfo")
    cpuinfo = None
    cpuinfo_parse_arch = None
else:
    from cpuinfo.cpuinfo import _parse_arch as cpuinfo_parse_arch


class BDistWheel(bdist_wheel):
    """Override bdist_wheel to handle as pure python package"""

    def get_tag(self):
        """Override the python and abi tag generation"""
        return self.python_tag, "none", super().get_tag()[-1]


# Probe host capabilities and manage build config

def get_compiler(compiler):
    """Returns an initialized compiler

    Taken from https://github.com/pypa/setuptools/issues/2806#issuecomment-961805789
    """
    build_ext = Distribution().get_command_obj("build_ext")
    build_ext.compiler = compiler
    build_ext.finalize_options()
    # register an extension to ensure a compiler is created
    build_ext.extensions = [Extension("ignored", ["ignored.c"])]
    # disable building fake extensions
    build_ext.build_extensions = lambda: None
    # run to populate self.compiler
    build_ext.run()
    return build_ext.compiler


def check_compile_flags(compiler, *flags, extension='.c', source=None):
    """Try to compile an empty file to check for compiler args

    :param distutils.ccompiler.CCompiler compiler: The compiler to use
    :param flags: Flags argument to pass to compiler
    :param str extension: Source file extension (default: '.c')
    :param source: Source code to compile (default: dummy C function)
    :returns: Whether or not compilation was successful
    :rtype: bool
    """
    if source is None:
        source = 'int main (int argc, char **argv) { return 0; }\n'
    with tempfile.TemporaryDirectory() as tmp_dir:
        # Create empty source file
        tmp_file = Path(tmp_dir) / f"source{extension}"
        tmp_file.write_text(source)
        try:
            compiler.compile([str(tmp_file)], output_dir=tmp_dir, extra_postargs=list(flags))
        except CompileError:
            return False
        else:
            return True


def has_cpu_flag(flag: str) -> bool:
    """Is given flag available on the current (x86) CPU"""
    if cpuinfo is None:
        logger.warning("Cannot get CPU flags")
        return False
    return flag in cpuinfo.get_cpu_info().get('flags', [])


class HostConfig:
    """Probe and describe host configuration

    For differences in native build option across architectures, see
    https://gcc.gnu.org/onlinedocs/gcc/Submodel-Options.html#Submodel-Options
    """

    ARCH = cpuinfo_parse_arch(platform.machine().lower())[0] if cpuinfo_parse_arch is not None else None
    """Machine architecture description from cpuinfo parser"""

    def __init__(self, compiler=None):
        self.__compiler = get_compiler(compiler)

        # Set architecture specific compile args
        if self.ARCH in ('X86_32', 'X86_64', 'MIPS_64'):
            self.native_compile_args = ("-march=native",)
        elif self.ARCH in ('ARM_7', 'ARM_8', 'PPC_64'):
            self.native_compile_args = ("-mcpu=native",)
        else:
            self.native_compile_args = ()

        if self.ARCH in ('X86_32', 'X86_64'):
            self.sse2_compile_args = ('-msse2',)  # /arch:SSE2 is on by default
        else:
            self.sse2_compile_args = ()

        if self.ARCH in ('X86_32', 'X86_64'):
            self.ssse3_compile_args = ('-mssse3',)  # There is no /arch:SSSE3
        else:
            self.ssse3_compile_args = ()

        if self.ARCH in ('X86_32', 'X86_64'):
            self.avx2_compile_args = ('-mavx2', '/arch:AVX2')
        else:
            self.avx2_compile_args = ()

        if self.ARCH in ('X86_32', 'X86_64'):
            self.avx512_compile_args = ('-mavx512f', '-mavx512bw', '/arch:AVX512')
        else:
            self.avx512_compile_args = ()

    def get_shared_lib_extension(self) -> str:
        """Returns shared library file extension"""
        if sys.platform == 'win32':
            return '.dll'
        elif sys.platform == 'linux':
            return '.so'
        elif sys.platform == 'darwin':
            return '.dylib'
        else:  # Return same value as used by build_ext.get_ext_filename
            return sysconfig.get_config_var('EXT_SUFFIX')

    def has_cpp11(self) -> bool:
        """Check C++11 availability on host"""
        if self.__compiler.compiler_type == 'msvc':
            return True
        return check_compile_flags(self.__compiler, '-std=c++11', extension='.cc')

    def has_cpp14(self) -> bool:
        """Check C++14 availability on host"""
        if self.__compiler.compiler_type == 'msvc':
            return True
        return check_compile_flags(self.__compiler, '-std=c++14', extension='.cc')

    @lru_cache()
    def get_cpp20_flag(self) -> str | None:
        """Returns C++20 compiler flag or None if not supported"""
        if self.__compiler.compiler_type == 'msvc':
            # C++20 available since Visual Studio C++ 2019 v16.11
            # Lack of support of the compilation flag do not raise an error
            # So instead check the _MSVC_LANG macro
            # See: https://learn.microsoft.com/en-us/cpp/build/reference/std-specify-language-standard-version?view=msvc-170#c-standards-support
            is_available = check_compile_flags(
                self.__compiler,
                '/std:c++20',
                extension='.cc',
                source="""
                    #if _MSVC_LANG != 202002L
                    #error C++20 is not supported
                    #endif
                    int main (int argc, char **argv) { return 0; }
                """,
            )
            return "/std:c++20" if is_available else None

        # -std=c++20 if clang>=10 or gcc>=10 else -std=c++2a
        for flag in ('-std=c++20', '-std=c++2a'):
            if check_compile_flags(self.__compiler, flag, extension='.cc'):
                break
        else:  # Check failed for both flags
            return None

        if sys.platform != 'darwin':
            return flag

        # Check macos min version >= 10.13:
        # 10.13 does not fully support C++20, but is enough to build the SPERR library
        is_available = check_compile_flags(
            self.__compiler,
            flag,
            extension='.cc',
            source="""
                #include "AvailabilityMacros.h"
                #if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_13
                #error C++20 is not supported: macOS 10.13 at least is required
                #endif
                int main (int argc, char **argv) { return 0; }
            """,
        )
        return flag if is_available else None

    def has_cpp20(self) -> bool:
        """Check C++20 availability on host"""
        return self.get_cpp20_flag() is not None

    def _has_x86_simd(self, *flags) -> bool:
        """Check x86 SIMD availability on host"""
        if self.ARCH not in ('X86_32', 'X86_64'):
            return False
        if not all(has_cpu_flag(flag) for flag in flags):
            return False
        if self.__compiler.compiler_type == "msvc":
            return True
        return check_compile_flags(self.__compiler, *(f"-m{flag}" for flag in flags))

    def has_sse2(self) -> bool:
        """Check SSE2 availability on host"""
        return self._has_x86_simd('sse2')

    def has_ssse3(self) -> bool:
        """Check SSSE3 availability on host"""
        return self._has_x86_simd('ssse3')

    def has_avx2(self) -> bool:
        """Check AVX2 availability on host"""
        return self._has_x86_simd('avx2')

    def has_avx512(self) -> bool:
        """Check AVX512 "F" and "BW" instruction sets availability on host"""
        return self._has_x86_simd('avx512f', 'avx512bw')

    def has_openmp(self) -> bool:
        """Check OpenMP availability on host"""
        if sys.platform == 'darwin':
            return False
        prefix = '/' if self.__compiler.compiler_type == 'msvc' else '-f'
        return check_compile_flags(self.__compiler, prefix + 'openmp')

    def has_native(self) -> bool:
        """Returns native build option availability on host"""
        if len(self.native_compile_args) > 0:
            return check_compile_flags(self.__compiler, *self.native_compile_args)
        return False


class BuildConfig:
    """Describe build configuration"""
    def __init__(self, config_file: Path, compiler=None):
        self.__config_file = config_file
        self.__host_config = HostConfig(compiler)
        self.embedded_filters = []

    @staticmethod
    def get_hdf5_library_dirs() -> list[str]:
        """Returns list of HDF5 library directories"""
        if sys.platform != 'win32':
            return []
        hdf5_dir = os.environ.get("HDF5PLUGIN_HDF5_DIR", "src/hdf5")
        return [f"{hdf5_dir}/lib"]

    @staticmethod
    def get_hdf5_include_dirs() -> list[str]:
        """Returns list of HDF5 include directories"""
        try:
            hdf5_dir = os.environ["HDF5PLUGIN_HDF5_DIR"]
        except KeyError:
            hdf5_dir = "src/hdf5"
        else:  # HDF5 directory define by environment variable
            return [f"{hdf5_dir}/include"]

        # Add folder containing H5pubconf.h
        if sys.platform == 'win32':
            folder = 'windows'
        elif sys.platform == 'darwin':
            folder = 'darwin'
        else:
            folder = 'linux'
        return [f"{hdf5_dir}/include", f"{hdf5_dir}/include/{folder}"]

    @property
    def filter_file_extension(self) -> str:
        """File extension to use for filter shared libraries"""
        return self.__host_config.get_shared_lib_extension()

    @property
    def compile_args(self) -> tuple[str, ...]:
        """Returns compile args to use"""
        compile_args = []
        if self.use_sse2:
            compile_args.extend(self.__host_config.sse2_compile_args)
        if self.use_ssse3:
            compile_args.extend(self.__host_config.ssse3_compile_args)
        if self.use_avx2:
            compile_args.extend(self.__host_config.avx2_compile_args)
        if self.use_avx512:
            compile_args.extend(self.__host_config.avx512_compile_args)
        if self.use_native:
            compile_args.extend(self.__host_config.native_compile_args)
        return tuple(compile_args)

    @property
    def cpp20_compile_arg(self) -> str | None:
        """Returns C++20 compilation flag or None if not supported"""
        return self.__host_config.get_cpp20_flag()

    @lru_cache(maxsize=None)
    def _is_enabled(self, feature: str) -> bool:
        """Returns True if given compilation feature is enabled.

        It first checks if the corresponding HDF5PLUGIN_* environment variable is set.
        If it is not set, it checks if both the compiler and the host support the feature.
        """
        assert feature in ("cpp11", "cpp14", "cpp20", "sse2", "ssse3", "avx2", "avx512", "openmp", "native")
        try:
            return os.environ[f"HDF5PLUGIN_{feature.upper()}"] == "True"
        except KeyError:
            pass
        check = getattr(self.__host_config, f"has_{feature.lower()}")
        return check()

    use_cpp11 = property(lambda self: self._is_enabled('cpp11'))
    use_cpp14 = property(lambda self: self._is_enabled('cpp14'))
    use_cpp20 = property(lambda self: self._is_enabled('cpp20'))
    use_sse2 = property(lambda self: self._is_enabled('sse2'))
    use_openmp = property(lambda self: self._is_enabled('openmp'))
    use_native = property(lambda self: self._is_enabled('native'))

    @cached_property
    def use_ssse3(self) -> bool:
        enabled = self._is_enabled('ssse3')
        if enabled and not self.use_sse2:
            logger.error("use_ssse3=True disabled: incompatible with use_sse2=False")
            return False
        return enabled

    @cached_property
    def use_avx2(self) -> bool:
        enabled = self._is_enabled('avx2')
        if enabled and not (self.use_sse2 and self.use_ssse3):
            logger.error(
                "use_avx2=True disabled: incompatible with use_sse2=False and use_ssse3=False")
            return False
        return enabled

    @cached_property
    def use_avx512(self) -> bool:
        enabled = self._is_enabled('avx512')
        if enabled and not (self.use_sse2 and self.use_ssse3 and self.use_avx2):
            logger.error(
                "use_avx512=True disabled: incompatible with use_sse2=False, use_ssse3=False and use_avx2=False")
            return False
        return enabled

    USE_BMI2 = bool(
        os.environ.get("HDF5PLUGIN_BMI2", 'True') == 'True'
        and sys.platform in ('linux', 'darwin')
    )
    """Whether to build with BMI2 instruction set or not (bool)"""

    INTEL_IPP_DIR = os.environ.get("HDF5PLUGIN_INTEL_IPP_DIR", None)
    """Root directory of Intel IPP or None to disable"""

    def get_config_string(self) -> str:
        build_config = {
            'openmp': self.use_openmp,
            'native': self.use_native,
            'bmi2': self.USE_BMI2,
            'sse2': self.use_sse2,
            'ssse3': self.use_ssse3,
            'avx2': self.use_avx2,
            'avx512': self.use_avx512,
            'cpp11': self.use_cpp11,
            'cpp14': self.use_cpp14,
            'cpp20': self.use_cpp20,
            'ipp': self.INTEL_IPP_DIR is not None,
            'filter_file_extension': self.filter_file_extension,
            'embedded_filters': tuple(sorted(set(self.embedded_filters))),
        }
        return f"""from collections import namedtuple

HDF5PluginBuildConfig = namedtuple('HDF5PluginBuildConfig', {tuple(build_config.keys())})
build_config = HDF5PluginBuildConfig(**{build_config})
"""

    def has_config_changed(self) -> bool:
        """Returns whether config file needs to be changed or not."""
        try:
            return self.__config_file.read_text() != self.get_config_string()
        except:  # noqa
            pass
        return True

    def save_config(self) -> None:
        """Save config as a dict in a python file"""
        self.__config_file.write_text(self.get_config_string())


# Plugins

class Build(build):
    """Build command with extra options used by PluginBuildExt"""

    def finalize_options(self):
        build.finalize_options(self)
        self.hdf5plugin_config = BuildConfig(
            config_file=Path(self.build_lib) / "hdf5plugin" / "_config.py",
            compiler=self.compiler,
        )

        if not self.hdf5plugin_config.use_cpp11:
            # Filter out C++11 libraries
            self.distribution.libraries = [
                (name, info) for name, info in self.distribution.libraries
                if '-std=c++11' not in info.get('cflags', [])]

            # Filter out C++11-only extensions
            self.distribution.ext_modules = [
                ext for ext in self.distribution.ext_modules
                if not (isinstance(ext, HDF5PluginExtension) and ext.cpp11_required)]

        if not self.hdf5plugin_config.use_cpp14:
            # Filter out C++14 libraries
            self.distribution.libraries = [
                (name, info) for name, info in self.distribution.libraries
                if '-std=c++14' not in info.get('cflags', [])
            ]

            # Filter out C++14-only extensions
            self.distribution.ext_modules = [
                ext for ext in self.distribution.ext_modules
                if '-std=c++14' not in ext.extra_compile_args
                and not (isinstance(ext, HDF5PluginExtension) and ext.cpp14_required)
            ]

        if not self.hdf5plugin_config.use_cpp20:
            cpp20_flags = set(["/std:c++20", "-std=c++20"])

            # Filter out C++20 libraries
            self.distribution.libraries = [
                (name, info) for name, info in self.distribution.libraries
                if cpp20_flags.isdisjoint(info.get('cflags', []))
            ]

            # Filter out C++20-only extensions
            self.distribution.ext_modules = [
                ext for ext in self.distribution.ext_modules
                if not (isinstance(ext, HDF5PluginExtension) and ext.cpp20_required)]

        self.hdf5plugin_config.embedded_filters = [
            ext.hdf5_plugin_name for ext in self.distribution.ext_modules
            if isinstance(ext, HDF5PluginExtension)
        ]

        logger.info("Build configuration: %s", self.hdf5plugin_config.get_config_string())

    def has_config_changed(self):
        """Check if configuration file has changed"""
        if not self.hdf5plugin_config.has_config_changed():
            logger.info("Build configuration didn't changed")
            return False

        logger.info('Build configuration has changed')
        clean_cmd = self.distribution.get_command_obj('clean')
        clean_cmd.all = True
        return True

    # Add clean to sub-commands
    sub_commands = [('clean', has_config_changed)] + build.sub_commands


class BuildPy(build_py):
    """build_py command also writing hdf5plugin._config"""
    def run(self):
        super().run()
        build_cmd = self.distribution.get_command_obj("build")
        build_cmd.hdf5plugin_config.save_config()


class BuildCLib(build_clib):
    """build_clib command adding/patching compile args"""
    def build_libraries(self, libraries):
        updated_libraries = []
        for (lib_name, build_info) in libraries:
            config = self.distribution.get_command_obj("build").hdf5plugin_config

            cflags = list(build_info.get('cflags', []))

            # Add flags from build config
            cflags.extend(config.compile_args)

            if not config.use_openmp:  # Remove OpenMP flags
                cflags = [f for f in cflags if not f.endswith('openmp')]

            prefix = '/' if self.compiler.compiler_type == 'msvc' else '-'
            cflags = [
                f for f in cflags if f.startswith(prefix)
            ]

            # Patch C++20 flag for older gcc/clang support
            if '-std=c++20' in cflags:
                if config.cpp20_compile_arg is None:
                    raise RuntimeError("Cannot compile C++20 code with current compiler")
                cflags = [f if f != '-std=c++20' else config.cpp20_compile_arg for f in cflags]

            build_info['cflags'] = cflags
            updated_libraries.append((lib_name, build_info))

        super().build_libraries(updated_libraries)


class PluginBuildExt(build_ext):
    """Build extension command for DLLs that are not Python modules

    It also handles extra compile arguments depending on the build options.
    """

    def get_export_symbols(self, ext):
        """Overridden to remove PyInit_* export"""
        return ext.export_symbols

    def get_ext_filename(self, ext_name):
        """Overridden to use .dll as file extension"""
        config = self.distribution.get_command_obj("build").hdf5plugin_config
        return os.path.join(*ext_name.split('.')) + config.filter_file_extension

    def build_extensions(self):
        """Overridden to tune extensions.

        - check for OpenMP, SSE2, AVX2 availability
        - select compile args for MSVC and others
        - Set hdf5 directory
        """
        config = self.distribution.get_command_obj("build").hdf5plugin_config

        for e in self.extensions:
            if isinstance(e, HDF5PluginExtension):
                e.extra_compile_args.extend(config.compile_args)

                if config.use_cpp11:
                    for name, value in e.cpp11.items():
                        attribute = getattr(e, name)
                        attribute += value
                if config.use_sse2:
                    for name, value in e.sse2.items():
                        attribute = getattr(e, name)
                        attribute += value
                if config.use_avx2:
                    for name, value in e.avx2.items():
                        attribute = getattr(e, name)
                        attribute += value

            if not config.use_openmp:  # Remove OpenMP flags
                e.extra_compile_args = [
                    arg for arg in e.extra_compile_args if not arg.endswith('openmp')]
                e.extra_link_args = [
                    arg for arg in e.extra_link_args if not arg.endswith('openmp')]

            # Remove flags that do not correspond to compiler
            prefix = '/' if self.compiler.compiler_type == 'msvc' else '-'
            e.extra_compile_args = [
                arg for arg in e.extra_compile_args if arg.startswith(prefix)]
            e.extra_link_args = [
                arg for arg in e.extra_link_args if arg.startswith(prefix)]

        build_ext.build_extensions(self)


class HDF5PluginExtension(Extension):
    """Extension adding specific things to build a HDF5 plugin"""

    def __init__(
            self,
            name,
            sse2=None,
            avx2=None,
            cpp11=None,
            cpp11_required=False,
            cpp14_required=False,
            cpp20_required=False,
            **kwargs
    ):
        Extension.__init__(self, name, **kwargs)

        if not self.depends:
            self.depends = list(itertools.chain.from_iterable(
                glob(f"{self.include_dirs}/*.h")))
            self.depends += list(itertools.chain.from_iterable(
                glob(f"{self.include_dirs}/*.hpp")))

        self.export_symbols.append('H5PLget_plugin_info')
        if not sys.platform == 'win32':
            self.export_symbols.append('init_filter')

        if sys.platform == 'win32':
            self.define_macros.append(('H5_BUILT_AS_DYNAMIC_LIB', None))
            self.libraries.append('hdf5')

        self.define_macros.append(('H5_USE_18_API', None))

        # Add HDF5 library directories
        self.include_dirs = BuildConfig.get_hdf5_include_dirs() + self.include_dirs
        self.library_dirs = BuildConfig.get_hdf5_library_dirs() + self.library_dirs

        self.sse2 = sse2 if sse2 is not None else {}
        self.avx2 = avx2 if avx2 is not None else {}
        self.cpp11 = cpp11 if cpp11 is not None else {}
        self.cpp11_required = cpp11_required
        self.cpp14_required = cpp14_required
        self.cpp20_required = cpp20_required

    @property
    def hdf5_plugin_name(self):
        """Return HDF5 plugin short name"""
        module_name = self.name.split('.')[-1]
        assert module_name.startswith('libh5')
        return module_name[5:]  # Strip libh5


def prefix(directory, files):
    """Add a directory as prefix to a list of files.

    :param str directory: Directory to add as prefix
    :param List[str] files: List of relative file path
    :rtype: List[str]
    """
    return ['/'.join((directory, f)) for f in files]


PLUGIN_LIB_DEPENDENCIES = dict()
"""Mapping plugin name to library name they depend on"""


# compression libs


def _get_bz2_clib(field=None):
    """BZip2 static lib build config"""
    bzip2_dir = "src/bzip2"

    config = dict(
        sources=prefix(bzip2_dir, [
            "blocksort.c",
            "huffman.c",
            "crctable.c",
            "randtable.c",
            "compress.c",
            "decompress.c",
            "bzlib.c",
        ]),
        include_dirs=[bzip2_dir],
        macros=[],
        cflags=[
            "-Wall",
            "-Winline",
            "-O2",
            "-g",
            "-D_FILE_OFFSET_BITS=64"
        ],
    )

    if field is None:
        return config
    if field in ('extra_link_args', 'libraries'):
        return []
    return config[field]


def _get_charls_clib(field=None):
    """CharLS static lib build config"""
    charls_dir = "src/charls/src"

    config = dict(
        sources=glob(f'{charls_dir}/*.cpp'),
        include_dirs=["src/charls/include", "src/charls/include/charls", charls_dir],
        macros=[("CHARLS_STATIC", 1), ("CHARLS_LIBRARY_BUILD", 1)],
        cflags=['-std=c++14'],
    )

    if field is None:
        return config
    if field in ('extra_link_args', 'libraries'):
        return []
    return config[field]


# Define compilation arguments for Intel IPP
INTEL_IPP_INCLUDE_DIRS = []  # Intel IPP include directories
INTEL_IPP_EXTRA_LINK_ARGS = []  # Intel IPP extra link arguments
INTEL_IPP_LIBRARIES = []  # Intel IPP libraries to link
if BuildConfig.INTEL_IPP_DIR is not None:
    INTEL_IPP_INCLUDE_DIRS.append(f'{BuildConfig.INTEL_IPP_DIR}/include')
    arch = 'ia32' if HostConfig.ARCH == 'X86_32' else 'intel64'
    ipp_lib_dir = f'{BuildConfig.INTEL_IPP_DIR}/lib/{arch}'
    if not os.path.isdir(ipp_lib_dir):  # Happens on macos as only intel64 is available
        ipp_lib_dir = f'{BuildConfig.INTEL_IPP_DIR}/lib'
    INTEL_IPP_EXTRA_LINK_ARGS.append(f'-L{ipp_lib_dir}')
    INTEL_IPP_EXTRA_LINK_ARGS.append(f'/LIBPATH:{ipp_lib_dir}')
    INTEL_IPP_LIBRARIES.extend(['ippdc', 'ipps', 'ippvm', 'ippcore'])


def _get_lz4_ipp_clib(field=None):
    """LZ4 static lib using Intel IPP build config"""
    assert BuildConfig.INTEL_IPP_DIR is not None

    cflags = ['-O3', '-ffast-math', '-std=gnu99']
    cflags += ['/Ox', '/fp:fast']

    lz4_dir = 'src/lz4_ipp'

    config = dict(
        sources=glob(f'{lz4_dir}/*.c'),
        include_dirs=[lz4_dir] + INTEL_IPP_INCLUDE_DIRS,
        macros=[('WITH_IPP', 1)],
        cflags=cflags,
    )

    if field is None:
        return config
    if field == 'extra_link_args':
        return INTEL_IPP_EXTRA_LINK_ARGS
    if field == 'libraries':
        # Adding LZ4 here for it to be placed before IPP libs for gcc
        return ['lz4'] + INTEL_IPP_LIBRARIES
    return config[field]


def _get_lz4_clib(field=None):
    """LZ4 static lib build config

    If HDFPLUGIN_IPP_DIR is set, it will use a patched LZ4 library to use Intel IPP.
    """
    if BuildConfig.INTEL_IPP_DIR is not None:
        return _get_lz4_ipp_clib(field)

    cflags = ['-O3', '-ffast-math', '-std=gnu99']
    cflags += ['/Ox', '/fp:fast']

    folders = glob('src/c-blosc2/internal-complibs/lz4*')
    lz4_dir = folders[0] if folders else "src/no-folder"

    config = dict(
        sources=glob(f'{lz4_dir}/*.c'),
        include_dirs=[lz4_dir],
        macros=[],
        cflags=cflags,
    )

    if field is None:
        return config
    if field in ('extra_link_args', 'libraries'):
        return []
    return config[field]


def _get_snappy_clib(field=None):
    """snappy static lib build config"""
    snappy_dir = 'src/snappy'

    config = dict(
        sources=prefix(snappy_dir, [
            'snappy-c.cc',
            'snappy-sinksource.cc',
            'snappy-stubs-internal.cc',
            'snappy.cc',
        ]),
        include_dirs=[snappy_dir],
        macros=[],
        cflags=['-std=c++11'],
    )

    if field is None:
        return config
    if field in ('extra_link_args', 'libraries'):
        return []
    return config[field]


def _get_sperr_clib(field=None):
    """sperr static lib and sperr filter C++20 source file build config"""
    sperr_dir = "src/SPERR"

    config = dict(
        sources=glob(f"{sperr_dir}/src/*.cpp"),
        include_dirs=[f"{sperr_dir}/include"],
        macros=[
            ("SPERR_VERSION_MAJOR", 0),  # Check project(SPERR VERSION ... in src/SPERR/CMakeLists.txt
            ("USE_VANILLA_CONFIG", 1),
        ],
        cflags=["-std=c++20", "/std:c++20"],
    )

    if field is None:
        return config
    if field in ('extra_link_args', 'libraries'):
        return []
    return config[field]


def _get_sperr_filter_clib(field=None):
    """sperr filter C++20 source file build config"""
    h5z_sperr_dir = "src/H5Z-SPERR"

    config = dict(
        sources=[f"{h5z_sperr_dir}/src/h5zsperr_helper.cpp"],
        include_dirs=BuildConfig.get_hdf5_include_dirs() + ["src/SPERR/include", f"{h5z_sperr_dir}/include"],
        macros=[],
        cflags=["-std=c++20", "/std:c++20"],
    )

    if sys.platform == 'win32':
        # h5zsperr_helper.cpp is part of the plugin
        config["macros"].append(('H5_BUILT_AS_DYNAMIC_LIB', None))

    if field is None:
        return config
    raise RuntimeError("SPERR filter C++ source lib config is not expected to be used this way")


def _get_zfp_clib(field=None):
    """ZFP static lib build config"""
    cflags = ['-O3', '-ffast-math', '-std=c99', '-fopenmp']
    # Use /Ob1 to fix ZFP test failing with Visual Studio 2022: MSVC 14.40.33807
    # See https://github.com/LLNL/zfp/issues/222
    cflags += ['/Ob1', '/fp:fast', '/openmp']

    zfp_dir = "src/zfp"

    config = dict(
        sources=glob(f'{zfp_dir}/src/*.c'),
        include_dirs=[f'{zfp_dir}/include'],
        macros=[('BIT_STREAM_WORD_TYPE', 'uint8')],
        cflags=cflags,
    )

    if field is None:
        return config
    if field == 'extra_link_args':
        return ['-fopenmp']
    if field == 'libraries':
        return []
    return config[field]


def _get_zlib_clib(field=None):
    """ZLib static lib build config"""
    cflags = ['-O3', '-ffast-math', '-std=gnu99']
    cflags += ['/Ox', '/fp:fast']

    folders = glob('src/c-blosc/internal-complibs/zlib*')
    zlib_dir = folders[0] if folders else "src/no-folder"

    config = dict(
        sources=glob(f'{zlib_dir}/*.c'),
        include_dirs=[zlib_dir],
        macros=[],
        cflags=cflags,
    )

    if field is None:
        return config
    if field in ('extra_link_args', 'libraries'):
        return []
    return config[field]


def _get_zstd_clib(field=None):
    """zstd static lib build config"""
    cflags = ['-O3', '-ffast-math', '-std=gnu99']
    cflags += ['/Ox', '/fp:fast']

    folders = glob('src/c-blosc2/internal-complibs/zstd*')
    zstd_dir = folders[0] if folders else "src/no-folder"

    config = dict(
        sources=glob(f'{zstd_dir}/*/*.c'),
        include_dirs=[zstd_dir, f'{zstd_dir}/common'],
        macros=[] if BuildConfig.USE_BMI2 else [('ZSTD_DISABLE_ASM', 1)],
        cflags=cflags,
    )

    if field == 'extra_objects':
        return glob(f'{zstd_dir}/*/*.S') if BuildConfig.USE_BMI2 else []

    if field is None:
        return config
    if field in ('extra_link_args', 'libraries'):
        return []
    return config[field]


_EMBEDDED_CLIB_CONFIG_GETTERS = {
    "bz2": _get_bz2_clib,
    "charls": _get_charls_clib,
    "lz4": _get_lz4_clib,
    "snappy": _get_snappy_clib,
    "sperr": _get_sperr_clib,
    "sperr_filter": _get_sperr_filter_clib,
    "zfp": _get_zfp_clib,
    "zlib": _get_zlib_clib,
    "zstd": _get_zstd_clib,
}
_CLIB_NAMES = {"blosc", "blosc2"} | set(_EMBEDDED_CLIB_CONFIG_GETTERS.keys()) - {"sperr_filter"}


@lru_cache()
def get_system_clib_names():
    """Returns the set of clib names that should not be embedded"""
    system_clibs = set(
        name.strip().lower()
        for name in os.environ.get('HDF5PLUGIN_SYSTEM_LIBRARIES', '').split(',')
        if name.strip()
    )
    if not system_clibs <= _CLIB_NAMES:
        raise RuntimeError(f"Unexpected names in HDF5PLUGIN_SYSTEM_LIBRARIES: {system_clibs - _CLIB_NAMES}")
    return system_clibs


@lru_cache()
def _get_clib_config_from_pkgconfig(libname):
    if pkgconfig is None:
        raise RuntimeError("pkgconfig is required to build against system libraries")
    if not pkgconfig.exists(libname):
        if pkgconfig.exists(f"lib{libname}"):
            libname = f"lib{libname}"
        else:
            raise RuntimeError(f"pkgconfig: (lib){libname} not found")

    include_dir = pkgconfig.variables(libname).get('includedir', None)

    return {
        'include_dirs': [include_dir] if include_dir is not None else [],
        'extra_link_args': pkgconfig.libs(libname).split(" "),
        'libraries': [],
        'macros': [],
        'extra_objects': [],
    }


def get_clib_config(libname, field=None):
    """Returns the configuration or one of it's field for the given clib"""
    if libname in get_system_clib_names():
        return _get_clib_config_from_pkgconfig(libname)[field]

    get_embedded_config = _EMBEDDED_CLIB_CONFIG_GETTERS[libname]
    return get_embedded_config(field)


# compression filter plugins


def _get_blosc_plugin():
    """blosc plugin build config

    Plugin from https://github.com/Blosc/hdf5-blosc
    c-blosc from https://github.com/Blosc/c-blosc
    """
    hdf5_blosc_dir = 'src/hdf5-blosc/src'
    hdf5_blosc_sources = prefix(hdf5_blosc_dir, ['blosc_filter.c', 'blosc_plugin.c'])

    extra_compile_args = ['-std=gnu99']  # Needed to build manylinux1 wheels
    extra_compile_args += ['-O3', '-ffast-math']
    extra_compile_args += ['/Ox', '/fp:fast']
    extra_compile_args += ['-pthread']
    extra_link_args = ['-pthread']

    if "blosc" in get_system_clib_names():
        return HDF5PluginExtension(
            "hdf5plugin.plugins.libh5blosc",
            sources=hdf5_blosc_sources,
            include_dirs=get_clib_config("blosc", "include_dirs") + [hdf5_blosc_dir],
            extra_compile_args=extra_compile_args,
            extra_link_args=get_clib_config("blosc", "extra_link_args") + extra_link_args,
            libraries=get_clib_config("blosc", "libraries"),
        )

    blosc_dir = 'src/c-blosc/blosc'

    # blosc sources
    sources = glob(f'{blosc_dir}/*.c')
    include_dirs = ['src/c-blosc', blosc_dir]
    define_macros = []
    libraries = []

    # compression libs
    # lz4
    include_dirs += get_clib_config('lz4', 'include_dirs')
    extra_link_args += get_clib_config('lz4', 'extra_link_args')
    libraries += get_clib_config('lz4', 'libraries')
    define_macros.append(('HAVE_LZ4', 1))
    # snappy
    cpp11_kwargs = {
        'include_dirs': get_clib_config('snappy', 'include_dirs'),
        'extra_link_args': ['-lstdc++'],
        'define_macros': [('HAVE_SNAPPY', 1)],
    }
    # zlib
    include_dirs += get_clib_config('zlib', 'include_dirs')
    extra_link_args += get_clib_config('zlib', 'extra_link_args')
    libraries += get_clib_config('zlib', 'libraries')
    define_macros.append(('HAVE_ZLIB', 1))
    # zstd
    include_dirs += get_clib_config('zstd', 'include_dirs')
    extra_link_args += get_clib_config('zstd', 'extra_link_args')
    libraries += get_clib_config('zstd', 'libraries')
    define_macros.append(('HAVE_ZSTD', 1))

    return HDF5PluginExtension(
        "hdf5plugin.plugins.libh5blosc",
        sources=sources + hdf5_blosc_sources,
        extra_objects=get_clib_config('zstd', 'extra_objects'),
        include_dirs=include_dirs + [hdf5_blosc_dir],
        define_macros=define_macros,
        extra_compile_args=extra_compile_args,
        extra_link_args=extra_link_args,
        libraries=libraries,
        sse2={'define_macros': [('SHUFFLE_SSE2_ENABLED', 1)]},
        avx2={'define_macros': [('SHUFFLE_AVX2_ENABLED', 1)]},
        cpp11=cpp11_kwargs,
)


if 'blosc' in get_system_clib_names():
    PLUGIN_LIB_DEPENDENCIES['blosc'] = ()
else:
    PLUGIN_LIB_DEPENDENCIES['blosc'] = 'snappy', 'lz4', 'zlib', 'zstd'


def _get_blosc2_plugin():
    """blosc2 plugin build config

    Source from PyTables and c-blosc2
    """
    hdf5_blosc2_dir = 'src/PyTables/hdf5-blosc2/src'
    hdf5_blosc2_sources = prefix(hdf5_blosc2_dir, ['blosc2_filter.c', 'blosc2_plugin.c'])

    extra_compile_args = ['-O3', '-std=gnu99']
    extra_compile_args += ['/Ox']
    extra_compile_args += ['-pthread']
    extra_link_args = ['-pthread']

    if "blosc2" in get_system_clib_names():
        return HDF5PluginExtension(
            "hdf5plugin.plugins.libh5blosc2",
            sources=hdf5_blosc2_sources,
            include_dirs=get_clib_config("blosc2", "include_dirs") + [hdf5_blosc2_dir],
            extra_compile_args=extra_compile_args,
            extra_link_args=get_clib_config("blosc2", "extra_link_args") + extra_link_args,
            libraries=get_clib_config("blosc2", "libraries"),
        )

    # blosc sources
    blosc2_dir = 'src/c-blosc2'
    plugins_dir = f'{blosc2_dir}/plugins'

    sources = glob(f'{blosc2_dir}/blosc/*.c')
    sources += [  # Add embedded codecs, filters and tuners
        src_file
        for src_file in glob(f'{plugins_dir}/*.c') + glob(f'{plugins_dir}/*/*.c') + glob(f'{plugins_dir}/*/*/*.c')
        if not os.path.basename(src_file).startswith("test")
    ]
    sources += glob(f'{plugins_dir}/codecs/zfp/src/*.c')  # Add ZFP embedded sources
    include_dirs = [
        blosc2_dir,
        f'{blosc2_dir}/blosc',
        f'{blosc2_dir}/include',
        f'{blosc2_dir}/plugins/codecs/zfp/include',
    ]
    define_macros = [('HAVE_PLUGINS', 1)]
    if platform.machine() == 'ppc64le':
        define_macros.append(('SHUFFLE_ALTIVEC_ENABLED', 1))
        define_macros.append(('NO_WARN_X86_INTRINSICS', None))
    else:
        define_macros.append(('SHUFFLE_SSE2_ENABLED', 1))
        define_macros.append(('SHUFFLE_AVX2_ENABLED', 1))
        define_macros.append(('SHUFFLE_AVX512_ENABLED', 1))
        define_macros.append(('SHUFFLE_NEON_ENABLED', 1))

    libraries = []

    if HostConfig.ARCH == 'ARM_8':
        extra_compile_args += ['-flax-vector-conversions']
    if HostConfig.ARCH == 'ARM_7':
        extra_compile_args += ['-mfpu=neon', '-flax-vector-conversions']
    # compression libs
    # lz4
    include_dirs += get_clib_config('lz4', 'include_dirs')
    if BuildConfig.INTEL_IPP_DIR is None:
        extra_link_args += get_clib_config('lz4', 'extra_link_args')
        libraries += get_clib_config('lz4', 'libraries')
    else:
        include_dirs += INTEL_IPP_INCLUDE_DIRS
        extra_link_args += INTEL_IPP_EXTRA_LINK_ARGS
        libraries += INTEL_IPP_LIBRARIES
        define_macros.append(('HAVE_IPP', 1))
    # zlib
    include_dirs += get_clib_config('zlib', 'include_dirs')
    extra_link_args += get_clib_config('zlib', 'extra_link_args')
    libraries += get_clib_config('zlib', 'libraries')
    define_macros.append(('HAVE_ZLIB', 1))
    # zstd
    include_dirs += get_clib_config('zstd', 'include_dirs')
    extra_link_args += get_clib_config('zstd', 'extra_link_args')
    libraries += get_clib_config('zstd', 'libraries')
    define_macros.append(('HAVE_ZSTD', 1))

    return HDF5PluginExtension(
        "hdf5plugin.plugins.libh5blosc2",
        sources=sources + hdf5_blosc2_sources,
        extra_objects=get_clib_config('zstd', 'extra_objects'),
        include_dirs=include_dirs + [hdf5_blosc2_dir],
        define_macros=define_macros,
        extra_compile_args=extra_compile_args,
        extra_link_args=extra_link_args,
        libraries=libraries,
        sse2={'define_macros': [('SHUFFLE_SSE2_ENABLED', 1)]},
        avx2={'define_macros': [('SHUFFLE_AVX2_ENABLED', 1)]},
    )


if 'blosc2' in get_system_clib_names():
    PLUGIN_LIB_DEPENDENCIES['blosc2'] = ()
else:
    PLUGIN_LIB_DEPENDENCIES['blosc2'] = 'lz4', 'zlib', 'zstd'


def _get_zstandard_plugin():
    """HDF5Plugin-Zstandard plugin build config"""
    zstandard_dir = 'src/HDF5Plugin-Zstandard'

    return HDF5PluginExtension(
        "hdf5plugin.plugins.libh5zstd",
        sources=[f'{zstandard_dir}/zstd_h5plugin.c'],
        extra_objects=get_clib_config('zstd', 'extra_objects'),
        include_dirs=[zstandard_dir] + get_clib_config('zstd', 'include_dirs'),
        extra_link_args=get_clib_config('zstd', 'extra_link_args'),
        libraries=get_clib_config('zstd', 'libraries'),
    )


PLUGIN_LIB_DEPENDENCIES['zstd'] = ('zstd',)


def _get_bitshuffle_plugin():
    """bitshuffle (+lz4 or zstd) plugin build config

    Plugins from https://github.com/kiyo-masui/bitshuffle
    """
    bithsuffle_dir = 'src/bitshuffle/src'

    extra_compile_args = ['-O3', '-ffast-math', '-std=c99', '-fopenmp']
    extra_compile_args += ['/Ox', '/fp:fast', '/openmp']
    extra_link_args = ['-fopenmp']

    define_macros = [("ZSTD_SUPPORT", 1)]
    if platform.machine() == 'ppc64le':
        define_macros.append(('NO_WARN_X86_INTRINSICS', None))  # P9 way to enable SSE2

    return HDF5PluginExtension(
        "hdf5plugin.plugins.libh5bshuf",
        sources=prefix(bithsuffle_dir, [
            "bshuf_h5plugin.c",
            "bshuf_h5filter.c",
            "bitshuffle.c",
            "bitshuffle_core.c",
            "iochain.c",
        ]),
        extra_objects=get_clib_config('zstd', 'extra_objects'),
        include_dirs=[bithsuffle_dir] + get_clib_config('lz4', 'include_dirs') + get_clib_config('zstd', 'include_dirs'),
        define_macros=define_macros,
        extra_compile_args=extra_compile_args,
        extra_link_args=extra_link_args + get_clib_config('lz4', 'extra_link_args') + get_clib_config('zstd', 'extra_link_args'),
        libraries=get_clib_config('lz4', 'libraries') + get_clib_config('zstd', 'libraries'),
    )


PLUGIN_LIB_DEPENDENCIES['bshuf'] = ('lz4', 'zstd')


def _get_lz4_plugin():
    """lz4 plugin build config

    Source from https://github.com/nexusformat/HDF5-External-Filter-Plugins
    """
    if sys.platform == 'darwin':
        extra_compile_args = ['-Wno-error=implicit-function-declaration']
    else:
        extra_compile_args = []

    libraries = ['Ws2_32'] if sys.platform == 'win32' else []
    libraries.extend(get_clib_config('lz4', 'libraries'))

    return HDF5PluginExtension(
        "hdf5plugin.plugins.libh5lz4",
        sources=['src/LZ4/H5Zlz4.c', 'src/LZ4/lz4_h5plugin.c'],
        include_dirs=get_clib_config('lz4', 'include_dirs'),
        extra_compile_args=extra_compile_args,
        extra_link_args=get_clib_config('lz4', 'extra_link_args'),
        libraries=libraries,
    )


PLUGIN_LIB_DEPENDENCIES['lz4'] = ('lz4',)


def _get_bzip2_plugin():
    """BZip2 plugin build config"""
    return HDF5PluginExtension(
        "hdf5plugin.plugins.libh5bzip2",
        sources=['src/PyTables/src/H5Zbzip2.c', 'src/H5Zbzip2_plugin.c'],
        include_dirs=['src/PyTables/src/'] + get_clib_config('bz2', 'include_dirs'),
        define_macros=[('HAVE_BZ2_LIB', 1)],
        extra_compile_args=[],
        extra_link_args=get_clib_config('bz2', 'extra_link_args'),
        libraries=get_clib_config('bz2', 'libraries'),
    )


PLUGIN_LIB_DEPENDENCIES['bzip2'] = ('bz2',)


def _get_fcidecomp_plugin():
    """FCIDECOMP plugin build config"""
    fcidecomp_dir = 'src/fcidecomp/src/fcidecomp'

    extra_compile_args = ['-O3', '-ffast-math', '-std=c99', '-fopenmp']
    extra_compile_args += ['/Ox', '/fp:fast', '/openmp']
    extra_link_args = ['-lstdc++', '-fopenmp']

    macros = [('LOGGING', 1)]
    if 'charls' not in get_system_clib_names():
        macros.append(('CHARLS_STATIC', 1))

    charls_include_dirs = get_clib_config('charls', 'include_dirs')
    # fcidecomp includes "charls.h" instead of "charls/charls.h"
    charls_include_dirs += [os.path.join(d, "charls") for d in get_clib_config('charls', 'include_dirs')]

    return HDF5PluginExtension(
        "hdf5plugin.plugins.libh5fcidecomp",
        sources=glob(f"{fcidecomp_dir}/fcicomp-*/src/*.c"),
        include_dirs=glob(f"{fcidecomp_dir}/fcicomp-*/include") + charls_include_dirs,
        extra_compile_args=extra_compile_args,
        extra_link_args=extra_link_args + get_clib_config('charls', 'extra_link_args'),
        libraries=get_clib_config('charls', 'libraries'),
        cpp14_required=True,
        define_macros=macros,
    )


PLUGIN_LIB_DEPENDENCIES['fcidecomp'] = ('charls',)


def _get_h5zfp_plugin():
    """H5Z-ZFP plugin build config"""
    h5zfp_dir = 'src/H5Z-ZFP/src'

    extra_compile_args = ['-O3', '-ffast-math', '-std=c99']
    extra_compile_args += ['/Ox', '/fp:fast']

    return HDF5PluginExtension(
        "hdf5plugin.plugins.libh5zfp",
        sources=glob(f"{h5zfp_dir}/*.c"),
        include_dirs=[f"{h5zfp_dir}/src"] + get_clib_config('zfp', 'include_dirs'),
        extra_compile_args=extra_compile_args,
        extra_link_args=get_clib_config('zfp', 'extra_link_args'),
        libraries=get_clib_config('zfp', 'libraries'),
    )


PLUGIN_LIB_DEPENDENCIES['zfp'] = ('zfp',)


def _get_sz_plugin():
    """SZ library and its hdf5 filter plugin build config"""
    sz_dir = "src/SZ/sz"
    h5zsz_dir = "src/SZ/hdf5-filter/H5Z-SZ"

    extra_compile_args = ['-O3', '-std=c99', '-fopenmp']
    extra_compile_args += ['/Ox', '/openmp']

    extra_link_args = ['-fopenmp', "-lm"]
    extra_link_args += get_clib_config('zlib', 'extra_link_args')
    extra_link_args += get_clib_config('zstd', 'extra_link_args')

    include_dirs = [f'{h5zsz_dir}/include']
    include_dirs += [sz_dir, f"{sz_dir}/include"]
    include_dirs += glob('src/SZ_extra/')
    include_dirs += get_clib_config('zlib', 'include_dirs')
    include_dirs += get_clib_config('zstd', 'include_dirs')

    return HDF5PluginExtension(
        "hdf5plugin.plugins.libh5sz",
        sources=glob(f"{h5zsz_dir}/src/*.c") + glob(f"{sz_dir}/src/*.c"),
        include_dirs=include_dirs,
        extra_compile_args=extra_compile_args,
        extra_link_args=extra_link_args,
        libraries=get_clib_config('zlib', 'libraries') + get_clib_config('zstd', 'libraries'),
        extra_objects=get_clib_config('zstd', 'extra_objects'),
    )


PLUGIN_LIB_DEPENDENCIES['sz'] = ('zlib', 'zstd')


def _get_sz3_plugin():
    # SZ3 library and its hdf5 filter
    sz3_dir = "src/SZ3"
    h5z_sz3_dir = "src/SZ3/tools/H5Z-SZ3"

    include_dirs = [f"{sz3_dir}/include"]
    include_dirs += glob(f"{sz3_dir}/include/SZ3/*/")
    include_dirs += glob(f"{sz3_dir}/include/SZ3/utils/*/")
    # add version.hpp
    include_dirs.append("src/SZ3_extra")
    if sys.platform == 'darwin':
        # provide dummy omp.h
        include_dirs.append("src/SZ3_extra/darwin")
    include_dirs.append(f"{h5z_sz3_dir}/include")
    include_dirs += get_clib_config('zstd', 'include_dirs')

    extra_compile_args = ['-std=c++14', '-O3', '-ffast-math', '-fopenmp']
    extra_compile_args += ['/Ox', '/fp:fast', '/openmp']
    extra_link_args = ['-fopenmp', "-lm"]

    return HDF5PluginExtension(
        "hdf5plugin.plugins.libh5sz3",
        sources=[f"{h5z_sz3_dir}/src/H5Z_SZ3.cpp"],
        extra_objects=get_clib_config('zstd', 'extra_objects'),
        include_dirs=include_dirs,
        extra_compile_args=extra_compile_args,
        extra_link_args=extra_link_args + get_clib_config('zstd', 'extra_link_args'),
        libraries=get_clib_config('zstd', 'libraries'),
        cpp11_required=True,
    )


PLUGIN_LIB_DEPENDENCIES['sz3'] = ('zstd',)


def _get_sperr_plugin():
    h5z_sperr_dir = "src/H5Z-SPERR"

    return HDF5PluginExtension(
        "hdf5plugin.plugins.libh5sperr",
        sources=prefix(
            f"{h5z_sperr_dir}/src",
            [
                "h5z-sperr.c",
                "icecream.c",
                "compactor.c",
            ]
        ),
        include_dirs=get_clib_config("sperr", "include_dirs") + [f"{h5z_sperr_dir}/include"],
        extra_link_args=['-lstdc++'] + get_clib_config("sperr", "extra_link_args"),
        libraries=get_clib_config("sperr", "libraries"),
        define_macros=get_clib_config("sperr", "macros"),
        cpp20_required=True,
    )


PLUGIN_LIB_DEPENDENCIES['sperr'] = ("sperr", "sperr_filter")


_EMBEDDED_PLUGIN_EXTENSIONS = {
    "blosc": _get_blosc_plugin,
    "blosc2": _get_blosc2_plugin,
    "bshuf": _get_bitshuffle_plugin,
    "bzip2": _get_bzip2_plugin,
    "fcidecomp": _get_fcidecomp_plugin,
    "lz4": _get_lz4_plugin,
    "sperr": _get_sperr_plugin,
    "sz": _get_sz_plugin,
    "sz3": _get_sz3_plugin,
    "zfp": _get_h5zfp_plugin,
    "zstd": _get_zstandard_plugin,
}

PLUGIN_NAMES = set(_EMBEDDED_PLUGIN_EXTENSIONS.keys())


def get_libraries_and_extensions():
    """Returns lists of static libraries and extensions to build.

    Strip libraries and extensions according to HDF5PLUGIN_STRIP env. var.
    """
    stripped_filters = set(
        name.strip().lower()
        for name in os.environ.get('HDF5PLUGIN_STRIP', '').split(',')
        if name.strip()
    )

    if 'all' in stripped_filters:
        return [], []

    if not stripped_filters <= PLUGIN_NAMES:
        raise ValueError(f"Unexpected names in HDF5PLUGIN_STRIP: {stripped_filters - PLUGIN_NAMES}")

    # Filter out library that won't be used because of stripped filters
    lib_names = set(
        itertools.chain.from_iterable(
            lib_names for filter_name, lib_names in PLUGIN_LIB_DEPENDENCIES.items()
            if filter_name not in stripped_filters
        )
    )

    # Filter-out used system libraries
    # Add a prefix to library names to prevent the compiler to use the dynamic library if it exists
    libraries = [
        (f"hdf5plugin_static_clib_{name}", get_clib_config(name))
        for name in lib_names if name not in get_system_clib_names()
    ]

    # Create Python extensions
    embedded_extension_names = PLUGIN_NAMES - stripped_filters
    extensions = [_EMBEDDED_PLUGIN_EXTENSIONS[name]() for name in embedded_extension_names]

    if extensions and not sys.platform == 'win32':
        # Add hdf5 dynamic loading lib
        libraries.append(
            (
                'hdf5_dl',
                {
                    'sources': ['src/hdf5_dl.c'],
                    'include_dirs': BuildConfig.get_hdf5_include_dirs(),
                    'macros': [('H5_USE_18_API', None)],
                    'cflags': [],
                }
            )
        )

    return libraries, extensions


if __name__ == "__main__":
    libraries, extensions = get_libraries_and_extensions()
    setup(
        cmdclass=dict(
            bdist_wheel=BDistWheel,
            build=Build,
            build_clib=BuildCLib,
            build_ext=PluginBuildExt,
            build_py=BuildPy,
        ),
        ext_modules=extensions,
        libraries=libraries,
    )