vendor: OpenCV 5.0.0 snapshot at 40738fb16ceddb5fb3fea747585f7ce6abb0605b

cmake/checks/OpenCVDetectCudaArch.cu

@@ -0,0 +1,25 @@
+#include <iostream>
+#include <sstream>
+#include <list>
+
+int main()
+{
+    std::ostringstream arch;
+    std::list<std::string> archs;
+
+    int count = 0;
+    if (cudaSuccess != cudaGetDeviceCount(&count)){ return -1; }
+    if (count == 0) { return -1; }
+    for (int device = 0; device < count; ++device)
+    {
+        cudaDeviceProp prop;
+        if (cudaSuccess != cudaGetDeviceProperties(&prop, device)){ continue; }
+        arch << prop.major << "." << prop.minor;
+        archs.push_back(arch.str());
+        arch.str("");
+    }
+    archs.unique(); // Some devices might have the same arch
+    for (std::list<std::string>::iterator it=archs.begin(); it!=archs.end(); ++it)
+        std::cout << *it << " ";
+    return 0;
+}

cmake/checks/atomic_check.cpp

@@ -0,0 +1,12 @@
+#include <atomic>
+
+static int test()
+{
+    std::atomic<long long> x;
+    return x;
+}
+
+int main()
+{
+    return test();
+}

cmake/checks/cann.cpp

@@ -0,0 +1,20 @@
+#include <acl/acl.h>
+#include <unistd.h> // fork()
+#include <iostream>
+
+int main(int /*argc*/, char** /*argv*/)
+{
+    int ret = aclInit(NULL);
+    if (ret != 0)
+    {
+        std::cerr << "Failed to initialize Ascend, ret = " << ret;
+    }
+
+    ret = aclFinalize();
+    if (ret != 0)
+    {
+        std::cerr << "Failed to de-initialize Ascend, ret = " << ret;
+    }
+
+    return 0;
+}

cmake/checks/cpu_avx.cpp

@@ -0,0 +1,9 @@
+#if !defined __AVX__
+#error "__AVX__ define is missing"
+#endif
+#include <immintrin.h>
+void test()
+{
+    __m256 a = _mm256_set1_ps(0.0f);
+}
+int main() { return 0; }

cmake/checks/cpu_avx2.cpp

@@ -0,0 +1,11 @@
+#if !defined __AVX2__
+#error "__AVX2__ define is missing"
+#endif
+#include <immintrin.h>
+void test()
+{
+    int data[8] = {0,0,0,0, 0,0,0,0};
+    __m256i a = _mm256_loadu_si256((const __m256i *)data);
+    __m256i b = _mm256_bslli_epi128(a, 1);  // available in GCC 4.9.3+
+}
+int main() { return 0; }

cmake/checks/cpu_avx512.cpp

@@ -0,0 +1,13 @@
+#if defined __AVX512__ || defined __AVX512F__
+#include <immintrin.h>
+void test()
+{
+    __m512i zmm = _mm512_setzero_si512();
+#if defined __GNUC__ && defined __x86_64__
+    asm volatile ("" : : : "zmm16", "zmm17", "zmm18", "zmm19");
+#endif
+}
+#else
+#error "AVX512 is not supported"
+#endif
+int main() { return 0; }

cmake/checks/cpu_avx512clx.cpp

@@ -0,0 +1,11 @@
+#if defined __AVX512__ || defined __AVX512F__
+#include <immintrin.h>
+void test()
+{
+    __m512i a, b, c;
+    a = _mm512_dpwssd_epi32(a, b, c);            // VNNI
+}
+#else
+#error "AVX512-CLX is not supported"
+#endif
+int main() { return 0; }

cmake/checks/cpu_avx512cnl.cpp

@@ -0,0 +1,12 @@
+#if defined __AVX512__ || defined __AVX512F__
+#include <immintrin.h>
+void test()
+{
+    __m512i a, b, c;
+    a = _mm512_madd52hi_epu64(a, b, c);
+    a = _mm512_permutexvar_epi8(a, b);
+}
+#else
+#error "AVX512-CNL is not supported"
+#endif
+int main() { return 0; }

cmake/checks/cpu_avx512common.cpp

@@ -0,0 +1,14 @@
+#if defined __AVX512__ || defined __AVX512F__
+#include <immintrin.h>
+void test()
+{
+    __m512i zmm = _mm512_setzero_si512();
+    zmm = _mm512_lzcnt_epi32(zmm);
+#if defined __GNUC__ && defined __x86_64__
+    asm volatile ("" : : : "zmm16", "zmm17", "zmm18", "zmm19");
+#endif
+}
+#else
+#error "AVX512-COMMON is not supported"
+#endif
+int main() { return 0; }

cmake/checks/cpu_avx512icl.cpp

