<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">"""
Copyright 2019 Intel Corporation.

This software and the related documents are Intel copyrighted  materials,  and
your use of  them is  governed by the  express license  under which  they were
provided to you (License).  Unless the License provides otherwise, you may not
use, modify, copy, publish, distribute,  disclose or transmit this software or
the related documents without Intel's prior written permission.

This software and the related documents  are provided as  is,  with no express
or implied  warranties,  other  than those  that are  expressly stated  in the
License.

License:
http://software.intel.com/en-us/articles/intel-sample-source-code-license-agr
eement/
"""

import os
from enum import Enum

WINDOWS = 'Windows'
UNIX = 'Unix'
LINUX = 'Linux'
MACOSX = 'macOS'
ANDROID = 'Android'
TEMPORARY_FOLDER = './tmp'
MAIN_FILE = 'main.c'
INTEL64 = 'intel64'
IA32 = 'ia32'
PROJECT_EXTENSION = '.cltproj'
COMPILERS_AND_LIBRARIES_PATH = ''
ANDROID_NDK_PATH = ''
SINGLE_THREADED = 'Single-threaded'
MULTI_THREADED = 'Multi-threaded'
THREADING_LAYER = 'Threading layer'
HOST_SYSTEM = WINDOWS


class ThreadingLayerType(Enum):
    NONE = 1
    OPENMP = 2
    TBB = 3

# Positions:
# 0 - architecture
# 1 - OpenMP/TBB
LIBRARIES_LIST = {
    WINDOWS: {
        WINDOWS: {
            SINGLE_THREADED: [
                '{0}\\ippccmt.lib',
                '{0}\\ippchmt.lib',
                '{0}\\ippcvmt.lib',
                '{0}\\ippdcmt.lib',
                '{0}\\ippemt.lib',
                '{0}\\ippsmt.lib',
                '{0}\\ippimt.lib',
                '{0}\\ippcoremt.lib',
                '{0}\\ippvmmt.lib'
            ],
            MULTI_THREADED: [
                '{0}\\threaded\\ippccmt.lib',
                '{0}\\threaded\\ippchmt.lib',
                '{0}\\threaded\\ippcvmt.lib',
                '{0}\\threaded\\ippdcmt.lib',
                '{0}\\threaded\\ippemt.lib',
                '{0}\\threaded\\ippsmt.lib',
                '{0}\\threaded\\ippimt.lib',
                '{0}\\threaded\\ippcoremt.lib',
                '{0}\\threaded\\ippvmmt.lib'
            ],
            THREADING_LAYER: [
                '{0}\\tl\\{1}\\ippccmt_tl.lib',
                '{0}\\tl\\{1}\\ippimt_tl.lib',
                '{0}\\tl\\{1}\\ippcoremt_tl.lib'
            ]
        },
        LINUX: [],
        ANDROID: {
            SINGLE_THREADED: [
                '{0}/libippcc.a',
                '{0}/libippch.a',
                '{0}/libippcv.a',
                '{0}/libippdc.a',
                '{0}/libippe.a',
                '{0}/libipps.a',
                '{0}/libippi.a',
                '{0}/libippcore.a',
                '{0}/libippvm.a'
            ],
            MULTI_THREADED: [
                '{0}/libippcc.a',
                '{0}/libippch.a',
                '{0}/libippcv.a',
                '{0}/libippdc.a',
                '{0}/libippe.a',
                '{0}/libipps.a',
                '{0}/libippi.a',
                '{0}/libippcore.a',
                '{0}/libippvm.a'
            ],
            THREADING_LAYER: []
        }
    },
    LINUX: {
        LINUX: {
            SINGLE_THREADED: [
                '{0}/libippcc.a',
                '{0}/libippch.a',
                '{0}/libippcv.a',
                '{0}/libippdc.a',
                '{0}/libippe.a',
                '{0}/libipps.a',
                '{0}/libippi.a',
                '{0}/libippcore.a',
                '{0}/libippvm.a'
            ],
            MULTI_THREADED: [
                '{0}/threaded/libippcc.a',
                '{0}/threaded/libippch.a',
                '{0}/threaded/libippcv.a',
                '{0}/threaded/libippdc.a',
                '{0}/threaded/libippe.a',
                '{0}/threaded/libipps.a',
                '{0}/threaded/libippi.a',
                '{0}/threaded/libippcore.a',
                '{0}/threaded/libippvm.a'
            ],
            THREADING_LAYER: [
                '{0}/tl/{1}/libippcc_tl.so',
                '{0}/tl/{1}/libippi_tl.so',
                '{0}/tl/{1}/libippcore_tl.so'
            ]
        },
        ANDROID: {
            SINGLE_THREADED: [
                '{0}/libippcc.a',
                '{0}/libippch.a',
                '{0}/libippcv.a',
                '{0}/libippdc.a',
                '{0}/libippe.a',
                '{0}/libipps.a',
                '{0}/libippi.a',
                '{0}/libippcore.a',
                '{0}/libippvm.a'
            ],
            MULTI_THREADED: [
                '{0}/libippcc.a',
                '{0}/libippch.a',
                '{0}/libippcv.a',
                '{0}/libippdc.a',
                '{0}/libippe.a',
                '{0}/libipps.a',
                '{0}/libippi.a',
                '{0}/libippcore.a',
                '{0}/libippvm.a'
            ],
            THREADING_LAYER: []
        }
    },
    MACOSX: {
        # when macOS x32 will be available just add "{0}/" and all will be good
        MACOSX:  {
            SINGLE_THREADED: [
                'libippcc.a',
                'libippch.a',
                'libippcv.a',
                'libippdc.a',
                'libippe.a',
                'libipps.a',
                'libippi.a',
                'libippcore.a',
                'libippvm.a'
            ],
            MULTI_THREADED: [
                'threaded/libippcc.a',
                'threaded/libippch.a',
                'threaded/libippcv.a',
                'threaded/libippdc.a',
                'threaded/libippe.a',
                'threaded/libipps.a',
                'threaded/libippi.a',
                'threaded/libippcore.a',
                'threaded/libippvm.a'
            ],
            THREADING_LAYER: [
                'tl/{1}/libippcc_tl.dylib',
                'tl/{1}/libippi_tl.dylib',
                'tl/{1}/libippcore_tl.dylib'
            ]
        },
        ANDROID: {
            SINGLE_THREADED: [
                '{0}/libippcc.a',
                '{0}/libippch.a',
                '{0}/libippcv.a',
                '{0}/libippdc.a',
                '{0}/libippe.a',
                '{0}/libipps.a',
                '{0}/libippi.a',
                '{0}/libippcore.a',
                '{0}/libippvm.a'
            ],
            MULTI_THREADED: [
                '{0}/libippcc.a',
                '{0}/libippch.a',
                '{0}/libippcv.a',
                '{0}/libippdc.a',
                '{0}/libippe.a',
                '{0}/libipps.a',
                '{0}/libippi.a',
                '{0}/libippcore.a',
                '{0}/libippvm.a'
            ],
            THREADING_LAYER: []
        }
    }
}

ARCHITECTURES = {
    INTEL64: 'X64',
    IA32: 'X86'
}

BUILD_SCRIPT = {
    INTEL64: {
        WINDOWS: 'intel64.bat',
        LINUX: 'intel64.sh',
        MACOSX: 'intel64.sh'
    },
    IA32: {
        WINDOWS: 'ia32.bat',
        LINUX: 'ia32.sh',
        MACOSX: 'ia32.sh'
    }
}

MAIN_FILES = {
    WINDOWS: "#include &lt;Windows.h&gt;\n"
             "#include \"ipp.h\"\n\n"
             "int WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)\n"
             "{\n"
             "    switch (fdwReason)\n"
             "    {\n"
             "    case DLL_PROCESS_ATTACH:\n"
             "        ippInit(); break;\n"
             "    case DLL_THREAD_ATTACH: break;\n"
             "    case DLL_THREAD_DETACH: break;\n"
             "    case DLL_PROCESS_DETACH: break;\n"
             "    default: break;\n"
             "    }\n"
             "    return 1;\n"
             "    UNREFERENCED_PARAMETER(hinstDLL);\n"
             "    UNREFERENCED_PARAMETER(lpvReserved);\n"
             "}\n",
    LINUX: "#include \"ipp.h\"\n\n"
           "int _init(void)\n"
           "{\n"
           "    ippInit();\n"
           "    return 1;\n"
           "}\n\n"
           "void _fini(void)\n"
           "{\n"
           "}\n",
    MACOSX: "#include \"ipp.h\"\n\n"
            "__attribute__((constructor)) void initializer( void )\n"
            "{\n"
            "    static int initialized = 0;\n"
            "    if (!initialized)\n"
            "    {\n"
            "        initialized = 1;\n"
            "    }\n\n"
            "    ippInit();\n"
            "    return;\n"
            "}\n\n"
            "__attribute__((destructor)) void destructor()\n"
            "{\n"
            "}\n",
    ANDROID: "#include \"ipp.h\"\n\n"
             "int _init(void)\n"
             "{\n"
             "    ippInit();\n"
             "    return 1;\n"
             "}\n\n"
             "void _fini(void)\n"
             "{\n"
             "}\n"
}

EXPORT_FILES = {
    WINDOWS: 'export.def',
    LINUX: 'export.def',
    MACOSX: 'export.lib-export',
    ANDROID: 'export.def'
}

BUILD_COMMANDS = {
    WINDOWS: {
        WINDOWS: lambda package_path, architecture: 'call "' + os.path.join(package_path,
                                                                            'windows',
                                                                            'bin',
                                                                            'compilervars.bat')
                                                    + '" ' + architecture + '\n',
        ANDROID: lambda package_path, architecture: 'call "' + os.path.join(package_path,
                                                                            'linux',
                                                                            'bin',
                                                                            'compilervars.bat')
                                                    + '" -arch ' + architecture
                                                    + ' -platform android\n'
                                                    + 'set ANDROID_GNU_X86_TOOLCHAIN='
                                                    + ANDROID_NDK_PATH + '\\toolchains\\x86'
                                                    + ('_64' if architecture == INTEL64 else '')
                                                    + '-4.9\\prebuilt\\windows-x86_64\n'
                                                    + 'set ANDROID_SYSROOT='
                                                    + ANDROID_NDK_PATH + '\\sysroot\n'
    },
    LINUX: {
        LINUX: lambda package_path, architecture: 'source "' + os.path.join(package_path,
                                                                            'linux',
                                                                            'bin',
                                                                            'compilervars.sh')
                                                  + '" -arch ' + architecture + '\n',
        ANDROID: lambda package_path, architecture: 'source "' + os.path.join(package_path,
                                                                            'linux',
                                                                            'bin',
                                                                            'compilervars.sh')
                                                    + '" -arch ' + architecture
                                                    + ' -platform android\n'
                                                    + 'export ANDROID_GNU_X86_TOOLCHAIN='
                                                    + ANDROID_NDK_PATH + '/toolchains/x86'
                                                    + ('_64' if architecture == INTEL64 else '')
                                                    + '-4.9/prebuilt/linux-x86_64\n'
                                                    + 'export ANDROID_SYSROOT='
                                                    + ANDROID_NDK_PATH + '/sysroot\n'
    },
    MACOSX: {
        MACOSX: lambda package_path, architecture: 'source "' + os.path.join(package_path,
                                                                             'mac',
                                                                             'bin',
                                                                             'compilervars.sh')
                                                   + '" -arch ' + architecture + '\n',
        ANDROID: lambda package_path, architecture: 'source "' + os.path.join(package_path,
                                                                             'mac',
                                                                             'bin',
                                                                             'compilervars.sh')
                                                   + '" -arch ' + architecture
                                                   + ' -platform android\n'
                                                   + 'export ANDROID_GNU_X86_TOOLCHAIN='
                                                   + ANDROID_NDK_PATH + '/toolchains/x86'
                                                   + ('_64' if architecture == INTEL64 else '')
                                                   + '-4.9/prebuilt/darwin-x86_64\n'
                                                   + 'export ANDROID_SYSROOT='
                                                   + ANDROID_NDK_PATH + '/sysroot\n'
    }
}

LIBRARIES_EXTENSIONS = {
    WINDOWS: '.dll',
    LINUX: '.so',
    MACOSX: '.dy',
    ANDROID: '.so'
}

LIBRARIES_PREFIX = {
    WINDOWS: '',
    LINUX: 'lib',
    MACOSX: 'lib',
    ANDROID: 'lib'
}

DOMAIN_TO_LIBRARY = {
    'Color conversion': 'ippcc',
    'String processing': 'ippch',
    'Computer vision': 'ippcv',
    'Data compression': 'ippdc',
    'Image processing': 'ippi',
    'Signal processing': 'ipps',
    'Image processing TL': 'ippi',
    'Signal processing TL': 'ipps'
}

SUPPORTED_ARCHITECTURES = {
    WINDOWS: {
        INTEL64: True,
        IA32: True
    },
    LINUX: {
        INTEL64: True,
        IA32: True
    },
    ANDROID: {
        INTEL64: True,
        IA32: True
    },
    MACOSX: {
        INTEL64: True,
        IA32: False}
}
ONLY_THREADABLE = {
    WINDOWS: False,
    LINUX: False,
    ANDROID: True,
    MACOSX: False
}
</pre></body></html>