@@ -0,0 +1,14 @@
+#if defined __AVX512__ || defined __AVX512F__
+#include <immintrin.h>
+void test()
+{
+    __m512i a, b, c;
+    a = _mm512_popcnt_epi8(a);                   // BITALG
+    a = _mm512_shrdv_epi64(a, b, c);             // VBMI2
+    a = _mm512_popcnt_epi64(a);                  // VPOPCNTDQ
+    a = _mm512_dpwssd_epi32(a, b, c);            // VNNI
+}
+#else
+#error "AVX512-ICL is not supported"
+#endif
+int main() { return 0; }

cmake/checks/cpu_avx512knl.cpp

@@ -0,0 +1,16 @@
+#if defined __AVX512__ || defined __AVX512F__
+#include <immintrin.h>
+
+void test()
+{
+    int* base;
+    __m512i idx;
+    __mmask16 m16;
+    __m512 f;
+    _mm512_mask_prefetch_i32gather_ps(idx, m16, base, 1, _MM_HINT_T1);
+    f = _mm512_rsqrt28_ps(f);
+}
+#else
+#error "AVX512-KNL is not supported"
+#endif
+int main() { return 0; }

cmake/checks/cpu_avx512knm.cpp

@@ -0,0 +1,17 @@
+#if defined __AVX512__ || defined __AVX512F__
+#include <immintrin.h>
+void test()
+{
+    __m512 a, b, c, d, e;
+    __m512i ai, bi, ci, di, ei, fi;
+    __m128  *mem;
+    __m128i *memi;
+    __mmask16 m;
+    a  = _mm512_4fnmadd_ps(a, b, c, d, e, mem);
+    ai = _mm512_4dpwssd_epi32(ai, bi, ci, di, ei, memi);
+    ai = _mm512_popcnt_epi64(ai);
+}
+#else
+#error "AVX512-KNM is not supported"
+#endif
+int main() { return 0; }

cmake/checks/cpu_avx512skx.cpp

@@ -0,0 +1,32 @@
+#if defined __AVX512__ || defined __AVX512F__
+#include <immintrin.h>
+
+// Workaround for problem with GCC 5-6 in -O0 mode
+struct v_uint32x16
+{
+    __m512i val;
+    explicit v_uint32x16(__m512i v) : val(v) {}
+};
+inline v_uint32x16 operator << (const v_uint32x16& a, int imm)
+{
+    return v_uint32x16(_mm512_slli_epi32(a.val, imm));
+}
+
+void test()
+{
+    __m512i zmm = _mm512_setzero_si512();
+    __m256i a = _mm256_setzero_si256();
+    __m256i b = _mm256_abs_epi64(a); // VL
+    __m512i c = _mm512_abs_epi8(zmm); // BW
+    __m512i d = _mm512_broadcast_i32x8(b); // DQ
+    v_uint32x16 e(d); e = e << 10;
+    __m512i f = _mm512_packus_epi32(d,d);
+#if defined __GNUC__ && defined __x86_64__
+    asm volatile ("" : : : "zmm16", "zmm17", "zmm18", "zmm19");
+#endif
+}
+
+#else
+#error "AVX512-SKX is not supported"
+#endif
+int main() { return 0; }

cmake/checks/cpu_fp16.cpp

@@ -0,0 +1,55 @@
+#include <stdio.h>
+
+#if defined __F16C__ || (defined _MSC_VER && _MSC_VER >= 1700 && defined __AVX__) || (defined __INTEL_COMPILER && defined __AVX__)
+#include <immintrin.h>
+int test()
+{
+    const float src[] = { 0.0f, 0.0f, 0.0f, 0.0f };
+    short dst[8];
+    __m128 v_src = _mm_load_ps(src);
+    __m128i v_dst = _mm_cvtps_ph(v_src, 0);
+    _mm_storel_epi64((__m128i*)dst, v_dst);
+    return (int)dst[0];
+}
+#elif (defined __GNUC__ && (defined __arm__ || defined __aarch64__)) /*|| (defined _MSC_VER && defined _M_ARM64)*/
+// Windows + ARM64 case disabled: https://github.com/opencv/opencv/issues/25052
+#include "arm_neon.h"
+int test()
+{
+    const float src[] = { 0.0f, 0.0f, 0.0f, 0.0f };
+    short dst[8];
+    float32x4_t v_src = *(float32x4_t*)src;
+    float16x4_t v_dst = vcvt_f16_f32(v_src);
+    *(float16x4_t*)dst = v_dst;
+    return (int)dst[0];
+}
+#elif (defined __riscv_zvfhmin && __riscv_zvfhmin) || (defined __riscv_zvfh && __riscv_zvfh)
+#include <riscv_vector.h>
+
+int test()
+{
+    const _Float16 input1[] = {0.5f, 1.5f, 2.5f, 3.5f};
+    const float input2[] = {-0.5f, -1.5f, -2.5f, -3.5f};
+    short dst[4];
+
+    size_t vl =  __riscv_vsetvl_e16m1(4);
+
+    vfloat16m1_t in_f16 = __riscv_vle16_v_f16m1(input1, vl);
+    vfloat32m2_t in_f32 = __riscv_vle32_v_f32m2(input2, vl);
+
+    vfloat32m2_t cvt_f32 = __riscv_vfwcvt_f_f_v_f32m2(in_f16, vl);
+    vfloat32m2_t res_f32 = __riscv_vfadd(in_f32, cvt_f32, vl);
+    vfloat16m1_t res_f16 = __riscv_vfncvt_f_f_w_f16m1(res_f32, vl);
+
+    __riscv_vse16_v_f16m1((_Float16*)dst, res_f16, vl);
+    return (int)dst[0];
+}
+#else
+#error "FP16 is not supported"
+#endif
+
+int main()
+{
+  printf("%d\n", test());
+  return 0;
+}

cmake/checks/cpu_lasx.cpp

@@ -0,0 +1,23 @@
+#include <stdio.h>
+
+#if defined(__loongarch_asx)
+#  include <lasxintrin.h>
+#  define CV_LASX 1
+#endif
+
+#if defined CV_LASX
+int test()
+{
+    const float src[] = { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f };
+    v8f32 val = (v8f32)__lasx_xvld((const float*)(src), 0);
+    return __lasx_xvpickve2gr_w(__lasx_xvftint_w_s (val), 7);
+}
+#else
+#error "LASX is not supported"
+#endif
+
+int main()
+{
+  printf("%d\n", test());
+  return 0;
+}

cmake/checks/cpu_lsx.cpp

@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <lsxintrin.h>
+
+int test()
+{
+    const float src[] = { 0.0f, 1.0f, 2.0f, 3.0f};
+    v4f32 val = (v4f32)__lsx_vld((const float*)(src), 0);
+    return __lsx_vpickve2gr_w(__lsx_vftint_w_s(val), 3);
+}
+
+int main()
+{
+  printf("%d\n", test());
+  return 0;
+}

cmake/checks/cpu_msa.cpp

@@ -0,0 +1,23 @@
+#include <stdio.h>
+
+#if defined(__mips_msa)
+#  include <msa.h>
+#  define CV_MSA 1
+#endif
+
+#if defined CV_MSA
+int test()
+{
+    const float src[] = { 0.0f, 0.0f, 0.0f, 0.0f };
+    v4f32 val = (v4f32)__msa_ld_w((const float*)(src), 0);
+    return __msa_copy_s_w(__builtin_msa_ftint_s_w (val), 0);
+}
+#else
+#error "MSA is not supported"
+#endif
+
+int main()
+{
+  printf("%d\n", test());
+  return 0;
+}

cmake/checks/cpu_neon.cpp

@@ -0,0 +1,32 @@
+#include <stdio.h>
+
+#if defined _WIN32 && (defined(_M_ARM) || defined(_M_ARM64) || defined(_M_ARM64EC))
+# define _ARM64_DISTINCT_NEON_TYPES
+# include <Intrin.h>
+# include <arm_neon.h>
+# define CV_NEON 1
+#elif defined(__ARM_NEON)
+#  include <arm_neon.h>
+#  define CV_NEON 1
+#endif
+
+// MSVC 2019 bug. Details: https://github.com/opencv/opencv/pull/16027
+void test_aliased_type(const uint8x16_t& a) { }
+void test_aliased_type(const int8x16_t& a) { }
+
+#if defined CV_NEON
+int test()
+{
+    const float src[] = { 0.0f, 0.0f, 0.0f, 0.0f };
+    float32x4_t val = vld1q_f32((const float32_t*)(src));
+    return (int)vgetq_lane_f32(val, 0);
+}
+#else
+#error "NEON is not supported"
+#endif
+
+int main()
+{
+  printf("%d\n", test());
+  return 0;
+}

cmake/checks/cpu_neon_bf16.cpp

@@ -0,0 +1,46 @@
+#if (defined __GNUC__ && (defined __arm__ || defined __aarch64__)) || (defined _MSC_VER && (defined _M_ARM64 || defined _M_ARM64EC))
+#include <stdio.h>
+#include "arm_neon.h"
+
+/*#if defined __clang__
+#pragma clang attribute push (__attribute__((target("bf16"))), apply_to=function)
+#elif defined GCC
+#pragma GCC push_options
+#pragma GCC target("armv8.2-a", "bf16")
+#endif*/
+bfloat16x8_t vld1q_as_bf16(const float* src)
+{
+    float32x4_t s0 = vld1q_f32(src), s1 = vld1q_f32(src + 4);
+    return vcombine_bf16(vcvt_bf16_f32(s0), vcvt_bf16_f32(s1));
+}
+
+void vprintreg(const char* name, const float32x4_t& r)
+{
+    float data[4];
+    vst1q_f32(data, r);
+    printf("%s: (%.2f, %.2f, %.2f, %.2f)\n",
+        name, data[0], data[1], data[2], data[3]);
+}
+
+void test()
+{
+    const float src1[] = { 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f };
+    const float src2[] = { 1.f, 3.f, 6.f, 10.f, 15.f, 21.f, 28.f, 36.f };
+    bfloat16x8_t s1 = vld1q_as_bf16(src1), s2 = vld1q_as_bf16(src2);
+    float32x4_t d = vbfdotq_f32(vdupq_n_f32(0.f), s1, s2);
+    vprintreg("(s1[0]*s2[0] + s1[1]*s2[1], ... s1[6]*s2[6] + s1[7]*s2[7])", d);
+}
+/*#if defined __clang__
+#pragma clang attribute pop
+#elif defined GCC
+#pragma GCC pop_options
+#endif*/
+#else
+#error "BF16 is not supported"
+#endif
+
+int main()
+{
+    test();
+    return 0;
+}

cmake/checks/cpu_neon_dotprod.cpp

@@ -0,0 +1,26 @@
+#include <stdio.h>
+
+#if (defined __GNUC__ && (defined __arm__ || defined __aarch64__))/* || (defined _MSC_VER && (defined _M_ARM64 || defined _M_ARM64EC)) */
+// Windows + ARM64 case disabled: https://github.com/opencv/opencv/issues/25052
+
+#include "arm_neon.h"
+int test()
+{
+    const unsigned int src[] = { 0, 0, 0, 0 };
+    unsigned int dst[4];
+    uint32x4_t v_src = *(uint32x4_t*)src;
+    uint8x16_t v_m0 = *(uint8x16_t*)src;
+    uint8x16_t v_m1 = *(uint8x16_t*)src;
+    uint32x4_t v_dst = vdotq_u32(v_src, v_m0, v_m1);
+    *(uint32x4_t*)dst = v_dst;
+    return (int)dst[0];
+}
+#else
+#error "DOTPROD is not supported"
+#endif
+
+int main()
+{
+  printf("%d\n", test());
+  return 0;
+}

cmake/checks/cpu_neon_fp16.cpp

@@ -0,0 +1,47 @@
+#include <stdio.h>
+
+#if (defined __GNUC__ && (defined __arm__ || defined __aarch64__)) /* || (defined _MSC_VER && (defined _M_ARM64 || defined _M_ARM64EC)) */
+// Windows + ARM64 case disabled: https://github.com/opencv/opencv/issues/25052
+#include "arm_neon.h"
+
+float16x8_t vld1q_as_f16(const float* src)
+{
+    float32x4_t s0 = vld1q_f32(src), s1 = vld1q_f32(src + 4);
+    return vcombine_f16(vcvt_f16_f32(s0), vcvt_f16_f32(s1));
+}
+
+void vprintreg(const char* name, const float16x8_t& r)
+{
+    float data[8];
+    vst1q_f32(data, vcvt_f32_f16(vget_low_f16(r)));
+    vst1q_f32(data + 4, vcvt_f32_f16(vget_high_f16(r)));
+    printf("%s: (%.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
+        name, data[0], data[1], data[2], data[3],
+        data[4], data[5], data[6], data[7]);
+}
+
+void test()
+{
+    const float src1[] = { 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f };
+    const float src2[] = { 1.f, 3.f, 6.f, 10.f, 15.f, 21.f, 28.f, 36.f };
+    float16x8_t s1 = vld1q_as_f16(src1), s2 = vld1q_as_f16(src2);
+    float16x8_t d = vsubq_f16(s1, s1);
+    d = vfmaq_laneq_f16(d, s1, s2, 0);
+    d = vfmaq_laneq_f16(d, s1, s2, 1);
+    d = vfmaq_laneq_f16(d, s1, s2, 2);
+    d = vfmaq_laneq_f16(d, s1, s2, 3);
+    d = vfmaq_laneq_f16(d, s1, s2, 4);
+    d = vfmaq_laneq_f16(d, s1, s2, 5);
+    d = vfmaq_laneq_f16(d, s1, s2, 6);
+    d = vfmaq_laneq_f16(d, s1, s2, 7);
+    vprintreg("s1*s2[0]+s1*s2[1] + ... + s1*s2[7]", d);
+}
+#else
+#error "NEON FP16 is not supported"
+#endif
+
+int main()
+{
+    test();
+    return 0;
+}

cmake/checks/cpu_popcnt.cpp

@@ -0,0 +1,24 @@
+#ifdef _MSC_VER
+#  include <nmmintrin.h>
+#  if defined(_M_X64)
+#    define CV_POPCNT_U64 _mm_popcnt_u64
+#  endif
+#  define CV_POPCNT_U32 _mm_popcnt_u32
+#elif defined(__POPCNT__)
+#  include <popcntintrin.h>
+#  if defined(__x86_64__)
+#    define CV_POPCNT_U64 __builtin_popcountll
+#  endif
+#  define CV_POPCNT_U32 __builtin_popcount
+#else
+#  error "__POPCNT__ is not defined by compiler"
+#endif
+
+int main()
+{
+#ifdef CV_POPCNT_U64
+    int i = CV_POPCNT_U64(1);
+#endif
+    int j = CV_POPCNT_U32(1);
+    return 0;
+}

cmake/checks/cpu_rvv.cpp

@@ -0,0 +1,37 @@
+#include <stdio.h>
+
+#if !defined(__riscv) || !defined(__riscv_v)
+#error "RISC-V or vector extension(RVV) is not supported by the compiler"
+#endif
+
+#if !defined(__THEAD_VERSION__) && defined(__riscv_v_intrinsic) && __riscv_v_intrinsic < 12000
+#error "Wrong intrinsics version, v0.12 or higher is required for gcc or clang"
+#endif
+
+#include <riscv_vector.h>
+
+#ifdef __THEAD_VERSION__
+int test()
+{
+    const float src[] = { 0.0f, 0.0f, 0.0f, 0.0f };
+    uint64_t ptr[2] = {0x0908060504020100, 0xFFFFFFFF0E0D0C0A};
+    vuint8m1_t a = vreinterpret_v_u64m1_u8m1(vle64_v_u64m1(ptr, 2));
+    vfloat32m1_t val = vle32_v_f32m1((const float*)(src), 4);
+    return (int)vfmv_f_s_f32m1_f32(val);
+}
+#else
+int test()
+{
+    const float src[] = { 0.0f, 0.0f, 0.0f, 0.0f };
+    uint64_t ptr[2] = {0x0908060504020100, 0xFFFFFFFF0E0D0C0A};
+    vuint8m1_t a = __riscv_vreinterpret_v_u64m1_u8m1(__riscv_vle64_v_u64m1(ptr, 2));
+    vfloat32m1_t val = __riscv_vle32_v_f32m1((const float*)(src), 4);
+    return (int)__riscv_vfmv_f_s_f32m1_f32(val);
+}
+#endif
+
+int main()
+{
+  printf("%d\n", test());
+  return 0;
+}

cmake/checks/cpu_rvv_fp16.cpp

@@ -0,0 +1,25 @@
+#include <stdio.h>
+
+#if defined(__riscv) && __riscv && defined (__riscv_zvfh) && __riscv_zvfh
+#  include <riscv_vector.h>
+
+int test()
+{
+    const _Float16 input1[] = {0.5f, 1.5f, 2.5f, 3.5f};
+    const _Float16 input2[] = {-0.5f, -1.5f, -2.5f, -3.5f};
+
+    size_t vl =  __riscv_vsetvl_e16m1(4);
+    vfloat16m1_t vec1 = __riscv_vle16_v_f16m1(input1, vl);
+    vfloat16m1_t vec2 = __riscv_vle16_v_f16m1(input2, vl);
+    vfloat16m1_t result = __riscv_vfadd_vv_f16m1(vec1, vec2, vl);
+    return (int)__riscv_vfmv_f_s_f16m1_f16(result);
+}
+#else
+#error "RISC-V Vector Extension with Half-Precision Floating-Point (zvfh) is not supported"
+#endif
+
+int main()
+{
+  printf("%d\n", test());
+  return 0;
+}

cmake/checks/cpu_sse.cpp

@@ -0,0 +1,2 @@
+#include <xmmintrin.h>
+int main() { return 0; }

cmake/checks/cpu_sse2.cpp

@@ -0,0 +1,16 @@
+#include <emmintrin.h>
+
+inline __m128i _v128_comgt_epu32(const __m128i& a, const __m128i& b)
+{
+    const __m128i delta = _mm_set1_epi32((int)0x80000000);
+    return _mm_cmpgt_epi32(_mm_xor_si128(a, delta), _mm_xor_si128(b, delta));
+}
+
+int main()
+{
+    __m128i a, b, c;
+    a = _mm_set1_epi32(0x00000000);
+    b = _mm_set1_epi32(0x0000ffff);
+    c = _v128_comgt_epu32(a, b);
+    return 0;
+}

cmake/checks/cpu_sse3.cpp

@@ -0,0 +1,7 @@
+#include <pmmintrin.h>
+int main() {
+    __m128 u, v;
+    u = _mm_set1_ps(0.0f);
+    v = _mm_moveldup_ps(u); // SSE3
+    return 0;
+}

cmake/checks/cpu_sse41.cpp

@@ -0,0 +1,6 @@
+#include <smmintrin.h>
+int main() {
+    __m128i a = _mm_setzero_si128(), b = _mm_setzero_si128();
+    __m128i c = _mm_packus_epi32(a, b);
+    return 0;
+}

cmake/checks/cpu_sse42.cpp

@@ -0,0 +1,7 @@
+#include <nmmintrin.h>
+
+int main()
+{
+    unsigned int res = _mm_crc32_u8(1, 2);
+    return 0;
+}

cmake/checks/cpu_ssse3.cpp

@@ -0,0 +1,7 @@
+#include <tmmintrin.h>
+const double v = 0;
+int main() {
+    __m128i a = _mm_setzero_si128();
+    __m128i b = _mm_abs_epi32(a);
+    return 0;
+}

cmake/checks/cpu_sve.cpp

@@ -0,0 +1,24 @@
+#include <stdio.h>
+
+#if defined(__ARM_FEATURE_SVE)
+#  include <arm_sve.h>
+#  define CV_SVE 1
+#endif
+
+#if defined(CV_SVE)
+int test()
+{
+    const float src[1024] = {0.0};
+    svbool_t pg = svptrue_b32();
+    svfloat32_t val = svld1(pg, src);
+    return (int)svlastb_f32(pg, val);
+}
+#else
+#error "SVE is not supported"
+#endif
+
+int main()
+{
+  printf("%d\n", test());
+  return 0;
+}

cmake/checks/cpu_vsx.cpp

@@ -0,0 +1,16 @@
+#if defined(__VSX__)
+    #if defined(__PPC64__) && defined(__LITTLE_ENDIAN__)
+        #include <altivec.h>
+    #else
+        #error "OpenCV only supports little-endian mode"
+    #endif
+#else
+    #error "VSX is not supported"
+#endif
+
+int main()
+{
+    __vector float testF = vec_splats(0.f);
+    testF = vec_madd(testF, testF, testF);
+    return 0;
+}

cmake/checks/cpu_vsx3.cpp

@@ -0,0 +1,17 @@
+#if defined(__VSX__)
+    #if defined(__PPC64__) && defined(__LITTLE_ENDIAN__)
+        #include <altivec.h>
+    #else
+        #error "OpenCV only supports little-endian mode"
+    #endif
+#else
+    #error "VSX3 is not supported"
+#endif
+
+int main()
+{
+    __vector unsigned char a = vec_splats((unsigned char)1);
+    __vector unsigned char b = vec_splats((unsigned char)2);
+    __vector unsigned char r = vec_absd(a, b);
+    return 0;
+}

cmake/checks/cpu_vsx_asm.cpp

@@ -0,0 +1,21 @@
+#if defined(__VSX__)
+    #if defined(__PPC64__) && defined(__LITTLE_ENDIAN__)
+        #include <altivec.h>
+    #else
+        #error "OpenCV only supports little-endian mode"
+    #endif
+#else
+    #error "VSX is not supported"
+#endif
+
+/*
+ * xlc and wide versions of clang don't support %x<n> in the inline asm template which fixes register number
+ * when using any of the register constraints wa, wd, wf
+*/
+int main()
+{
+    __vector float vf;
+    __vector signed int vi;
+    __asm__ __volatile__ ("xvcvsxwsp %x0,%x1" : "=wa" (vf) : "wa" (vi));
+    return 0;
+}

cmake/checks/directml.cpp

@@ -0,0 +1,38 @@
+#include <initguid.h>
+
+#include <d3d11.h>
+#include <dxgi1_2.h>
+#include <dxgi1_4.h>
+#include <dxgi.h>
+#include <dxcore.h>
+#include <dxcore_interface.h>
+#include <d3d12.h>
+#include <directml.h>
+
+int main(int /*argc*/, char** /*argv*/)
+{
+    IDXCoreAdapterFactory* factory;
+    DXCoreCreateAdapterFactory(__uuidof(IDXCoreAdapterFactory), (void**)&factory);
+
+    IDXCoreAdapterList* adapterList;
+    const GUID dxGUIDs[] = { DXCORE_ADAPTER_ATTRIBUTE_D3D12_CORE_COMPUTE };
+    factory->CreateAdapterList(ARRAYSIZE(dxGUIDs), dxGUIDs, __uuidof(IDXCoreAdapterList), (void**)&adapterList);
+
+    IDXCoreAdapter* adapter;
+    adapterList->GetAdapter(0u, __uuidof(IDXCoreAdapter), (void**)&adapter);
+
+    D3D_FEATURE_LEVEL d3dFeatureLevel = D3D_FEATURE_LEVEL_1_0_CORE;
+    ID3D12Device* d3d12Device = NULL;
+    D3D12CreateDevice((IUnknown*)adapter, d3dFeatureLevel, __uuidof(ID3D11Device), (void**)&d3d12Device);
+
+    D3D12_COMMAND_LIST_TYPE commandQueueType = D3D12_COMMAND_LIST_TYPE_COMPUTE;
+    ID3D12CommandQueue* cmdQueue;
+    D3D12_COMMAND_QUEUE_DESC commandQueueDesc = {};
+    commandQueueDesc.Type = commandQueueType;
+
+    d3d12Device->CreateCommandQueue(&commandQueueDesc, __uuidof(ID3D12CommandQueue), (void**)&cmdQueue);
+    IDMLDevice* dmlDevice;
+    DMLCreateDevice(d3d12Device, DML_CREATE_DEVICE_FLAG_NONE, IID_PPV_ARGS(&dmlDevice));
+
+    return 0;
+}

cmake/checks/directx.cpp

@@ -0,0 +1,73 @@
+#include <windows.h>
+
+#include <d3d11.h>
+
+HINSTANCE g_hInst = NULL;
+D3D_DRIVER_TYPE g_driverType = D3D_DRIVER_TYPE_NULL;
+D3D_FEATURE_LEVEL g_featureLevel = D3D_FEATURE_LEVEL_11_0;
+ID3D11Device* g_pd3dDevice = NULL;
+ID3D11DeviceContext* g_pImmediateContext = NULL;
+IDXGISwapChain* g_pSwapChain = NULL;
+
+static HRESULT InitDevice()
+{
+    HRESULT hr = S_OK;
+
+    UINT width = 640;
+    UINT height = 480;
+
+    UINT createDeviceFlags = 0;
+
+    D3D_DRIVER_TYPE driverTypes[] =
+    {
+        D3D_DRIVER_TYPE_HARDWARE,
+        D3D_DRIVER_TYPE_WARP,
+        D3D_DRIVER_TYPE_REFERENCE,
+    };
+    UINT numDriverTypes = ARRAYSIZE(driverTypes);
+
+    D3D_FEATURE_LEVEL featureLevels[] =
+    {
+        D3D_FEATURE_LEVEL_11_0,
+        D3D_FEATURE_LEVEL_10_1,
+        D3D_FEATURE_LEVEL_10_0,
+    };
+    UINT numFeatureLevels = ARRAYSIZE(featureLevels);
+
+    DXGI_SWAP_CHAIN_DESC sd;
+    ZeroMemory( &sd, sizeof( sd ) );
+    sd.BufferCount = 1;
+    sd.BufferDesc.Width = width;
+    sd.BufferDesc.Height = height;
+#ifdef CHECK_NV12
+    sd.BufferDesc.Format = DXGI_FORMAT_NV12;
+#else
+    sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+#endif
+    sd.BufferDesc.RefreshRate.Numerator = 60;
+    sd.BufferDesc.RefreshRate.Denominator = 1;
+    sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+    sd.OutputWindow = NULL; //g_hWnd;
+    sd.SampleDesc.Count = 1;
+    sd.SampleDesc.Quality = 0;
+    sd.Windowed = TRUE;
+
+    for (UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++)
+    {
+        g_driverType = driverTypes[driverTypeIndex];
+        hr = D3D11CreateDeviceAndSwapChain(NULL, g_driverType, NULL, createDeviceFlags, featureLevels, numFeatureLevels,
+                D3D11_SDK_VERSION, &sd, &g_pSwapChain, &g_pd3dDevice, &g_featureLevel, &g_pImmediateContext);
+        if (SUCCEEDED(hr))
+            break;
+    }
+    if (FAILED(hr))
+        return hr;
+
+    return S_OK;
+}
+
+int main(int /*argc*/, char** /*argv*/)
+{
+    InitDevice();
+    return 0;
+}

cmake/checks/ffmpeg_test.cpp

@@ -0,0 +1,29 @@
+#define __STDC_CONSTANT_MACROS
+
+#include <stdlib.h>
+
+extern "C" {
+#include <libavformat/avformat.h>
+#include <libavcodec/avcodec.h>
+#include <libswscale/swscale.h>
+}
+
+#define CALC_FFMPEG_VERSION(a,b,c) ( a<<16 | b<<8 | c )
+
+static void test()
+{
+  AVFormatContext* c = 0;
+  AVCodec* avcodec = 0;
+  AVFrame* frame = 0;
+  (void)avcodec;
+  (void)frame;
+
+#if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(52, 111, 0)
+  int err = avformat_open_input(&c, "", NULL, NULL);
+#else
+  int err = av_open_input_file(&c, "", NULL, 0, NULL);
+#endif
+  (void)err;
+}
+
+int main() { test(); return 0; }

cmake/checks/framebuffer.cpp

@@ -0,0 +1,9 @@
+#include <X11/XWDFile.h>
+#include <X11/X.h>
+
+int main(void)
+{
+    XWDFileHeader *xwd_header;
+    XWDColor *xwd_colors;
+    return 0;
+}

cmake/checks/lapack_check.cpp

@@ -0,0 +1,15 @@
+#include <complex.h>
+#include "opencv_lapack.h"
+
+static char* check_fn1 = (char*)sgesv_;
+static char* check_fn2 = (char*)sposv_;
+static char* check_fn3 = (char*)spotrf_;
+static char* check_fn4 = (char*)sgesdd_;
+
+int main(int argc, char* argv[])
+{
+    (void)argv;
+    if(argc > 1000)
+        return check_fn1[0] + check_fn2[0] + check_fn3[0] + check_fn4[0];
+    return 0;
+}

cmake/checks/opencl.cpp

@@ -0,0 +1,21 @@
+// custom OpenCL headers are located in "CL" subfolder (3rdparty/include/...)
+#include <CL/cl.h>
+
+#ifndef _MSC_VER
+#ifdef CL_VERSION_1_2
+#error OpenCL is valid
+#else
+#error OpenCL check failed
+#endif
+#else
+#ifdef CL_VERSION_1_2
+#pragma message ("OpenCL is valid")
+#else
+#pragma message ("OpenCL check failed")
+#endif
+#endif
+
+int main(int /*argc*/, char** /*argv*/)
+{
+    return 0;
+}

cmake/checks/runtime/cpu_vsx_aligned.cpp

@@ -0,0 +1,56 @@
+// check sanity of vsx aligned ld/st
+// https://github.com/opencv/opencv/issues/13211
+
+#include <altivec.h>
+#undef bool
+
+#define vsx_ld vec_vsx_ld
+#define vsx_st vec_vsx_st
+
+template<typename T>
+static void fill(T& d, int from = 0, int to = 16)
+{
+   for (int i = from; i < to; i++)
+        d[i] = i;
+}
+
+template<typename T, typename Tvec>
+static bool check_data(T& d, Tvec& v, int from = 0, int to = 16)
+{
+    for (int i = from; i < to; i++)
+    {
+        if (d[i] != vec_extract(v, i))
+            return false;
+    }
+    return true;
+}
+
+int main()
+{
+    unsigned char __attribute__ ((aligned (16))) rbuf[16];
+    unsigned char __attribute__ ((aligned (16))) wbuf[16];
+    __vector unsigned char a;
+
+    // 1- check aligned load and store
+    fill(rbuf);
+    a = vec_ld(0, rbuf);
+    if (!check_data(rbuf, a))
+        return 1;
+    vec_st(a, 0, wbuf);
+    if (!check_data(wbuf, a))
+        return 11;
+
+    // 2- check mixing aligned load and unaligned store
+    a = vec_ld(0, rbuf);
+    vsx_st(a, 0, wbuf);
+    if (!check_data(wbuf, a))
+        return 2;
+
+    // 3- check mixing unaligned load and aligned store
+    a = vsx_ld(0, rbuf);
+    vec_st(a, 0, wbuf);
+    if (!check_data(wbuf, a))
+        return 3;
+
+    return 0;
+}

cmake/checks/vtk_test.cpp

@@ -0,0 +1,9 @@
+#include <vtkSmartPointer.h>
+#include <vtkTransform.h>
+#include <vtkMath.h>
+
+int main()
+{
+  vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
+  return 0;
+}

cmake/checks/vulkan.cpp

@@ -0,0 +1,6 @@
+#include <vulkan/vulkan.h>
+
+int main(int /*argc*/, char** /*argv*/)
+{
+    return 0;
+}

cmake/checks/webnn.cpp

@@ -0,0 +1,23 @@
+#include <webnn/webnn_cpp.h>
+#include <webnn/webnn.h>
+#ifdef __EMSCRIPTEN__
+#include <emscripten.h>
+#include <emscripten/html5.h>
+#include <emscripten/html5_webnn.h>
+#else
+#include <webnn/webnn_proc.h>
+#include <webnn_native/WebnnNative.h>
+#endif
+
+
+int main(int /*argc*/, char** /*argv*/)
+{
+#ifdef __EMSCRIPTEN__
+    ml::Context ml_context = ml::Context(emscripten_webnn_create_context());
+#else
+    WebnnProcTable backendProcs = webnn_native::GetProcs();
+    webnnProcSetProcs(&backendProcs);
+    ml::Context ml_context = ml::Context(webnn_native::CreateContext());
+#endif
+    return 0;
+}

cmake/checks/win32uitest.cpp

@@ -0,0 +1,11 @@
+#include <windows.h>
+
+int main(int argc, char** argv)
+{
+    CreateWindow(NULL /*lpClassName*/, NULL /*lpWindowName*/, 0 /*dwStyle*/, 0 /*x*/,
+                 0 /*y*/, 0 /*nWidth*/, 0 /*nHeight*/, NULL /*hWndParent*/, NULL /*hMenu*/,
+                NULL /*hInstance*/,  NULL /*lpParam*/);
+    DeleteDC(NULL);
+
+    return 0;
+}