Fixed video writer filename check for plugins

G-API planar kernels (#14917)

* Added resizeP with tests

* NV12 planar filters

* fix warnings in ResizeP test

* fix out mat ocv warning

* sz_on - > sz rename

* cpu tests new signature

* try to fix resizeP test

* trailing spaces remove

* doxygen doc fixed

* doxygen minor fix

* more doxygen fixes

* Doxygen corrected and extended after review.

.github/ISSUE_TEMPLATE.md

@@ -2,6 +2,14 @@
 If you have a question rather than reporting a bug please go to http://answers.opencv.org where you get much faster responses.
 If you need further assistance please read [How To Contribute](https://github.com/opencv/opencv/wiki/How_to_contribute).
 
+Please:
+
+* Read the documentation to test with the latest developer build.
+* Check if other person has already created the same issue to avoid duplicates. You can comment on it if there already is an issue.
+* Try to be as detailed as possible in your report.
+* Report only one problem per created issue.
+
+
 This is a template helping you to create an issue which can be processed as quickly as possible. This is the bug reporting section for the OpenCV library.
 -->
 
@@ -27,4 +35,4 @@ This is a template helping you to create an issue which can be processed as quic
     // C++ code example
     ```
  or attach as .txt or .zip file
--->
+-->

3rdparty/carotene/hal/CMakeLists.txt

@@ -12,6 +12,8 @@ elseif (CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64.*|AARCH64.*")
   set(AARCH64 TRUE)
 endif()
 
+ocv_warnings_disable(CMAKE_CXX_FLAGS -Wunused-function)
+
 set(TEGRA_COMPILER_FLAGS "")
 
 if(CV_GCC OR CV_CLANG)

3rdparty/carotene/hal/tegra_hal.hpp

@@ -1127,7 +1127,6 @@ inline int TEGRA_FILTERINIT(cvhalFilter2D **context, uchar *kernel_data, size_t
         {
             std::memcpy(ctx->kernel_data + kernel_width * j, kernel_data + kernel_step * j, kernel_width * sizeof(int16_t));
         }
-        break;
     default:
         delete[] ctx->kernel_data;
         delete ctx;
@@ -1244,7 +1243,6 @@ inline int TEGRA_SEPFILTERINIT(cvhalFilter2D **context, int src_type, int dst_ty
         ctx->kernely_data[0]=((int16_t*)kernely_data)[0];
         ctx->kernely_data[1]=((int16_t*)kernely_data)[1];
         ctx->kernely_data[2]=((int16_t*)kernely_data)[2];
-        break;
     default:
         delete ctx;
         return CV_HAL_ERROR_NOT_IMPLEMENTED;

3rdparty/carotene/src/colorconvert.cpp

@@ -49,12 +49,12 @@ namespace {
 
 enum
 {
-    SHIFT = 14,
+    SHIFT = 15,
     SHIFT_DELTA = 1 << (SHIFT - 1),
 
-    R2Y_BT601   = 4899,
-    G2Y_BT601   = 9617,
-    B2Y_BT601   = 1868,
+    R2Y_BT601   = 9798,
+    G2Y_BT601   = 19235,
+    B2Y_BT601   = 3735,
 
     R2Y_BT709   = 3483,
     G2Y_BT709   = 11718,

3rdparty/carotene/src/div.cpp

@@ -151,6 +151,10 @@ void div(const Size2D &size,
     typedef typename internal::VecTraits<T>::vec128 vec128;
     typedef typename internal::VecTraits<T>::vec64 vec64;
 
+#if defined(__GNUC__) && (defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L)
+    static_assert(std::numeric_limits<T>::is_integer, "template implementation is for integer types only");
+#endif
+
     if (scale == 0.0f ||
         (std::numeric_limits<T>::is_integer &&
          (scale * std::numeric_limits<T>::max()) <  1.0f &&
@@ -311,6 +315,10 @@ void recip(const Size2D &size,
     typedef typename internal::VecTraits<T>::vec128 vec128;
     typedef typename internal::VecTraits<T>::vec64 vec64;
 
+#if defined(__GNUC__) && (defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L)
+    static_assert(std::numeric_limits<T>::is_integer, "template implementation is for integer types only");
+#endif
+
     if (scale == 0.0f ||
         (std::numeric_limits<T>::is_integer &&
          scale <  1.0f &&
@@ -463,8 +471,6 @@ void div(const Size2D &size,
         return;
     }
 
-    float32x4_t v_zero = vdupq_n_f32(0.0f);
-
     size_t roiw128 = size.width >= 3 ? size.width - 3 : 0;
     size_t roiw64 = size.width >= 1 ? size.width - 1 : 0;
 
@@ -485,9 +491,7 @@ void div(const Size2D &size,
                 float32x4_t v_src0 = vld1q_f32(src0 + j);
                 float32x4_t v_src1 = vld1q_f32(src1 + j);
 
-                uint32x4_t v_mask = vceqq_f32(v_src1,v_zero);
-                vst1q_f32(dst + j, vreinterpretq_f32_u32(vbicq_u32(
-                                   vreinterpretq_u32_f32(vmulq_f32(v_src0, internal::vrecpq_f32(v_src1))), v_mask)));
+                vst1q_f32(dst + j, vmulq_f32(v_src0, internal::vrecpq_f32(v_src1)));
             }
 
             for (; j < roiw64; j += 2)
@@ -495,14 +499,12 @@ void div(const Size2D &size,
                 float32x2_t v_src0 = vld1_f32(src0 + j);
                 float32x2_t v_src1 = vld1_f32(src1 + j);
 
-                uint32x2_t v_mask = vceq_f32(v_src1,vget_low_f32(v_zero));
-                vst1_f32(dst + j, vreinterpret_f32_u32(vbic_u32(
-                                  vreinterpret_u32_f32(vmul_f32(v_src0, internal::vrecp_f32(v_src1))), v_mask)));
+                vst1_f32(dst + j, vmul_f32(v_src0, internal::vrecp_f32(v_src1)));
             }
 
             for (; j < size.width; j++)
             {
-                dst[j] = src1[j] ? src0[j] / src1[j] : 0.0f;
+                dst[j] = src0[j] / src1[j];
             }
         }
     }
@@ -523,10 +525,8 @@ void div(const Size2D &size,
                 float32x4_t v_src0 = vld1q_f32(src0 + j);
                 float32x4_t v_src1 = vld1q_f32(src1 + j);
 
-                uint32x4_t v_mask = vceqq_f32(v_src1,v_zero);
-                vst1q_f32(dst + j, vreinterpretq_f32_u32(vbicq_u32(
-                                   vreinterpretq_u32_f32(vmulq_f32(vmulq_n_f32(v_src0, scale),
-                                                         internal::vrecpq_f32(v_src1))), v_mask)));
+                vst1q_f32(dst + j, vmulq_f32(vmulq_n_f32(v_src0, scale),
+                                             internal::vrecpq_f32(v_src1)));
             }
 
             for (; j < roiw64; j += 2)
@@ -534,15 +534,13 @@ void div(const Size2D &size,
                 float32x2_t v_src0 = vld1_f32(src0 + j);
                 float32x2_t v_src1 = vld1_f32(src1 + j);
 
-                uint32x2_t v_mask = vceq_f32(v_src1,vget_low_f32(v_zero));
-                vst1_f32(dst + j, vreinterpret_f32_u32(vbic_u32(
-                                  vreinterpret_u32_f32(vmul_f32(vmul_n_f32(v_src0, scale),
-                                                                internal::vrecp_f32(v_src1))), v_mask)));
+                vst1_f32(dst + j, vmul_f32(vmul_n_f32(v_src0, scale),
+                                           internal::vrecp_f32(v_src1)));
             }
 
             for (; j < size.width; j++)
             {
-                dst[j] = src1[j] ? src0[j] * scale / src1[j] : 0.0f;
+                dst[j] = src0[j] * scale / src1[j];
             }
         }
     }
@@ -620,8 +618,6 @@ void reciprocal(const Size2D &size,
         return;
     }
 
-    float32x4_t v_zero = vdupq_n_f32(0.0f);
-
     size_t roiw128 = size.width >= 3 ? size.width - 3 : 0;
     size_t roiw64 = size.width >= 1 ? size.width - 1 : 0;
 
@@ -639,23 +635,19 @@ void reciprocal(const Size2D &size,
 
                 float32x4_t v_src1 = vld1q_f32(src1 + j);
 
-                uint32x4_t v_mask = vceqq_f32(v_src1,v_zero);
-                vst1q_f32(dst + j, vreinterpretq_f32_u32(vbicq_u32(
-                                   vreinterpretq_u32_f32(internal::vrecpq_f32(v_src1)), v_mask)));
+                vst1q_f32(dst + j, internal::vrecpq_f32(v_src1));
             }
 
             for (; j < roiw64; j += 2)
             {
                 float32x2_t v_src1 = vld1_f32(src1 + j);
 
-                uint32x2_t v_mask = vceq_f32(v_src1,vget_low_f32(v_zero));
-                vst1_f32(dst + j, vreinterpret_f32_u32(vbic_u32(
-                                  vreinterpret_u32_f32(internal::vrecp_f32(v_src1)), v_mask)));
+                vst1_f32(dst + j, internal::vrecp_f32(v_src1));
             }
 
             for (; j < size.width; j++)
             {
-                dst[j] = src1[j] ? 1.0f / src1[j] : 0;
+                dst[j] = 1.0f / src1[j];
             }
         }
     }
@@ -673,25 +665,19 @@ void reciprocal(const Size2D &size,
 
                 float32x4_t v_src1 = vld1q_f32(src1 + j);
 
-                uint32x4_t v_mask = vceqq_f32(v_src1,v_zero);
-                vst1q_f32(dst + j, vreinterpretq_f32_u32(vbicq_u32(
-                                   vreinterpretq_u32_f32(vmulq_n_f32(internal::vrecpq_f32(v_src1),
-                                                                     scale)),v_mask)));
+                vst1q_f32(dst + j, vmulq_n_f32(internal::vrecpq_f32(v_src1), scale));
             }
 
             for (; j < roiw64; j += 2)
             {
                 float32x2_t v_src1 = vld1_f32(src1 + j);
 
-                uint32x2_t v_mask = vceq_f32(v_src1,vget_low_f32(v_zero));
-                vst1_f32(dst + j, vreinterpret_f32_u32(vbic_u32(
-                                  vreinterpret_u32_f32(vmul_n_f32(internal::vrecp_f32(v_src1),
-                                                                  scale)), v_mask)));
+                vst1_f32(dst + j, vmul_n_f32(internal::vrecp_f32(v_src1), scale));
             }
 
             for (; j < size.width; j++)
             {
-                dst[j] = src1[j] ? scale / src1[j] : 0;
+                dst[j] = scale / src1[j];
             }
         }
     }

3rdparty/cpufeatures/cpu-features.h

@@ -30,6 +30,7 @@
 
 #include <sys/cdefs.h>
 #include <stdint.h>
+#include <string.h>
 
 __BEGIN_DECLS
 

3rdparty/ffmpeg/ffmpeg-download.ps1.in

@@ -1,6 +1,6 @@
-$url = "https://raw.githubusercontent.com/opencv/opencv_3rdparty/@FFMPEG_BINARIES_COMMIT@/ffmpeg/opencv_ffmpeg_64.dll"
+$url = "https://raw.githubusercontent.com/opencv/opencv_3rdparty/@FFMPEG_BINARIES_COMMIT@/ffmpeg/opencv_videoio_ffmpeg_64.dll"
 $expected_md5 = "@FFMPEG_FILE_HASH_BIN64@"
-$output = "$PSScriptRoot\@OPENCV_BIN_INSTALL_PATH@\opencv_ffmpeg@OPENCV_DLLVERSION@_64.dll"
+$output = "$PSScriptRoot\@OPENCV_BIN_INSTALL_PATH@\opencv_videoio_ffmpeg@OPENCV_DLLVERSION@_64.dll"
 
 Write-Output ("=" * 120)
 try {

3rdparty/ffmpeg/ffmpeg.cmake

@@ -1,16 +1,16 @@
-# Binaries branch name: ffmpeg/3.4_20190905
-# Binaries were created for OpenCV: fafada28ebc0f2e5423a7d8ece425574ef01ff60
-ocv_update(FFMPEG_BINARIES_COMMIT "bf1730f4c4ba1996bed1fe268b52e4e942151cd6")
-ocv_update(FFMPEG_FILE_HASH_BIN32 "6899624f88cb4cbb1604edc5e12b18ab")
-ocv_update(FFMPEG_FILE_HASH_BIN64 "4729c052cb0c53ab56e9a0eed91559df")
-ocv_update(FFMPEG_FILE_HASH_CMAKE "3b90f67f4b429e77d3da36698cef700c")
+# Binaries branch name: ffmpeg/master_20190616
+# Binaries were created for OpenCV: 7b099e0fe2d929e55d6705b6ad510c2c9081606b
+ocv_update(FFMPEG_BINARIES_COMMIT "998718df34e35ea0fa429724875fc3900faa266f")
+ocv_update(FFMPEG_FILE_HASH_BIN32 "f03b47fb809edd2e06b6db135cbd3e49")
+ocv_update(FFMPEG_FILE_HASH_BIN64 "5c4571459570c288d874704244c428b5")
+ocv_update(FFMPEG_FILE_HASH_CMAKE "f710891525a04586d565d0e700e62a9c")
 
 function(download_win_ffmpeg script_var)
   set(${script_var} "" PARENT_SCOPE)
 
   set(ids BIN32 BIN64 CMAKE)
-  set(name_BIN32 "opencv_ffmpeg.dll")
-  set(name_BIN64 "opencv_ffmpeg_64.dll")
+  set(name_BIN32 "opencv_videoio_ffmpeg.dll")
+  set(name_BIN64 "opencv_videoio_ffmpeg_64.dll")
   set(name_CMAKE "ffmpeg_version.cmake")
 
   set(FFMPEG_DOWNLOAD_DIR "${OpenCV_BINARY_DIR}/3rdparty/ffmpeg")

3rdparty/ffmpeg/readme.txt

@@ -13,10 +13,10 @@
 
 * On Windows OpenCV uses pre-built ffmpeg binaries, built with proper flags (without GPL components) and
   wrapped with simple, stable OpenCV-compatible API.
-  The binaries are opencv_ffmpeg.dll (version for 32-bit Windows) and
-  opencv_ffmpeg_64.dll (version for 64-bit Windows).
+  The binaries are opencv_videoio_ffmpeg.dll (version for 32-bit Windows) and
+  opencv_videoio_ffmpeg_64.dll (version for 64-bit Windows).
 
-  The pre-built opencv_ffmpeg*.dll is:
+  The pre-built opencv_videoio_ffmpeg*.dll is:
   * LGPL library, not BSD libraries.
   * Loaded at runtime by opencv_videoio module.
     If it succeeds, ffmpeg can be used to decode/encode videos;
@@ -30,7 +30,7 @@
   Or you can specify location of binary file via OPENH264_LIBRARY environment variable.
 
   If LGPL/GPL software can not be supplied with your OpenCV-based product, simply exclude
-  opencv_ffmpeg*.dll from your distribution; OpenCV will stay fully functional except for the ability to
+  opencv_videoio_ffmpeg*.dll from your distribution; OpenCV will stay fully functional except for the ability to
   decode/encode videos using FFMPEG (though, it may still be able to do that using other API,
   such as Video for Windows, Windows Media Foundation or our self-contained motion jpeg codec).
 

3rdparty/include/vulkan/vk_platform.h

@@ -0,0 +1,92 @@
+//
+// File: vk_platform.h
+//
+/*
+** Copyright (c) 2014-2017 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+
+#ifndef VK_PLATFORM_H_
+#define VK_PLATFORM_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif // __cplusplus
+
+/*
+***************************************************************************************************
+*   Platform-specific directives and type declarations
+***************************************************************************************************
+*/
+
+/* Platform-specific calling convention macros.
+ *
+ * Platforms should define these so that Vulkan clients call Vulkan commands
+ * with the same calling conventions that the Vulkan implementation expects.
+ *
+ * VKAPI_ATTR - Placed before the return type in function declarations.
+ *              Useful for C++11 and GCC/Clang-style function attribute syntax.
+ * VKAPI_CALL - Placed after the return type in function declarations.
+ *              Useful for MSVC-style calling convention syntax.
+ * VKAPI_PTR  - Placed between the '(' and '*' in function pointer types.
+ *
+ * Function declaration:  VKAPI_ATTR void VKAPI_CALL vkCommand(void);
+ * Function pointer type: typedef void (VKAPI_PTR *PFN_vkCommand)(void);
+ */
+#if defined(_WIN32)
+    // On Windows, Vulkan commands use the stdcall convention
+    #define VKAPI_ATTR
+    #define VKAPI_CALL __stdcall
+    #define VKAPI_PTR  VKAPI_CALL
+#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7
+    #error "Vulkan isn't supported for the 'armeabi' NDK ABI"
+#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE)
+    // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat"
+    // calling convention, i.e. float parameters are passed in registers. This
+    // is true even if the rest of the application passes floats on the stack,
+    // as it does by default when compiling for the armeabi-v7a NDK ABI.
+    #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp")))
+    #define VKAPI_CALL
+    #define VKAPI_PTR  VKAPI_ATTR
+#else
+    // On other platforms, use the default calling convention
+    #define VKAPI_ATTR
+    #define VKAPI_CALL
+    #define VKAPI_PTR
+#endif
+
+#include <stddef.h>
+
+#if !defined(VK_NO_STDINT_H)
+    #if defined(_MSC_VER) && (_MSC_VER < 1600)
+        typedef signed   __int8  int8_t;
+        typedef unsigned __int8  uint8_t;
+        typedef signed   __int16 int16_t;
+        typedef unsigned __int16 uint16_t;
+        typedef signed   __int32 int32_t;
+        typedef unsigned __int32 uint32_t;
+        typedef signed   __int64 int64_t;
+        typedef unsigned __int64 uint64_t;
+    #else
+        #include <stdint.h>
+    #endif
+#endif // !defined(VK_NO_STDINT_H)
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus
+
+#endif

3rdparty/include/vulkan/vulkan.h

@@ -0,0 +1,83 @@
+#ifndef VULKAN_H_
+#define VULKAN_H_ 1
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#include "vk_platform.h"
+#include "vulkan_core.h"
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+#include "vulkan_android.h"
+#endif
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+#include <zircon/types.h>
+#include "vulkan_fuchsia.h"
+#endif
+
+#ifdef VK_USE_PLATFORM_IOS_MVK
+#include "vulkan_ios.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+#include "vulkan_macos.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_MIR_KHR
+#include <mir_toolkit/client_types.h>
+#include "vulkan_mir.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_VI_NN
+#include "vulkan_vi.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+#include <wayland-client.h>
+#include "vulkan_wayland.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+#include <windows.h>
+#include "vulkan_win32.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+#include <xcb/xcb.h>
+#include "vulkan_xcb.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+#include <X11/Xlib.h>
+#include "vulkan_xlib.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+#include <X11/Xlib.h>
+#include <X11/extensions/Xrandr.h>
+#include "vulkan_xlib_xrandr.h"
+#endif
+
+#endif // VULKAN_H_

3rdparty/include/vulkan/vulkan_android.h

@@ -0,0 +1,126 @@
+#ifndef VULKAN_ANDROID_H_
+#define VULKAN_ANDROID_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_KHR_android_surface 1
+struct ANativeWindow;
+
+#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6
+#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface"
+
+typedef VkFlags VkAndroidSurfaceCreateFlagsKHR;
+
+typedef struct VkAndroidSurfaceCreateInfoKHR {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkAndroidSurfaceCreateFlagsKHR    flags;
+    struct ANativeWindow*             window;
+} VkAndroidSurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
+    VkInstance                                  instance,
+    const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#define VK_ANDROID_external_memory_android_hardware_buffer 1
+struct AHardwareBuffer;
+
+#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 3
+#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME "VK_ANDROID_external_memory_android_hardware_buffer"
+
+typedef struct VkAndroidHardwareBufferUsageANDROID {
+    VkStructureType    sType;
+    void*              pNext;
+    uint64_t           androidHardwareBufferUsage;
+} VkAndroidHardwareBufferUsageANDROID;
+
+typedef struct VkAndroidHardwareBufferPropertiesANDROID {
+    VkStructureType    sType;
+    void*              pNext;
+    VkDeviceSize       allocationSize;
+    uint32_t           memoryTypeBits;
+} VkAndroidHardwareBufferPropertiesANDROID;
+
+typedef struct VkAndroidHardwareBufferFormatPropertiesANDROID {
+    VkStructureType                  sType;
+    void*                            pNext;
+    VkFormat                         format;
+    uint64_t                         externalFormat;
+    VkFormatFeatureFlags             formatFeatures;
+    VkComponentMapping               samplerYcbcrConversionComponents;
+    VkSamplerYcbcrModelConversion    suggestedYcbcrModel;
+    VkSamplerYcbcrRange              suggestedYcbcrRange;
+    VkChromaLocation                 suggestedXChromaOffset;
+    VkChromaLocation                 suggestedYChromaOffset;
+} VkAndroidHardwareBufferFormatPropertiesANDROID;
+
+typedef struct VkImportAndroidHardwareBufferInfoANDROID {
+    VkStructureType            sType;
+    const void*                pNext;
+    struct AHardwareBuffer*    buffer;
+} VkImportAndroidHardwareBufferInfoANDROID;
+
+typedef struct VkMemoryGetAndroidHardwareBufferInfoANDROID {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkDeviceMemory     memory;
+} VkMemoryGetAndroidHardwareBufferInfoANDROID;
+
+typedef struct VkExternalFormatANDROID {
+    VkStructureType    sType;
+    void*              pNext;
+    uint64_t           externalFormat;
+} VkExternalFormatANDROID;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID(
+    VkDevice                                    device,
+    const struct AHardwareBuffer*               buffer,
+    VkAndroidHardwareBufferPropertiesANDROID*   pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID(
+    VkDevice                                    device,
+    const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
+    struct AHardwareBuffer**                    pBuffer);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

3rdparty/include/vulkan/vulkan_fuchsia.h

@@ -0,0 +1,58 @@
+#ifndef VULKAN_FUCHSIA_H_
+#define VULKAN_FUCHSIA_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_FUCHSIA_imagepipe_surface 1
+#define VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION 1
+#define VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME "VK_FUCHSIA_imagepipe_surface"
+
+typedef VkFlags VkImagePipeSurfaceCreateFlagsFUCHSIA;
+
+typedef struct VkImagePipeSurfaceCreateInfoFUCHSIA {
+    VkStructureType                         sType;
+    const void*                             pNext;
+    VkImagePipeSurfaceCreateFlagsFUCHSIA    flags;
+    zx_handle_t                             imagePipeHandle;
+} VkImagePipeSurfaceCreateInfoFUCHSIA;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateImagePipeSurfaceFUCHSIA)(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA(
+    VkInstance                                  instance,
+    const VkImagePipeSurfaceCreateInfoFUCHSIA*  pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

3rdparty/include/vulkan/vulkan_ios.h

@@ -0,0 +1,58 @@
+#ifndef VULKAN_IOS_H_
+#define VULKAN_IOS_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_MVK_ios_surface 1
+#define VK_MVK_IOS_SURFACE_SPEC_VERSION   2
+#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface"
+
+typedef VkFlags VkIOSSurfaceCreateFlagsMVK;
+
+typedef struct VkIOSSurfaceCreateInfoMVK {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkIOSSurfaceCreateFlagsMVK    flags;
+    const void*                   pView;
+} VkIOSSurfaceCreateInfoMVK;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(
+    VkInstance                                  instance,
+    const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

3rdparty/include/vulkan/vulkan_macos.h

@@ -0,0 +1,58 @@
+#ifndef VULKAN_MACOS_H_
+#define VULKAN_MACOS_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_MVK_macos_surface 1
+#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 2
+#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface"
+
+typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
+
+typedef struct VkMacOSSurfaceCreateInfoMVK {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkMacOSSurfaceCreateFlagsMVK    flags;
+    const void*                     pView;
+} VkMacOSSurfaceCreateInfoMVK;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(
+    VkInstance                                  instance,
+    const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

3rdparty/include/vulkan/vulkan_mir.h

@@ -0,0 +1,65 @@
+#ifndef VULKAN_MIR_H_
+#define VULKAN_MIR_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_KHR_mir_surface 1
+#define VK_KHR_MIR_SURFACE_SPEC_VERSION   4
+#define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface"
+
+typedef VkFlags VkMirSurfaceCreateFlagsKHR;
+
+typedef struct VkMirSurfaceCreateInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkMirSurfaceCreateFlagsKHR    flags;
+    MirConnection*                connection;
+    MirSurface*                   mirSurface;
+} VkMirSurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR(
+    VkInstance                                  instance,
+    const VkMirSurfaceCreateInfoKHR*            pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    MirConnection*                              connection);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

3rdparty/include/vulkan/vulkan_vi.h

@@ -0,0 +1,58 @@
+#ifndef VULKAN_VI_H_
+#define VULKAN_VI_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_NN_vi_surface 1
+#define VK_NN_VI_SURFACE_SPEC_VERSION     1
+#define VK_NN_VI_SURFACE_EXTENSION_NAME   "VK_NN_vi_surface"
+
+typedef VkFlags VkViSurfaceCreateFlagsNN;
+
+typedef struct VkViSurfaceCreateInfoNN {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkViSurfaceCreateFlagsNN    flags;
+    void*                       window;
+} VkViSurfaceCreateInfoNN;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(
+    VkInstance                                  instance,
+    const VkViSurfaceCreateInfoNN*              pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

3rdparty/include/vulkan/vulkan_wayland.h

@@ -0,0 +1,65 @@
+#ifndef VULKAN_WAYLAND_H_
+#define VULKAN_WAYLAND_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_KHR_wayland_surface 1
+#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6
+#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface"
+
+typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
+
+typedef struct VkWaylandSurfaceCreateInfoKHR {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkWaylandSurfaceCreateFlagsKHR    flags;
+    struct wl_display*                display;
+    struct wl_surface*                surface;
+} VkWaylandSurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(
+    VkInstance                                  instance,
+    const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    struct wl_display*                          display);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

3rdparty/include/vulkan/vulkan_win32.h

@@ -0,0 +1,276 @@
+#ifndef VULKAN_WIN32_H_
+#define VULKAN_WIN32_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_KHR_win32_surface 1
+#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6
+#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
+
+typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
+
+typedef struct VkWin32SurfaceCreateInfoKHR {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkWin32SurfaceCreateFlagsKHR    flags;
+    HINSTANCE                       hinstance;
+    HWND                            hwnd;
+} VkWin32SurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
+    VkInstance                                  instance,
+    const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex);
+#endif
+
+#define VK_KHR_external_memory_win32 1
+#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32"
+
+typedef struct VkImportMemoryWin32HandleInfoKHR {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+    HANDLE                                handle;
+    LPCWSTR                               name;
+} VkImportMemoryWin32HandleInfoKHR;
+
+typedef struct VkExportMemoryWin32HandleInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    const SECURITY_ATTRIBUTES*    pAttributes;
+    DWORD                         dwAccess;
+    LPCWSTR                       name;
+} VkExportMemoryWin32HandleInfoKHR;
+
+typedef struct VkMemoryWin32HandlePropertiesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           memoryTypeBits;
+} VkMemoryWin32HandlePropertiesKHR;
+
+typedef struct VkMemoryGetWin32HandleInfoKHR {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkDeviceMemory                        memory;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+} VkMemoryGetWin32HandleInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(
+    VkDevice                                    device,
+    const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
+    HANDLE*                                     pHandle);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(
+    VkDevice                                    device,
+    VkExternalMemoryHandleTypeFlagBits          handleType,
+    HANDLE                                      handle,
+    VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties);
+#endif
+
+#define VK_KHR_win32_keyed_mutex 1
+#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1
+#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex"
+
+typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
+    VkStructureType          sType;
+    const void*              pNext;
+    uint32_t                 acquireCount;
+    const VkDeviceMemory*    pAcquireSyncs;
+    const uint64_t*          pAcquireKeys;
+    const uint32_t*          pAcquireTimeouts;
+    uint32_t                 releaseCount;
+    const VkDeviceMemory*    pReleaseSyncs;
+    const uint64_t*          pReleaseKeys;
+} VkWin32KeyedMutexAcquireReleaseInfoKHR;
+
+
+
+#define VK_KHR_external_semaphore_win32 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32"
+
+typedef struct VkImportSemaphoreWin32HandleInfoKHR {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkSemaphore                              semaphore;
+    VkSemaphoreImportFlags                   flags;
+    VkExternalSemaphoreHandleTypeFlagBits    handleType;
+    HANDLE                                   handle;
+    LPCWSTR                                  name;
+} VkImportSemaphoreWin32HandleInfoKHR;
+
+typedef struct VkExportSemaphoreWin32HandleInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    const SECURITY_ATTRIBUTES*    pAttributes;
+    DWORD                         dwAccess;
+    LPCWSTR                       name;
+} VkExportSemaphoreWin32HandleInfoKHR;
+
+typedef struct VkD3D12FenceSubmitInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           waitSemaphoreValuesCount;
+    const uint64_t*    pWaitSemaphoreValues;
+    uint32_t           signalSemaphoreValuesCount;
+    const uint64_t*    pSignalSemaphoreValues;
+} VkD3D12FenceSubmitInfoKHR;
+
+typedef struct VkSemaphoreGetWin32HandleInfoKHR {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkSemaphore                              semaphore;
+    VkExternalSemaphoreHandleTypeFlagBits    handleType;
+} VkSemaphoreGetWin32HandleInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(
+    VkDevice                                    device,
+    const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
+    VkDevice                                    device,
+    const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
+    HANDLE*                                     pHandle);
+#endif
+
+#define VK_KHR_external_fence_win32 1
+#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32"
+
+typedef struct VkImportFenceWin32HandleInfoKHR {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkFence                              fence;
+    VkFenceImportFlags                   flags;
+    VkExternalFenceHandleTypeFlagBits    handleType;
+    HANDLE                               handle;
+    LPCWSTR                              name;
+} VkImportFenceWin32HandleInfoKHR;
+
+typedef struct VkExportFenceWin32HandleInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    const SECURITY_ATTRIBUTES*    pAttributes;
+    DWORD                         dwAccess;
+    LPCWSTR                       name;
+} VkExportFenceWin32HandleInfoKHR;
+
+typedef struct VkFenceGetWin32HandleInfoKHR {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkFence                              fence;
+    VkExternalFenceHandleTypeFlagBits    handleType;
+} VkFenceGetWin32HandleInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(
+    VkDevice                                    device,
+    const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
+    VkDevice                                    device,
+    const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
+    HANDLE*                                     pHandle);
+#endif
+
+#define VK_NV_external_memory_win32 1
+#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
+#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
+
+typedef struct VkImportMemoryWin32HandleInfoNV {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkExternalMemoryHandleTypeFlagsNV    handleType;
+    HANDLE                               handle;
+} VkImportMemoryWin32HandleInfoNV;
+
+typedef struct VkExportMemoryWin32HandleInfoNV {
+    VkStructureType               sType;
+    const void*                   pNext;
+    const SECURITY_ATTRIBUTES*    pAttributes;
+    DWORD                         dwAccess;
+} VkExportMemoryWin32HandleInfoNV;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
+    VkDevice                                    device,
+    VkDeviceMemory                              memory,
+    VkExternalMemoryHandleTypeFlagsNV           handleType,
+    HANDLE*                                     pHandle);
+#endif
+
+#define VK_NV_win32_keyed_mutex 1
+#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1
+#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
+
+typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
+    VkStructureType          sType;
+    const void*              pNext;
+    uint32_t                 acquireCount;
+    const VkDeviceMemory*    pAcquireSyncs;
+    const uint64_t*          pAcquireKeys;
+    const uint32_t*          pAcquireTimeoutMilliseconds;
+    uint32_t                 releaseCount;
+    const VkDeviceMemory*    pReleaseSyncs;
+    const uint64_t*          pReleaseKeys;
+} VkWin32KeyedMutexAcquireReleaseInfoNV;
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

3rdparty/include/vulkan/vulkan_xcb.h

@@ -0,0 +1,66 @@
+#ifndef VULKAN_XCB_H_
+#define VULKAN_XCB_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_KHR_xcb_surface 1
+#define VK_KHR_XCB_SURFACE_SPEC_VERSION   6
+#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface"
+
+typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
+
+typedef struct VkXcbSurfaceCreateInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkXcbSurfaceCreateFlagsKHR    flags;
+    xcb_connection_t*             connection;
+    xcb_window_t                  window;
+} VkXcbSurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
+    VkInstance                                  instance,
+    const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    xcb_connection_t*                           connection,
+    xcb_visualid_t                              visual_id);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

3rdparty/include/vulkan/vulkan_xlib.h

@@ -0,0 +1,66 @@
+#ifndef VULKAN_XLIB_H_
+#define VULKAN_XLIB_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_KHR_xlib_surface 1
+#define VK_KHR_XLIB_SURFACE_SPEC_VERSION  6
+#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface"
+
+typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
+
+typedef struct VkXlibSurfaceCreateInfoKHR {
+    VkStructureType                sType;
+    const void*                    pNext;
+    VkXlibSurfaceCreateFlagsKHR    flags;
+    Display*                       dpy;
+    Window                         window;
+} VkXlibSurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
+    VkInstance                                  instance,
+    const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    Display*                                    dpy,
+    VisualID                                    visualID);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

3rdparty/include/vulkan/vulkan_xlib_xrandr.h

@@ -0,0 +1,54 @@
+#ifndef VULKAN_XLIB_XRANDR_H_
+#define VULKAN_XLIB_XRANDR_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_EXT_acquire_xlib_display 1
+#define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1
+#define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display"
+
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display);
+typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(
+    VkPhysicalDevice                            physicalDevice,
+    Display*                                    dpy,
+    VkDisplayKHR                                display);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(
+    VkPhysicalDevice                            physicalDevice,
+    Display*                                    dpy,
+    RROutput                                    rrOutput,
+    VkDisplayKHR*                               pDisplay);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

3rdparty/libjasper/jasper/jas_config.h

@@ -17,12 +17,6 @@
 #if !defined(JAS_WIN_MSVC_BUILD)
 /* A configure-based build is being used. */
 
-#include <stdio.h>
-
-// uClibc-ng workaround: https://github.com/opencv/opencv/pull/15279
-#ifndef L_tmpnam
-#define L_tmpnam 20
-#endif
 
 
 /* Extra debugging support */

3rdparty/libjpeg/CMakeLists.txt

@@ -15,6 +15,13 @@ else()
   ocv_list_filterout(lib_srcs jmemnobs.c)
 endif()
 
+if(WINRT)
+    add_definitions(-DNO_GETENV)
+    get_directory_property( DirDefs COMPILE_DEFINITIONS )
+    message(STATUS "Adding NO_GETENV to compiler definitions for WINRT:")
+    message(STATUS "   COMPILE_DEFINITIONS = ${DirDefs}")
+endif()
+
 # ----------------------------------------------------------------------------------
 #         Define the library target:
 # ----------------------------------------------------------------------------------

3rdparty/libpng/CMakeLists.txt

@@ -46,19 +46,8 @@ if(";${CPU_BASELINE_FINAL};" MATCHES "SSE2"
   add_definitions(-DPNG_INTEL_SSE)
 endif()
 
-# set definitions and sources for MIPS
-if(";${CPU_BASELINE_FINAL};" MATCHES "MSA")
-    list(APPEND lib_srcs mips/mips_init.c mips/filter_msa_intrinsics.c)
-    add_definitions(-DPNG_MIPS_MSA_OPT=2)
-    ocv_warnings_disable(CMAKE_C_FLAGS -Wshadow)
-else()
-    add_definitions(-DPNG_MIPS_MSA_OPT=0)
-endif()
-
 if(PPC64LE OR PPC64)
-  # VSX3 features are backwards compatible
-  if(";${CPU_BASELINE_FINAL};" MATCHES "VSX.*"
-      AND NOT PPC64)
+  if(ENABLE_VSX AND NOT PPC64)
     list(APPEND lib_srcs powerpc/powerpc_init.c powerpc/filter_vsx_intrinsics.c)
     add_definitions(-DPNG_POWERPC_VSX_OPT=2)
   else()

3rdparty/libpng/mips/filter_msa_intrinsics.c

@@ -1,808 +0,0 @@
-
-/* filter_msa_intrinsics.c - MSA optimised filter functions
- *
- * Copyright (c) 2018 Cosmin Truta
- * Copyright (c) 2016 Glenn Randers-Pehrson
- * Written by Mandar Sahastrabuddhe, August 2016.
- *
- * This code is released under the libpng license.
- * For conditions of distribution and use, see the disclaimer
- * and license in png.h
- */
-
-#include <stdio.h>
-#include <stdint.h>
-#include "../pngpriv.h"
-
-#ifdef PNG_READ_SUPPORTED
-
-/* This code requires -mfpu=msa on the command line: */
-#if PNG_MIPS_MSA_IMPLEMENTATION == 1 /* intrinsics code from pngpriv.h */
-
-#include <msa.h>
-
-/* libpng row pointers are not necessarily aligned to any particular boundary,
- * however this code will only work with appropriate alignment. mips/mips_init.c
- * checks for this (and will not compile unless it is done). This code uses
- * variants of png_aligncast to avoid compiler warnings.
- */
-#define png_ptr(type,pointer) png_aligncast(type *,pointer)
-#define png_ptrc(type,pointer) png_aligncastconst(const type *,pointer)
-
-/* The following relies on a variable 'temp_pointer' being declared with type
- * 'type'.  This is written this way just to hide the GCC strict aliasing
- * warning; note that the code is safe because there never is an alias between
- * the input and output pointers.
- */
-#define png_ldr(type,pointer)\
-   (temp_pointer = png_ptr(type,pointer), *temp_pointer)
-
-#if PNG_MIPS_MSA_OPT > 0
-
-#ifdef CLANG_BUILD
-   #define MSA_SRLI_B(a, b)   __msa_srli_b((v16i8) a, b)
-
-   #define LW(psrc)                              \
-   ( {                                           \
-       uint8_t *psrc_lw_m = (uint8_t *) (psrc);  \
-       uint32_t val_m;                           \
-                                                 \
-       asm volatile (                            \
-           "lw  %[val_m],  %[psrc_lw_m]  \n\t"   \
-                                                 \
-           : [val_m] "=r" (val_m)                \
-           : [psrc_lw_m] "m" (*psrc_lw_m)        \
-       );                                        \
-                                                 \
-       val_m;                                    \
-   } )
-
-   #define SH(val, pdst)                         \
-   {                                             \
-       uint8_t *pdst_sh_m = (uint8_t *) (pdst);  \
-       uint16_t val_m = (val);                   \
-                                                 \
-       asm volatile (                            \
-           "sh  %[val_m],  %[pdst_sh_m]  \n\t"   \
-                                                 \
-           : [pdst_sh_m] "=m" (*pdst_sh_m)       \
-           : [val_m] "r" (val_m)                 \
-       );                                        \
-   }
-
-   #define SW(val, pdst)                         \
-   {                                             \
-       uint8_t *pdst_sw_m = (uint8_t *) (pdst);  \
-       uint32_t val_m = (val);                   \
-                                                 \
-       asm volatile (                            \
-           "sw  %[val_m],  %[pdst_sw_m]  \n\t"   \
-                                                 \
-           : [pdst_sw_m] "=m" (*pdst_sw_m)       \
-           : [val_m] "r" (val_m)                 \
-       );                                        \
-   }
-
-       #if (__mips == 64)
-        #define SD(val, pdst)                         \
-        {                                             \
-            uint8_t *pdst_sd_m = (uint8_t *) (pdst);  \
-            uint64_t val_m = (val);                   \
-                                                      \
-            asm volatile (                            \
-                "sd  %[val_m],  %[pdst_sd_m]  \n\t"   \
-                                                      \
-                : [pdst_sd_m] "=m" (*pdst_sd_m)       \
-                : [val_m] "r" (val_m)                 \
-            );                                        \
-        }
-    #else
-        #define SD(val, pdst)                                          \
-        {                                                              \
-            uint8_t *pdst_sd_m = (uint8_t *) (pdst);                   \
-            uint32_t val0_m, val1_m;                                   \
-                                                                       \
-            val0_m = (uint32_t) ((val) & 0x00000000FFFFFFFF);          \
-            val1_m = (uint32_t) (((val) >> 32) & 0x00000000FFFFFFFF);  \
-                                                                       \
-            SW(val0_m, pdst_sd_m);                                     \
-            SW(val1_m, pdst_sd_m + 4);                                 \
-        }
-    #endif
-#else
-   #define MSA_SRLI_B(a, b)   (a >> b)
-
-#if (__mips_isa_rev >= 6)
-   #define LW(psrc)                              \
-   ( {                                           \
-       uint8_t *psrc_lw_m = (uint8_t *) (psrc);  \
-       uint32_t val_m;                           \
-                                                 \
-       asm volatile (                            \
-           "lw  %[val_m],  %[psrc_lw_m]  \n\t"   \
-                                                 \
-           : [val_m] "=r" (val_m)                \
-           : [psrc_lw_m] "m" (*psrc_lw_m)        \
-       );                                        \
-                                                 \
-       val_m;                                    \
-   } )
-
-   #define SH(val, pdst)                         \
-   {                                             \
-       uint8_t *pdst_sh_m = (uint8_t *) (pdst);  \
-       uint16_t val_m = (val);                   \
-                                                 \
-       asm volatile (                            \
-           "sh  %[val_m],  %[pdst_sh_m]  \n\t"   \
-                                                 \
-           : [pdst_sh_m] "=m" (*pdst_sh_m)       \
-           : [val_m] "r" (val_m)                 \
-       );                                        \
-   }
-
-   #define SW(val, pdst)                         \
-   {                                             \
-       uint8_t *pdst_sw_m = (uint8_t *) (pdst);  \
-       uint32_t val_m = (val);                   \
-                                                 \
-       asm volatile (                            \
-           "sw  %[val_m],  %[pdst_sw_m]  \n\t"   \
-                                                 \
-           : [pdst_sw_m] "=m" (*pdst_sw_m)       \
-           : [val_m] "r" (val_m)                 \
-       );                                        \
-   }
-
-   #if (__mips == 64)
-        #define SD(val, pdst)                         \
-        {                                             \
-            uint8_t *pdst_sd_m = (uint8_t *) (pdst);  \
-            uint64_t val_m = (val);                   \
-                                                      \
-            asm volatile (                            \
-                "sd  %[val_m],  %[pdst_sd_m]  \n\t"   \
-                                                      \
-                : [pdst_sd_m] "=m" (*pdst_sd_m)       \
-                : [val_m] "r" (val_m)                 \
-            );                                        \
-        }
-    #else
-        #define SD(val, pdst)                                          \
-        {                                                              \
-            uint8_t *pdst_sd_m = (uint8_t *) (pdst);                   \
-            uint32_t val0_m, val1_m;                                   \
-                                                                       \
-            val0_m = (uint32_t) ((val) & 0x00000000FFFFFFFF);          \
-            val1_m = (uint32_t) (((val) >> 32) & 0x00000000FFFFFFFF);  \
-                                                                       \
-            SW(val0_m, pdst_sd_m);                                     \
-            SW(val1_m, pdst_sd_m + 4);                                 \
-        }
-    #endif
-#else  // !(__mips_isa_rev >= 6)
-   #define LW(psrc)                              \
-   ( {                                           \
-       uint8_t *psrc_lw_m = (uint8_t *) (psrc);  \
-       uint32_t val_m;                           \
-                                                 \
-       asm volatile (                            \
-           "ulw  %[val_m],  %[psrc_lw_m]  \n\t"  \
-                                                 \
-           : [val_m] "=r" (val_m)                \
-           : [psrc_lw_m] "m" (*psrc_lw_m)        \
-       );                                        \
-                                                 \
-       val_m;                                    \
-   } )
-
-   #define SH(val, pdst)                         \
-   {                                             \
-       uint8_t *pdst_sh_m = (uint8_t *) (pdst);  \
-       uint16_t val_m = (val);                   \
-                                                 \
-       asm volatile (                            \
-           "ush  %[val_m],  %[pdst_sh_m]  \n\t"  \
-                                                 \
-           : [pdst_sh_m] "=m" (*pdst_sh_m)       \
-           : [val_m] "r" (val_m)                 \
-       );                                        \
-   }
-
-   #define SW(val, pdst)                         \
-   {                                             \
-       uint8_t *pdst_sw_m = (uint8_t *) (pdst);  \
-       uint32_t val_m = (val);                   \
-                                                 \
-       asm volatile (                            \
-           "usw  %[val_m],  %[pdst_sw_m]  \n\t"  \
-                                                 \
-           : [pdst_sw_m] "=m" (*pdst_sw_m)       \
-           : [val_m] "r" (val_m)                 \
-       );                                        \
-   }
-
-   #define SD(val, pdst)                                          \
-    {                                                              \
-        uint8_t *pdst_sd_m = (uint8_t *) (pdst);                   \
-        uint32_t val0_m, val1_m;                                   \
-                                                                   \
-        val0_m = (uint32_t) ((val) & 0x00000000FFFFFFFF);          \
-        val1_m = (uint32_t) (((val) >> 32) & 0x00000000FFFFFFFF);  \
-                                                                   \
-        SW(val0_m, pdst_sd_m);                                     \
-        SW(val1_m, pdst_sd_m + 4);                                 \
-    }
-
-    #define SW_ZERO(pdst)                      \
-    {                                          \
-        uint8_t *pdst_m = (uint8_t *) (pdst);  \
-                                               \
-        asm volatile (                         \
-            "usw  $0,  %[pdst_m]  \n\t"        \
-                                               \
-            : [pdst_m] "=m" (*pdst_m)          \
-            :                                  \
-        );                                     \
-    }
-#endif  // (__mips_isa_rev >= 6)
-#endif
-
-#define LD_B(RTYPE, psrc) *((RTYPE *) (psrc))
-#define LD_UB(...) LD_B(v16u8, __VA_ARGS__)
-#define LD_B2(RTYPE, psrc, stride, out0, out1)  \
-{                                               \
-    out0 = LD_B(RTYPE, (psrc));                 \
-    out1 = LD_B(RTYPE, (psrc) + stride);        \
-}
-#define LD_UB2(...) LD_B2(v16u8, __VA_ARGS__)
-#define LD_B4(RTYPE, psrc, stride, out0, out1, out2, out3)   \
-{                                                            \
-    LD_B2(RTYPE, (psrc), stride, out0, out1);                \
-    LD_B2(RTYPE, (psrc) + 2 * stride , stride, out2, out3);  \
-}
-#define LD_UB4(...) LD_B4(v16u8, __VA_ARGS__)
-
-#define ST_B(RTYPE, in, pdst) *((RTYPE *) (pdst)) = (in)
-#define ST_UB(...) ST_B(v16u8, __VA_ARGS__)
-#define ST_B2(RTYPE, in0, in1, pdst, stride)  \
-{                                             \
-    ST_B(RTYPE, in0, (pdst));                 \
-    ST_B(RTYPE, in1, (pdst) + stride);        \
-}
-#define ST_UB2(...) ST_B2(v16u8, __VA_ARGS__)
-#define ST_B4(RTYPE, in0, in1, in2, in3, pdst, stride)    \
-{                                                         \
-    ST_B2(RTYPE, in0, in1, (pdst), stride);               \
-    ST_B2(RTYPE, in2, in3, (pdst) + 2 * stride, stride);  \
-}
-#define ST_UB4(...) ST_B4(v16u8, __VA_ARGS__)
-
-#define ADD2(in0, in1, in2, in3, out0, out1)  \
-{                                             \
-    out0 = in0 + in1;                         \
-    out1 = in2 + in3;                         \
-}
-#define ADD3(in0, in1, in2, in3, in4, in5,  \
-             out0, out1, out2)              \
-{                                           \
-    ADD2(in0, in1, in2, in3, out0, out1);   \
-    out2 = in4 + in5;                       \
-}
-#define ADD4(in0, in1, in2, in3, in4, in5, in6, in7,  \
-             out0, out1, out2, out3)                  \
-{                                                     \
-    ADD2(in0, in1, in2, in3, out0, out1);             \
-    ADD2(in4, in5, in6, in7, out2, out3);             \
-}
-
-#define ILVR_B2(RTYPE, in0, in1, in2, in3, out0, out1)      \
-{                                                           \
-    out0 = (RTYPE) __msa_ilvr_b((v16i8) in0, (v16i8) in1);  \
-    out1 = (RTYPE) __msa_ilvr_b((v16i8) in2, (v16i8) in3);  \
-}
-#define ILVR_B2_SH(...) ILVR_B2(v8i16, __VA_ARGS__)
-
-#define HSUB_UB2(RTYPE, in0, in1, out0, out1)                 \
-{                                                             \
-    out0 = (RTYPE) __msa_hsub_u_h((v16u8) in0, (v16u8) in0);  \
-    out1 = (RTYPE) __msa_hsub_u_h((v16u8) in1, (v16u8) in1);  \
-}
-#define HSUB_UB2_SH(...) HSUB_UB2(v8i16, __VA_ARGS__)
-
-#define SLDI_B2_0(RTYPE, in0, in1, out0, out1, slide_val)                 \
-{                                                                         \
-    v16i8 zero_m = { 0 };                                                 \
-    out0 = (RTYPE) __msa_sldi_b((v16i8) zero_m, (v16i8) in0, slide_val);  \
-    out1 = (RTYPE) __msa_sldi_b((v16i8) zero_m, (v16i8) in1, slide_val);  \
-}
-#define SLDI_B2_0_UB(...) SLDI_B2_0(v16u8, __VA_ARGS__)
-
-#define SLDI_B3_0(RTYPE, in0, in1, in2, out0, out1, out2,  slide_val)     \
-{                                                                         \
-    v16i8 zero_m = { 0 };                                                 \
-    SLDI_B2_0(RTYPE, in0, in1, out0, out1, slide_val);                    \
-    out2 = (RTYPE) __msa_sldi_b((v16i8) zero_m, (v16i8) in2, slide_val);  \
-}
-#define SLDI_B3_0_UB(...) SLDI_B3_0(v16u8, __VA_ARGS__)
-
-#define ILVEV_W2(RTYPE, in0, in1, in2, in3, out0, out1)      \
-{                                                            \
-    out0 = (RTYPE) __msa_ilvev_w((v4i32) in1, (v4i32) in0);  \
-    out1 = (RTYPE) __msa_ilvev_w((v4i32) in3, (v4i32) in2);  \
-}
-#define ILVEV_W2_UB(...) ILVEV_W2(v16u8, __VA_ARGS__)
-
-#define ADD_ABS_H3(RTYPE, in0, in1, in2, out0, out1, out2)  \
-{                                                           \
-    RTYPE zero = {0};                                       \
-                                                            \
-    out0 = __msa_add_a_h((v8i16) zero, in0);                \
-    out1 = __msa_add_a_h((v8i16) zero, in1);                \
-    out2 = __msa_add_a_h((v8i16) zero, in2);                \
-}
-#define ADD_ABS_H3_SH(...) ADD_ABS_H3(v8i16, __VA_ARGS__)
-
-#define VSHF_B2(RTYPE, in0, in1, in2, in3, mask0, mask1, out0, out1)       \
-{                                                                          \
-    out0 = (RTYPE) __msa_vshf_b((v16i8) mask0, (v16i8) in1, (v16i8) in0);  \
-    out1 = (RTYPE) __msa_vshf_b((v16i8) mask1, (v16i8) in3, (v16i8) in2);  \
-}
-#define VSHF_B2_UB(...) VSHF_B2(v16u8, __VA_ARGS__)
-
-#define CMP_AND_SELECT(inp0, inp1, inp2, inp3, inp4, inp5, out0)              \
-{                                                                             \
-   v8i16 _sel_h0, _sel_h1;                                                    \
-   v16u8 _sel_b0, _sel_b1;                                                    \
-   _sel_h0 = (v8i16) __msa_clt_u_h((v8u16) inp1, (v8u16) inp0);               \
-   _sel_b0 = (v16u8) __msa_pckev_b((v16i8) _sel_h0, (v16i8) _sel_h0);         \
-   inp0 = (v8i16) __msa_bmnz_v((v16u8) inp0, (v16u8) inp1, (v16u8) _sel_h0);  \
-   inp4 = (v16u8) __msa_bmnz_v(inp3, inp4, _sel_b0);                          \
-   _sel_h1 = (v8i16) __msa_clt_u_h((v8u16) inp2, (v8u16) inp0);               \
-   _sel_b1 = (v16u8) __msa_pckev_b((v16i8) _sel_h1, (v16i8) _sel_h1);         \
-   inp4 = (v16u8) __msa_bmnz_v(inp4, inp5, _sel_b1);                          \
-   out0 += inp4;                                                              \
-}
-
-void png_read_filter_row_up_msa(png_row_infop row_info, png_bytep row,
-                                png_const_bytep prev_row)
-{
-   size_t i, cnt, cnt16, cnt32;
-   size_t istop = row_info->rowbytes;
-   png_bytep rp = row;
-   png_const_bytep pp = prev_row;
-   v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
-
-   for (i = 0; i < (istop >> 6); i++)
-   {
-      LD_UB4(rp, 16, src0, src1, src2, src3);
-      LD_UB4(pp, 16, src4, src5, src6, src7);
-      pp += 64;
-
-	  ADD4(src0, src4, src1, src5, src2, src6, src3, src7,
-	       src0, src1, src2, src3);
-
-      ST_UB4(src0, src1, src2, src3, rp, 16);
-      rp += 64;
-   }
-
-   if (istop & 0x3F)
-   {
-      cnt32 = istop & 0x20;
-      cnt16 = istop & 0x10;
-      cnt = istop & 0xF;
-
-      if(cnt32)
-      {
-         if (cnt16 && cnt)
-         {
-            LD_UB4(rp, 16, src0, src1, src2, src3);
-            LD_UB4(pp, 16, src4, src5, src6, src7);
-
-            ADD4(src0, src4, src1, src5, src2, src6, src3, src7,
-	             src0, src1, src2, src3);
-
-            ST_UB4(src0, src1, src2, src3, rp, 16);
-            rp += 64;
-         }
-         else if (cnt16 || cnt)
-         {
-            LD_UB2(rp, 16, src0, src1);
-            LD_UB2(pp, 16, src4, src5);
-            pp += 32;
-            src2 = LD_UB(rp + 32);
-            src6 = LD_UB(pp);
-
-            ADD3(src0, src4, src1, src5, src2, src6, src0, src1, src2);
-
-            ST_UB2(src0, src1, rp, 16);
-            rp += 32;
-            ST_UB(src2, rp);
-            rp += 16;
-         }
-         else
-         {
-            LD_UB2(rp, 16, src0, src1);
-            LD_UB2(pp, 16, src4, src5);
-
-			ADD2(src0, src4, src1, src5, src0, src1);
-
-            ST_UB2(src0, src1, rp, 16);
-            rp += 32;
-         }
-      }
-      else if (cnt16 && cnt)
-      {
-         LD_UB2(rp, 16, src0, src1);
-         LD_UB2(pp, 16, src4, src5);
-
-         ADD2(src0, src4, src1, src5, src0, src1);
-
-         ST_UB2(src0, src1, rp, 16);
-         rp += 32;
-      }
-      else if (cnt16 || cnt)
-      {
-         src0 = LD_UB(rp);
-         src4 = LD_UB(pp);
-         pp += 16;
-
-         src0 += src4;
-
-         ST_UB(src0, rp);
-         rp += 16;
-      }
-   }
-}
-
-void png_read_filter_row_sub4_msa(png_row_infop row_info, png_bytep row,
-                                  png_const_bytep prev_row)
-{
-   size_t count;
-   size_t istop = row_info->rowbytes;
-   png_bytep src = row;
-   png_bytep nxt = row + 4;
-   int32_t inp0;
-   v16u8 src0, src1, src2, src3, src4;
-   v16u8 dst0, dst1;
-   v16u8 zero = { 0 };
-
-   istop -= 4;
-
-   inp0 = LW(src);
-   src += 4;
-   src0 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp0);
-
-   for (count = 0; count < istop; count += 16)
-   {
-      src1 = LD_UB(src);
-      src += 16;
-
-      src2 = (v16u8) __msa_sldi_b((v16i8) zero, (v16i8) src1, 4);
-      src3 = (v16u8) __msa_sldi_b((v16i8) zero, (v16i8) src1, 8);
-      src4 = (v16u8) __msa_sldi_b((v16i8) zero, (v16i8) src1, 12);
-      src1 += src0;
-      src2 += src1;
-      src3 += src2;
-      src4 += src3;
-      src0 = src4;
-      ILVEV_W2_UB(src1, src2, src3, src4, dst0, dst1);
-      dst0 = (v16u8) __msa_pckev_d((v2i64) dst1, (v2i64) dst0);
-
-      ST_UB(dst0, nxt);
-      nxt += 16;
-   }
-}
-
-void png_read_filter_row_sub3_msa(png_row_infop row_info, png_bytep row,
-                                  png_const_bytep prev_row)
-{
-   size_t count;
-   size_t istop = row_info->rowbytes;
-   png_bytep src = row;
-   png_bytep nxt = row + 3;
-   int64_t out0;
-   int32_t inp0, out1;
-   v16u8 src0, src1, src2, src3, src4, dst0, dst1;
-   v16u8 zero = { 0 };
-   v16i8 mask0 = { 0, 1, 2, 16, 17, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-   v16i8 mask1 = { 0, 1, 2, 3, 4, 5, 16, 17, 18, 19, 20, 21, 0, 0, 0, 0 };
-
-   istop -= 3;
-
-   inp0 = LW(src);
-   src += 3;
-   src0 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp0);
-
-   for (count = 0; count < istop; count += 12)
-   {
-      src1 = LD_UB(src);
-      src += 12;
-
-      src2 = (v16u8) __msa_sldi_b((v16i8) zero, (v16i8) src1, 3);
-      src3 = (v16u8) __msa_sldi_b((v16i8) zero, (v16i8) src1, 6);
-      src4 = (v16u8) __msa_sldi_b((v16i8) zero, (v16i8) src1, 9);
-      src1 += src0;
-      src2 += src1;
-      src3 += src2;
-      src4 += src3;
-      src0 = src4;
-      VSHF_B2_UB(src1, src2, src3, src4, mask0, mask0, dst0, dst1);
-      dst0 = (v16u8) __msa_vshf_b(mask1, (v16i8) dst1, (v16i8) dst0);
-      out0 = __msa_copy_s_d((v2i64) dst0, 0);
-      out1 = __msa_copy_s_w((v4i32) dst0, 2);
-
-      SD(out0, nxt);
-      nxt += 8;
-      SW(out1, nxt);
-      nxt += 4;
-   }
-}
-
-void png_read_filter_row_avg4_msa(png_row_infop row_info, png_bytep row,
-                                  png_const_bytep prev_row)
-{
-   size_t i;
-   png_bytep src = row;
-   png_bytep nxt = row;
-   png_const_bytep pp = prev_row;
-   size_t istop = row_info->rowbytes - 4;
-   int32_t inp0, inp1, out0;
-   v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, dst0, dst1;
-   v16u8 zero = { 0 };
-
-   inp0 = LW(pp);
-   pp += 4;
-   inp1 = LW(src);
-   src += 4;
-   src0 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp0);
-   src1 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp1);
-   src0 = (v16u8) MSA_SRLI_B(src0, 1);
-   src1 += src0;
-   out0 = __msa_copy_s_w((v4i32) src1, 0);
-   SW(out0, nxt);
-   nxt += 4;
-
-   for (i = 0; i < istop; i += 16)
-   {
-      src2 = LD_UB(pp);
-      pp += 16;
-      src6 = LD_UB(src);
-      src += 16;
-
-      SLDI_B2_0_UB(src2, src6, src3, src7, 4);
-      SLDI_B2_0_UB(src2, src6, src4, src8, 8);
-      SLDI_B2_0_UB(src2, src6, src5, src9, 12);
-      src2 = __msa_ave_u_b(src2, src1);
-      src6 += src2;
-      src3 = __msa_ave_u_b(src3, src6);
-      src7 += src3;
-      src4 = __msa_ave_u_b(src4, src7);
-      src8 += src4;
-      src5 = __msa_ave_u_b(src5, src8);
-      src9 += src5;
-      src1 = src9;
-      ILVEV_W2_UB(src6, src7, src8, src9, dst0, dst1);
-      dst0 = (v16u8) __msa_pckev_d((v2i64) dst1, (v2i64) dst0);
-
-      ST_UB(dst0, nxt);
-      nxt += 16;
-   }
-}
-
-void png_read_filter_row_avg3_msa(png_row_infop row_info, png_bytep row,
-                                  png_const_bytep prev_row)
-{
-   size_t i;
-   png_bytep src = row;
-   png_bytep nxt = row;
-   png_const_bytep pp = prev_row;
-   size_t istop = row_info->rowbytes - 3;
-   int64_t out0;
-   int32_t inp0, inp1, out1;
-   int16_t out2;
-   v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, dst0, dst1;
-   v16u8 zero = { 0 };
-   v16i8 mask0 = { 0, 1, 2, 16, 17, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-   v16i8 mask1 = { 0, 1, 2, 3, 4, 5, 16, 17, 18, 19, 20, 21, 0, 0, 0, 0 };
-
-   inp0 = LW(pp);
-   pp += 3;
-   inp1 = LW(src);
-   src += 3;
-   src0 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp0);
-   src1 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp1);
-   src0 = (v16u8) MSA_SRLI_B(src0, 1);
-   src1 += src0;
-   out2 = __msa_copy_s_h((v8i16) src1, 0);
-   SH(out2, nxt);
-   nxt += 2;
-   nxt[0] = src1[2];
-   nxt++;
-
-   for (i = 0; i < istop; i += 12)
-   {
-      src2 = LD_UB(pp);
-      pp += 12;
-      src6 = LD_UB(src);
-      src += 12;
-
-      SLDI_B2_0_UB(src2, src6, src3, src7, 3);
-      SLDI_B2_0_UB(src2, src6, src4, src8, 6);
-      SLDI_B2_0_UB(src2, src6, src5, src9, 9);
-      src2 = __msa_ave_u_b(src2, src1);
-      src6 += src2;
-      src3 = __msa_ave_u_b(src3, src6);
-      src7 += src3;
-      src4 = __msa_ave_u_b(src4, src7);
-      src8 += src4;
-      src5 = __msa_ave_u_b(src5, src8);
-      src9 += src5;
-      src1 = src9;
-      VSHF_B2_UB(src6, src7, src8, src9, mask0, mask0, dst0, dst1);
-      dst0 = (v16u8) __msa_vshf_b(mask1, (v16i8) dst1, (v16i8) dst0);
-      out0 = __msa_copy_s_d((v2i64) dst0, 0);
-      out1 = __msa_copy_s_w((v4i32) dst0, 2);
-
-      SD(out0, nxt);
-      nxt += 8;
-      SW(out1, nxt);
-      nxt += 4;
-   }
-}
-
-void png_read_filter_row_paeth4_msa(png_row_infop row_info,
-                                    png_bytep row,
-                                    png_const_bytep prev_row)
-{
-   int32_t count, rp_end;
-   png_bytep nxt;
-   png_const_bytep prev_nxt;
-   int32_t inp0, inp1, res0;
-   v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9;
-   v16u8 src10, src11, src12, src13, dst0, dst1;
-   v8i16 vec0, vec1, vec2;
-   v16u8 zero = { 0 };
-
-   nxt = row;
-   prev_nxt = prev_row;
-
-   inp0 = LW(nxt);
-   inp1 = LW(prev_nxt);
-   prev_nxt += 4;
-   src0 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp0);
-   src1 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp1);
-
-   src1 += src0;
-   res0 = __msa_copy_s_w((v4i32) src1, 0);
-
-   SW(res0, nxt);
-   nxt += 4;
-
-   /* Remainder */
-   rp_end = row_info->rowbytes - 4;
-
-   for (count = 0; count < rp_end; count += 16)
-   {
-      src2 = LD_UB(prev_nxt);
-      prev_nxt += 16;
-      src6 = LD_UB(prev_row);
-      prev_row += 16;
-      src10 = LD_UB(nxt);
-
-      SLDI_B3_0_UB(src2, src6, src10, src3, src7, src11, 4);
-      SLDI_B3_0_UB(src2, src6, src10, src4, src8, src12, 8);
-      SLDI_B3_0_UB(src2, src6, src10, src5, src9, src13, 12);
-      ILVR_B2_SH(src2, src6, src1, src6, vec0, vec1);
-      HSUB_UB2_SH(vec0, vec1, vec0, vec1);
-      vec2 = vec0 + vec1;
-      ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
-      CMP_AND_SELECT(vec0, vec1, vec2, src1, src2, src6, src10);
-      ILVR_B2_SH(src3, src7, src10, src7, vec0, vec1);
-      HSUB_UB2_SH(vec0, vec1, vec0, vec1);
-      vec2 = vec0 + vec1;
-      ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
-      CMP_AND_SELECT(vec0, vec1, vec2, src10, src3, src7, src11);
-      ILVR_B2_SH(src4, src8, src11, src8, vec0, vec1);
-      HSUB_UB2_SH(vec0, vec1, vec0, vec1);
-      vec2 = vec0 + vec1;
-      ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
-      CMP_AND_SELECT(vec0, vec1, vec2, src11, src4, src8, src12);
-      ILVR_B2_SH(src5, src9, src12, src9, vec0, vec1);
-      HSUB_UB2_SH(vec0, vec1, vec0, vec1);
-      vec2 = vec0 + vec1;
-      ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
-      CMP_AND_SELECT(vec0, vec1, vec2, src12, src5, src9, src13);
-      src1 = src13;
-      ILVEV_W2_UB(src10, src11, src12, src1, dst0, dst1);
-      dst0 = (v16u8) __msa_pckev_d((v2i64) dst1, (v2i64) dst0);
-
-      ST_UB(dst0, nxt);
-      nxt += 16;
-   }
-}
-
-void png_read_filter_row_paeth3_msa(png_row_infop row_info,
-                                    png_bytep row,
-                                    png_const_bytep prev_row)
-{
-   int32_t count, rp_end;
-   png_bytep nxt;
-   png_const_bytep prev_nxt;
-   int64_t out0;
-   int32_t inp0, inp1, out1;
-   int16_t out2;
-   v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, dst0, dst1;
-   v16u8 src10, src11, src12, src13;
-   v8i16 vec0, vec1, vec2;
-   v16u8 zero = { 0 };
-   v16i8 mask0 = { 0, 1, 2, 16, 17, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-   v16i8 mask1 = { 0, 1, 2, 3, 4, 5, 16, 17, 18, 19, 20, 21, 0, 0, 0, 0 };
-
-   nxt = row;
-   prev_nxt = prev_row;
-
-   inp0 = LW(nxt);
-   inp1 = LW(prev_nxt);
-   prev_nxt += 3;
-   src0 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp0);
-   src1 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp1);
-
-   src1 += src0;
-   out2 = __msa_copy_s_h((v8i16) src1, 0);
-
-   SH(out2, nxt);
-   nxt += 2;
-   nxt[0] = src1[2];
-   nxt++;
-
-   /* Remainder */
-   rp_end = row_info->rowbytes - 3;
-
-   for (count = 0; count < rp_end; count += 12)
-   {
-      src2 = LD_UB(prev_nxt);
-      prev_nxt += 12;
-      src6 = LD_UB(prev_row);
-      prev_row += 12;
-      src10 = LD_UB(nxt);
-
-      SLDI_B3_0_UB(src2, src6, src10, src3, src7, src11, 3);
-      SLDI_B3_0_UB(src2, src6, src10, src4, src8, src12, 6);
-      SLDI_B3_0_UB(src2, src6, src10, src5, src9, src13, 9);
-      ILVR_B2_SH(src2, src6, src1, src6, vec0, vec1);
-      HSUB_UB2_SH(vec0, vec1, vec0, vec1);
-      vec2 = vec0 + vec1;
-      ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
-      CMP_AND_SELECT(vec0, vec1, vec2, src1, src2, src6, src10);
-      ILVR_B2_SH(src3, src7, src10, src7, vec0, vec1);
-      HSUB_UB2_SH(vec0, vec1, vec0, vec1);
-      vec2 = vec0 + vec1;
-      ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
-      CMP_AND_SELECT(vec0, vec1, vec2, src10, src3, src7, src11);
-      ILVR_B2_SH(src4, src8, src11, src8, vec0, vec1);
-      HSUB_UB2_SH(vec0, vec1, vec0, vec1);
-      vec2 = vec0 + vec1;
-      ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
-      CMP_AND_SELECT(vec0, vec1, vec2, src11, src4, src8, src12);
-      ILVR_B2_SH(src5, src9, src12, src9, vec0, vec1);
-      HSUB_UB2_SH(vec0, vec1, vec0, vec1);
-      vec2 = vec0 + vec1;
-      ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
-      CMP_AND_SELECT(vec0, vec1, vec2, src12, src5, src9, src13);
-      src1 = src13;
-      VSHF_B2_UB(src10, src11, src12, src13, mask0, mask0, dst0, dst1);
-      dst0 = (v16u8) __msa_vshf_b(mask1, (v16i8) dst1, (v16i8) dst0);
-      out0 = __msa_copy_s_d((v2i64) dst0, 0);
-      out1 = __msa_copy_s_w((v4i32) dst0, 2);
-
-      SD(out0, nxt);
-      nxt += 8;
-      SW(out1, nxt);
-      nxt += 4;
-   }
-}
-
-#endif /* PNG_MIPS_MSA_OPT > 0 */
-#endif /* PNG_MIPS_MSA_IMPLEMENTATION == 1 (intrinsics) */
-#endif /* READ */

3rdparty/libpng/mips/mips_init.c

@@ -1,127 +0,0 @@
-
-/* mips_init.c - MSA optimised filter functions
- *
- * Copyright (c) 2018 Cosmin Truta
- * Copyright (c) 2016 Glenn Randers-Pehrson
- * Written by Mandar Sahastrabuddhe, 2016.
- *
- * This code is released under the libpng license.
- * For conditions of distribution and use, see the disclaimer
- * and license in png.h
- */
-
-/* Below, after checking __linux__, various non-C90 POSIX 1003.1 functions are
- * called.
- */
-#define _POSIX_SOURCE 1
-
-#include <stdio.h>
-#include "../pngpriv.h"
-
-#ifdef PNG_READ_SUPPORTED
-
-#if PNG_MIPS_MSA_OPT > 0
-#ifdef PNG_MIPS_MSA_CHECK_SUPPORTED /* Do run-time checks */
-/* WARNING: it is strongly recommended that you do not build libpng with
- * run-time checks for CPU features if at all possible.  In the case of the MIPS
- * MSA instructions there is no processor-specific way of detecting the
- * presence of the required support, therefore run-time detection is extremely
- * OS specific.
- *
- * You may set the macro PNG_MIPS_MSA_FILE to the file name of file containing
- * a fragment of C source code which defines the png_have_msa function.  There
- * are a number of implementations in contrib/mips-msa, but the only one that
- * has partial support is contrib/mips-msa/linux.c - a generic Linux
- * implementation which reads /proc/cpufino.
- */
-#ifndef PNG_MIPS_MSA_FILE
-#  ifdef __linux__
-#     define PNG_MIPS_MSA_FILE "contrib/mips-msa/linux.c"
-#  endif
-#endif
-
-#ifdef PNG_MIPS_MSA_FILE
-
-#include <signal.h> /* for sig_atomic_t */
-static int png_have_msa(png_structp png_ptr);
-#include PNG_MIPS_MSA_FILE
-
-#else  /* PNG_MIPS_MSA_FILE */
-#  error "PNG_MIPS_MSA_FILE undefined: no support for run-time MIPS MSA checks"
-#endif /* PNG_MIPS_MSA_FILE */
-#endif /* PNG_MIPS_MSA_CHECK_SUPPORTED */
-
-#ifndef PNG_ALIGNED_MEMORY_SUPPORTED
-#  error "ALIGNED_MEMORY is required; set: -DPNG_ALIGNED_MEMORY_SUPPORTED"
-#endif
-
-void
-png_init_filter_functions_msa(png_structp pp, unsigned int bpp)
-{
-   /* The switch statement is compiled in for MIPS_MSA_API, the call to
-    * png_have_msa is compiled in for MIPS_MSA_CHECK. If both are defined
-    * the check is only performed if the API has not set the MSA option on
-    * or off explicitly. In this case the check controls what happens.
-    */
-
-#ifdef PNG_MIPS_MSA_API_SUPPORTED
-   switch ((pp->options >> PNG_MIPS_MSA) & 3)
-   {
-      case PNG_OPTION_UNSET:
-         /* Allow the run-time check to execute if it has been enabled -
-          * thus both API and CHECK can be turned on.  If it isn't supported
-          * this case will fall through to the 'default' below, which just
-          * returns.
-          */
-#ifdef PNG_MIPS_MSA_CHECK_SUPPORTED
-         {
-            static volatile sig_atomic_t no_msa = -1; /* not checked */
-
-            if (no_msa < 0)
-               no_msa = !png_have_msa(pp);
-
-            if (no_msa)
-               return;
-         }
-#endif /* PNG_MIPS_MSA_CHECK_SUPPORTED */
-         break;
-
-      default: /* OFF or INVALID */
-         return;
-
-      case PNG_OPTION_ON:
-         /* Option turned on */
-         break;
-   }
-   /* IMPORTANT: any new external functions used here must be declared using
-    * PNG_INTERNAL_FUNCTION in ../pngpriv.h.  This is required so that the
-    * 'prefix' option to configure works:
-    *
-    *    ./configure --with-libpng-prefix=foobar_
-    *
-    * Verify you have got this right by running the above command, doing a build
-    * and examining pngprefix.h; it must contain a #define for every external
-    * function you add.  (Notice that this happens automatically for the
-    * initialization function.)
-    */
-   pp->read_filter[PNG_FILTER_VALUE_UP-1] = png_read_filter_row_up_msa;
-
-   if (bpp == 3)
-   {
-      pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub3_msa;
-      pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg3_msa;
-      pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = png_read_filter_row_paeth3_msa;
-   }
-   else if (bpp == 4)
-   {
-      pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub4_msa;
-      pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg4_msa;
-      pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = png_read_filter_row_paeth4_msa;
-   }
-#else
-   (void)pp;
-   (void)bpp;
-#endif /* PNG_MIPS_MSA_API_SUPPORTED */
-}
-#endif /* PNG_MIPS_MSA_OPT > 0 */
-#endif /* READ */

3rdparty/libpng/patches/20190910-msa-patch.diff

@@ -1,53 +0,0 @@
-diff --git a/3rdparty/libpng/mips/mips_init.c b/3rdparty/libpng/mips/mips_init.c
-index 8dd283deef..6a061cccfa 100644
---- a/3rdparty/libpng/mips/mips_init.c
-+++ b/3rdparty/libpng/mips/mips_init.c
-@@ -73,7 +73,6 @@ png_init_filter_functions_msa(png_structp pp, unsigned int bpp)
-           * this case will fall through to the 'default' below, which just
-           * returns.
-           */
--#endif /* PNG_MIPS_MSA_API_SUPPORTED */
- #ifdef PNG_MIPS_MSA_CHECK_SUPPORTED
-          {
-             static volatile sig_atomic_t no_msa = -1; /* not checked */
-@@ -84,12 +83,9 @@ png_init_filter_functions_msa(png_structp pp, unsigned int bpp)
-             if (no_msa)
-                return;
-          }
--#ifdef PNG_MIPS_MSA_API_SUPPORTED
--         break;
--#endif
- #endif /* PNG_MIPS_MSA_CHECK_SUPPORTED */
-+         break;
- 
--#ifdef PNG_MIPS_MSA_API_SUPPORTED
-       default: /* OFF or INVALID */
-          return;
- 
-@@ -97,8 +93,6 @@ png_init_filter_functions_msa(png_structp pp, unsigned int bpp)
-          /* Option turned on */
-          break;
-    }
--#endif
--
-    /* IMPORTANT: any new external functions used here must be declared using
-     * PNG_INTERNAL_FUNCTION in ../pngpriv.h.  This is required so that the
-     * 'prefix' option to configure works:
-@@ -118,13 +112,16 @@ png_init_filter_functions_msa(png_structp pp, unsigned int bpp)
-       pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg3_msa;
-       pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = png_read_filter_row_paeth3_msa;
-    }
--
-    else if (bpp == 4)
-    {
-       pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub4_msa;
-       pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg4_msa;
-       pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = png_read_filter_row_paeth4_msa;
-    }
-+#else
-+   (void)pp;
-+   (void)bpp;
-+#endif /* PNG_MIPS_MSA_API_SUPPORTED */
- }
- #endif /* PNG_MIPS_MSA_OPT > 0 */
- #endif /* READ */

3rdparty/libwebp/patches/20190910-msa-asm-patch.diff

@@ -1,22 +0,0 @@
-diff --git a/3rdparty/libwebp/src/dsp/msa_macro.h b/3rdparty/libwebp/src/dsp/msa_macro.h
-index de026a1d9e..a16c0bb300 100644
---- a/3rdparty/libwebp/src/dsp/msa_macro.h
-+++ b/3rdparty/libwebp/src/dsp/msa_macro.h
-@@ -73,7 +73,7 @@
-   static inline TYPE FUNC_NAME(const void* const psrc) {  \
-     const uint8_t* const psrc_m = (const uint8_t*)psrc;   \
-     TYPE val_m;                                           \
--    asm volatile (                                        \
-+    __asm__ volatile (                                        \
-       "" #INSTR " %[val_m], %[psrc_m]  \n\t"              \
-       : [val_m] "=r" (val_m)                              \
-       : [psrc_m] "m" (*psrc_m));                          \
-@@ -86,7 +86,7 @@
-   static inline void FUNC_NAME(TYPE val, void* const pdst) { \
-     uint8_t* const pdst_m = (uint8_t*)pdst;                  \
-     TYPE val_m = val;                                        \
--    asm volatile (                                           \
-+    __asm__ volatile (                                           \
-       " " #INSTR "  %[val_m],  %[pdst_m]  \n\t"              \
-       : [pdst_m] "=m" (*pdst_m)                              \
-       : [val_m] "r" (val_m));                                \

3rdparty/libwebp/src/dsp/msa_macro.h

@@ -73,7 +73,7 @@
   static inline TYPE FUNC_NAME(const void* const psrc) {  \
     const uint8_t* const psrc_m = (const uint8_t*)psrc;   \
     TYPE val_m;                                           \
-    __asm__ volatile (                                        \
+    asm volatile (                                        \
       "" #INSTR " %[val_m], %[psrc_m]  \n\t"              \
       : [val_m] "=r" (val_m)                              \
       : [psrc_m] "m" (*psrc_m));                          \
@@ -86,7 +86,7 @@
   static inline void FUNC_NAME(TYPE val, void* const pdst) { \
     uint8_t* const pdst_m = (uint8_t*)pdst;                  \
     TYPE val_m = val;                                        \
-    __asm__ volatile (                                           \
+    asm volatile (                                           \
       " " #INSTR "  %[val_m],  %[pdst_m]  \n\t"              \
       : [pdst_m] "=m" (*pdst_m)                              \
       : [val_m] "r" (val_m));                                \

3rdparty/openvx/hal/openvx_hal.cpp

@@ -188,8 +188,8 @@ int ovx_hal_mul(const T *a, size_t astep, const T *b, size_t bstep, T *c, size_t
     refineStep(w, h, ivx::TypeToEnum<T>::imgType, astep);
     refineStep(w, h, ivx::TypeToEnum<T>::imgType, bstep);
     refineStep(w, h, ivx::TypeToEnum<T>::imgType, cstep);
-#ifdef _MSC_VER
-    const float MAGIC_SCALE = 0x0.01010102;
+#ifdef _WIN32
+    const float MAGIC_SCALE = 0x0.01010102p0;
 #else
     const float MAGIC_SCALE = 0x1.010102p-8;
 #endif
@@ -431,7 +431,7 @@ int ovx_hal_warpAffine(int atype, const uchar *a, size_t astep, int aw, int ah,
     return CV_HAL_ERROR_OK;
 }
 
-int ovx_hal_warpPerspectve(int atype, const uchar *a, size_t astep, int aw, int ah, uchar *b, size_t bstep, int bw, int bh, const double M[9], int interpolation, int borderType, const double borderValue[4])
+int ovx_hal_warpPerspective(int atype, const uchar *a, size_t astep, int aw, int ah, uchar *b, size_t bstep, int bw, int bh, const double M[9], int interpolation, int borderType, const double borderValue[4])
 {
     if (skipSmallImages<VX_KERNEL_WARP_PERSPECTIVE>(aw, ah))
         return CV_HAL_ERROR_NOT_IMPLEMENTED;

3rdparty/openvx/hal/openvx_hal.hpp

@@ -27,7 +27,7 @@ int ovx_hal_mul(const T *a, size_t astep, const T *b, size_t bstep, T *c, size_t
 int ovx_hal_merge8u(const uchar **src_data, uchar *dst_data, int len, int cn);
 int ovx_hal_resize(int atype, const uchar *a, size_t astep, int aw, int ah, uchar *b, size_t bstep, int bw, int bh, double inv_scale_x, double inv_scale_y, int interpolation);
 int ovx_hal_warpAffine(int atype, const uchar *a, size_t astep, int aw, int ah, uchar *b, size_t bstep, int bw, int bh, const double M[6], int interpolation, int borderType, const double borderValue[4]);
-int ovx_hal_warpPerspectve(int atype, const uchar *a, size_t astep, int aw, int ah, uchar *b, size_t bstep, int bw, int bh, const double M[9], int interpolation, int borderType, const double borderValue[4]);
+int ovx_hal_warpPerspective(int atype, const uchar *a, size_t astep, int aw, int ah, uchar *b, size_t bstep, int bw, int bh, const double M[9], int interpolation, int borderType, const double borderValue[4]);
 
 struct cvhalFilter2D;
 int ovx_hal_filterInit(cvhalFilter2D **filter_context, uchar *kernel_data, size_t kernel_step, int kernel_type, int kernel_width, int kernel_height,
@@ -97,7 +97,7 @@ int ovx_hal_integral(int depth, int sdepth, int, const uchar * a, size_t astep,
 //#undef cv_hal_warpAffine
 //#define cv_hal_warpAffine ovx_hal_warpAffine
 //#undef cv_hal_warpPerspective
-//#define cv_hal_warpPerspective ovx_hal_warpPerspectve
+//#define cv_hal_warpPerspective ovx_hal_warpPerspective
 
 #undef cv_hal_filterInit
 #define cv_hal_filterInit ovx_hal_filterInit

3rdparty/openvx/include/ivx.hpp

@@ -1718,8 +1718,7 @@ static const vx_enum
     }
 
 #ifdef IVX_USE_OPENCV
-    /// Convert image format (fourcc) to cv::Mat type
-    /// \return CV_USRTYPE1 for unknown image formats
+    /// Convert image format (fourcc) to cv::Mat type, throws WrapperError if not possible
     static int formatToMatType(vx_df_image format, vx_uint32 planeIdx = 0)
     {
         switch (format)
@@ -1739,7 +1738,7 @@ static const vx_enum
         case VX_DF_IMAGE_YUYV: return CV_8UC2;
         case VX_DF_IMAGE_NV12:
         case VX_DF_IMAGE_NV21: return planeIdx == 0 ? CV_8UC1 : CV_8UC2;
-        default: return CV_USRTYPE1;
+        default: throw WrapperError(std::string(__func__)+"(): unsupported image format");
         }
     }
 

3rdparty/zlib/zutil.c

@@ -136,7 +136,7 @@ const char * ZEXPORT zError(err)
     return ERR_MSG(err);
 }
 
-#if defined(_WIN32_WCE) && _WIN32_WCE < 0x800
+#if defined(_WIN32_WCE)
     /* The Microsoft C Run-Time Library for Windows CE doesn't have
      * errno.  We define it as a global variable to simplify porting.
      * Its value is always 0 and should not be used.

3rdparty/zlib/zutil.h

@@ -169,13 +169,11 @@ extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
 
 #if (defined(_MSC_VER) && (_MSC_VER > 600)) && !defined __INTERIX
 #  if defined(_WIN32_WCE)
-#    if _WIN32_WCE < 0x800
-#      define fdopen(fd,mode) NULL /* No fdopen() */
-#      ifndef _PTRDIFF_T_DEFINED
-         typedef int ptrdiff_t;
-#        define _PTRDIFF_T_DEFINED
-#      endif
-#  endif
+#    define fdopen(fd,mode) NULL /* No fdopen() */
+#    ifndef _PTRDIFF_T_DEFINED
+       typedef int ptrdiff_t;
+#      define _PTRDIFF_T_DEFINED
+#    endif
 #  else
 #    define fdopen(fd,type)  _fdopen(fd,type)
 #  endif

CMakeLists.txt

@@ -29,19 +29,69 @@ else()
   cmake_minimum_required(VERSION "${MIN_VER_CMAKE}" FATAL_ERROR)
 endif()
 
-#
-# Configure CMake policies
-#
+option(ENABLE_PIC "Generate position independent code (necessary for shared libraries)" TRUE)
+set(CMAKE_POSITION_INDEPENDENT_CODE ${ENABLE_PIC})
+
+set(OPENCV_MATHJAX_RELPATH "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0" CACHE STRING "URI to a MathJax installation")
+
+# Following block can break build in case of cross-compiling
+# but CMAKE_CROSSCOMPILING variable will be set only on project(OpenCV) command
+# so we will try to detect cross-compiling by the presence of CMAKE_TOOLCHAIN_FILE
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  if(NOT CMAKE_TOOLCHAIN_FILE)
+    # it _must_ go before project(OpenCV) in order to work
+    if(WIN32)
+      set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install" CACHE PATH "Installation Directory")
+    else()
+      set(CMAKE_INSTALL_PREFIX "/usr/local" CACHE PATH "Installation Directory")
+    endif()
+  else()
+    #Android: set output folder to ${CMAKE_BINARY_DIR}
+    set(LIBRARY_OUTPUT_PATH_ROOT ${CMAKE_BINARY_DIR} CACHE PATH "root for library output, set this to change where android libs are compiled to" )
+    # any cross-compiling
+    set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install" CACHE PATH "Installation Directory")
+  endif()
+endif()
+
+if(CMAKE_SYSTEM_NAME MATCHES WindowsPhone OR CMAKE_SYSTEM_NAME MATCHES WindowsStore)
+  set(WINRT TRUE)
+endif()
+
+if(WINRT)
+  add_definitions(-DWINRT -DNO_GETENV)
+
+  # Making definitions available to other configurations and
+  # to filter dependency restrictions at compile time.
+  if(CMAKE_SYSTEM_NAME MATCHES WindowsPhone)
+    set(WINRT_PHONE TRUE)
+    add_definitions(-DWINRT_PHONE)
+  elseif(CMAKE_SYSTEM_NAME MATCHES WindowsStore)
+    set(WINRT_STORE TRUE)
+    add_definitions(-DWINRT_STORE)
+  endif()
+
+  if(CMAKE_SYSTEM_VERSION MATCHES 10)
+    set(WINRT_10 TRUE)
+    add_definitions(-DWINRT_10)
+  elseif(CMAKE_SYSTEM_VERSION MATCHES 8.1)
+    set(WINRT_8_1 TRUE)
+    add_definitions(-DWINRT_8_1)
+  elseif(CMAKE_SYSTEM_VERSION MATCHES 8.0)
+    set(WINRT_8_0 TRUE)
+    add_definitions(-DWINRT_8_0)
+  endif()
+endif()
+
 if(POLICY CMP0026)
   cmake_policy(SET CMP0026 NEW)
 endif()
 
 if(POLICY CMP0042)
-  cmake_policy(SET CMP0042 NEW)  # CMake 3.0+ (2.8.12): MacOS "@rpath" in target's install name
+  cmake_policy(SET CMP0042 NEW)
 endif()
 
 if(POLICY CMP0046)
-  cmake_policy(SET CMP0046 NEW)  # warn about non-existed dependencies
+  cmake_policy(SET CMP0046 NEW)
 endif()
 
 if(POLICY CMP0051)
@@ -53,25 +103,17 @@ if(POLICY CMP0054)  # CMake 3.1: Only interpret if() arguments as variables or k
 endif()
 
 if(POLICY CMP0056)
-  cmake_policy(SET CMP0056 NEW)  # try_compile(): link flags
+  cmake_policy(SET CMP0056 NEW)
 endif()
 
 if(POLICY CMP0067)
-  cmake_policy(SET CMP0067 NEW)  # CMake 3.8: try_compile(): honor language standard variables (like C++11)
+  cmake_policy(SET CMP0067 NEW)
 endif()
 
 if(POLICY CMP0068)
   cmake_policy(SET CMP0068 NEW)  # CMake 3.9+: `RPATH` settings on macOS do not affect `install_name`.
 endif()
 
-if(POLICY CMP0075)
-  cmake_policy(SET CMP0075 NEW)  # CMake 3.12+: Include file check macros honor `CMAKE_REQUIRED_LIBRARIES`
-endif()
-
-
-#
-# Configure OpenCV CMake hooks
-#
 include(cmake/OpenCVUtils.cmake)
 ocv_cmake_reset_hooks()
 ocv_check_environment_variables(OPENCV_CMAKE_HOOKS_DIR)
@@ -84,40 +126,10 @@ endif()
 
 ocv_cmake_hook(CMAKE_INIT)
 
-# must go before the project()/enable_language() commands
+# must go before the project command
 ocv_update(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "Configs" FORCE)
 if(DEFINED CMAKE_BUILD_TYPE)
-  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "${CMAKE_CONFIGURATION_TYPES}")
-endif()
-
-option(ENABLE_PIC "Generate position independent code (necessary for shared libraries)" TRUE)
-set(CMAKE_POSITION_INDEPENDENT_CODE ${ENABLE_PIC})
-
-ocv_cmake_hook(PRE_CMAKE_BOOTSTRAP)
-
-# Bootstap CMake system: setup CMAKE_SYSTEM_NAME and other vars
-enable_language(CXX C)
-
-ocv_cmake_hook(POST_CMAKE_BOOTSTRAP)
-
-if(NOT OPENCV_SKIP_CMAKE_SYSTEM_FILE)
-  include("cmake/platforms/OpenCV-${CMAKE_SYSTEM_NAME}.cmake" OPTIONAL RESULT_VARIABLE "OPENCV_CMAKE_SYSTEM_FILE")
-  if(NOT OPENCV_CMAKE_SYSTEM_FILE)
-    message(STATUS "OpenCV: system-specific configuration file is not found: '${CMAKE_SYSTEM_NAME}'")
-  endif()
-endif()
-
-if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)  # https://cmake.org/cmake/help/latest/variable/CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT.html
-  if(NOT CMAKE_TOOLCHAIN_FILE)
-    if(WIN32)
-      set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install" CACHE PATH "Installation Directory" FORCE)
-    else()
-      set(CMAKE_INSTALL_PREFIX "/usr/local" CACHE PATH "Installation Directory" FORCE)
-    endif()
-  else()
-    # any cross-compiling
-    set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install" CACHE PATH "Installation Directory" FORCE)
-  endif()
+  set_property( CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS ${CMAKE_CONFIGURATION_TYPES} )
 endif()
 
 enable_testing()
@@ -147,7 +159,6 @@ endif()
 # ----------------------------------------------------------------------------
 # Detect compiler and target platform architecture
 # ----------------------------------------------------------------------------
-OCV_OPTION(ENABLE_CXX11 "Enable C++11 compilation mode" "${OPENCV_CXX11}")
 include(cmake/OpenCVDetectCXXCompiler.cmake)
 ocv_cmake_hook(POST_DETECT_COMPILER)
 
@@ -219,13 +230,13 @@ OCV_OPTION(BUILD_ITT                "Build Intel ITT from source"
 # ===================================================
 OCV_OPTION(WITH_1394 "Include IEEE1394 support" ON
   VISIBLE_IF NOT ANDROID AND NOT IOS AND NOT WINRT
-  VERIFY HAVE_DC1394)
+  VERIFY HAVE_DC1394_2)
 OCV_OPTION(WITH_AVFOUNDATION "Use AVFoundation for Video I/O (iOS/Mac)" ON
   VISIBLE_IF APPLE
   VERIFY HAVE_AVFOUNDATION)
-OCV_OPTION(WITH_CARBON "Use Carbon for UI instead of Cocoa (OBSOLETE)" OFF
-  VISIBLE_IF (APPLE OR HAVE_COCOA)
-  VERIFY HAVE_CARBON)
+OCV_OPTION(WITH_CAP_IOS "Enable iOS video capture" ON
+  VISIBLE_IF IOS
+  VERIFY HAVE_CAP_IOS)
 OCV_OPTION(WITH_CAROTENE "Use NVidia carotene acceleration library for ARM platform" ON
   VISIBLE_IF (ARM OR AARCH64) AND NOT IOS AND NOT (CMAKE_VERSION VERSION_LESS "2.8.11"))
 OCV_OPTION(WITH_CPUFEATURES "Use cpufeatures Android library" ON
@@ -243,24 +254,21 @@ OCV_OPTION(WITH_CUFFT "Include NVidia Cuda Fast Fourier Transform (FFT) library
 OCV_OPTION(WITH_CUBLAS "Include NVidia Cuda Basic Linear Algebra Subprograms (BLAS) library support" WITH_CUDA
   VISIBLE_IF WITH_CUDA
   VERIFY HAVE_CUBLAS)
+OCV_OPTION(WITH_CUDNN "Include NVIDIA CUDA Deep Neural Network (cuDNN) library support" WITH_CUDA
+  VISIBLE_IF WITH_CUDA
+  VERIFY HAVE_CUDNN)
 OCV_OPTION(WITH_NVCUVID "Include NVidia Video Decoding library support" WITH_CUDA
   VISIBLE_IF WITH_CUDA
   VERIFY HAVE_NVCUVID)
 OCV_OPTION(WITH_EIGEN "Include Eigen2/Eigen3 support" (NOT CV_DISABLE_OPTIMIZATION AND NOT CMAKE_CROSSCOMPILING)
   VISIBLE_IF NOT WINRT
   VERIFY HAVE_EIGEN)
-OCV_OPTION(WITH_VFW "Include Video for Windows support (deprecated, consider using MSMF)" OFF
-  VISIBLE_IF WIN32
-  VERIFY HAVE_VFW)
 OCV_OPTION(WITH_FFMPEG "Include FFMPEG support" (NOT ANDROID)
   VISIBLE_IF NOT IOS AND NOT WINRT
   VERIFY HAVE_FFMPEG)
 OCV_OPTION(WITH_GSTREAMER "Include Gstreamer support" ON
   VISIBLE_IF NOT ANDROID AND NOT IOS AND NOT WINRT
-  VERIFY HAVE_GSTREAMER AND GSTREAMER_BASE_VERSION VERSION_GREATER "0.99")
-OCV_OPTION(WITH_GSTREAMER_0_10 "Enable Gstreamer 0.10 support (instead of 1.x)" OFF
-  VISIBLE_IF TRUE
-  VERIFY HAVE_GSTREAMER AND GSTREAMER_BASE_VERSION VERSION_LESS "1.0")
+  VERIFY HAVE_GSTREAMER AND GSTREAMER_VERSION VERSION_GREATER "0.99")
 OCV_OPTION(WITH_GTK "Include GTK support" ON
   VISIBLE_IF UNIX AND NOT APPLE AND NOT ANDROID
   VERIFY HAVE_GTK)
@@ -273,6 +281,9 @@ OCV_OPTION(WITH_IPP "Include Intel IPP support" (NOT MINGW AND NOT CV_DISABLE_OP
 OCV_OPTION(WITH_HALIDE "Include Halide support" OFF
   VISIBLE_IF TRUE
   VERIFY HAVE_HALIDE)
+OCV_OPTION(WITH_VULKAN "Include Vulkan support" OFF
+  VISIBLE_IF TRUE
+  VERIFY HAVE_VULKAN)
 OCV_OPTION(WITH_INF_ENGINE "Include Intel Inference Engine support" OFF
   VISIBLE_IF TRUE
   VERIFY INF_ENGINE_TARGET)
@@ -309,9 +320,6 @@ OCV_OPTION(WITH_GDCM "Include DICOM support" OFF
 OCV_OPTION(WITH_PVAPI "Include Prosilica GigE support" OFF
   VISIBLE_IF NOT ANDROID AND NOT IOS AND NOT WINRT
   VERIFY HAVE_PVAPI)
-OCV_OPTION(WITH_GIGEAPI "Include Smartek GigE support" OFF
-  VISIBLE_IF NOT ANDROID AND NOT IOS AND NOT WINRT
-  VERIFY HAVE_GIGE_API)
 OCV_OPTION(WITH_ARAVIS "Include Aravis GigE support" OFF
   VISIBLE_IF NOT ANDROID AND NOT IOS AND NOT WINRT AND NOT WIN32
   VERIFY HAVE_ARAVIS_API)
@@ -321,36 +329,24 @@ OCV_OPTION(WITH_QT "Build with Qt Backend support" OFF
 OCV_OPTION(WITH_WIN32UI "Build with Win32 UI Backend support" ON
   VISIBLE_IF WIN32 AND NOT WINRT
   VERIFY HAVE_WIN32UI)
-OCV_OPTION(WITH_QUICKTIME "Use QuickTime for Video I/O (OBSOLETE)" OFF
-  VISIBLE_IF APPLE
-  VERIFY HAVE_QUICKTIME)
-OCV_OPTION(WITH_QTKIT "Use QTKit Video I/O backend" OFF
-  VISIBLE_IF APPLE
-  VERIFY HAVE_QTKIT)
 OCV_OPTION(WITH_TBB "Include Intel TBB support" OFF
   VISIBLE_IF NOT IOS AND NOT WINRT
   VERIFY HAVE_TBB)
+OCV_OPTION(WITH_HPX "Include Ste||ar Group HPX support" OFF
+  VISIBLE_IF TRUE
+  VERIFY HAVE_HPX)
 OCV_OPTION(WITH_OPENMP "Include OpenMP support" OFF
   VISIBLE_IF TRUE
   VERIFY HAVE_OPENMP)
-OCV_OPTION(WITH_CSTRIPES "Include C= support" OFF
-  VISIBLE_IF WIN32 AND NOT WINRT
-  VERIFY HAVE_CSTRIPES)
 OCV_OPTION(WITH_PTHREADS_PF "Use pthreads-based parallel_for" ON
   VISIBLE_IF NOT WIN32 OR MINGW
   VERIFY HAVE_PTHREADS_PF)
 OCV_OPTION(WITH_TIFF "Include TIFF support" ON
   VISIBLE_IF NOT IOS
   VERIFY HAVE_TIFF)
-OCV_OPTION(WITH_UNICAP "Include Unicap support (GPL)" OFF
-  VISIBLE_IF UNIX AND NOT APPLE AND NOT ANDROID
-  VERIFY HAVE_UNICAP)
 OCV_OPTION(WITH_V4L "Include Video 4 Linux support" ON
   VISIBLE_IF UNIX AND NOT ANDROID AND NOT APPLE
   VERIFY HAVE_CAMV4L OR HAVE_CAMV4L2 OR HAVE_VIDEOIO)
-OCV_OPTION(WITH_LIBV4L "Use libv4l for Video 4 Linux support" OFF
-  VISIBLE_IF UNIX AND NOT ANDROID AND NOT APPLE
-  VERIFY HAVE_LIBV4L)
 OCV_OPTION(WITH_DSHOW "Build VideoIO with DirectShow support" ON
   VISIBLE_IF WIN32 AND NOT ARM AND NOT WINRT
   VERIFY HAVE_DSHOW)
@@ -387,9 +383,9 @@ OCV_OPTION(WITH_DIRECTX "Include DirectX support" ON
 OCV_OPTION(WITH_OPENCL_D3D11_NV "Include NVIDIA OpenCL D3D11 support" WITH_DIRECTX
   VISIBLE_IF WIN32 AND NOT WINRT
   VERIFY HAVE_OPENCL_D3D11_NV)
-OCV_OPTION(WITH_INTELPERC "Include Intel Perceptual Computing support" OFF
-  VISIBLE_IF WIN32 AND NOT WINRT
-  VERIFY HAVE_INTELPERC)
+OCV_OPTION(WITH_LIBREALSENSE "Include Intel librealsense support" OFF
+  VISIBLE_IF NOT WITH_INTELPERC
+  VERIFY HAVE_LIBREALSENSE)
 OCV_OPTION(WITH_VA "Include VA support" OFF
   VISIBLE_IF UNIX AND NOT ANDROID
   VERIFY HAVE_VA)
@@ -423,9 +419,15 @@ OCV_OPTION(WITH_IMGCODEC_SUNRASTER "Include SUNRASTER support" ON
 OCV_OPTION(WITH_IMGCODEC_PXM "Include PNM (PBM,PGM,PPM) and PAM formats support" ON
   VISIBLE_IF TRUE
   VERIFY HAVE_IMGCODEC_PXM)
+OCV_OPTION(WITH_IMGCODEC_PFM "Include PFM formats support" ON
+  VISIBLE_IF TRUE
+  VERIFY HAVE_IMGCODEC_PFM)
 OCV_OPTION(WITH_QUIRC "Include library QR-code decoding" ON
   VISIBLE_IF TRUE
   VERIFY HAVE_QUIRC)
+OCV_OPTION(WITH_ANDROID_MEDIANDK "Use Android Media NDK for Video I/O (Android)" (ANDROID_NATIVE_API_LEVEL GREATER 20)
+  VISIBLE_IF ANDROID
+  VERIFY HAVE_ANDROID_MEDIANDK)
 
 # OpenCV build components
 # ===================================================
@@ -459,7 +461,7 @@ OCV_OPTION(INSTALL_TESTS            "Install accuracy and performance test binar
 # OpenCV build options
 # ===================================================
 OCV_OPTION(ENABLE_CCACHE              "Use ccache"                                               (UNIX AND NOT IOS AND (CMAKE_GENERATOR MATCHES "Makefile" OR CMAKE_GENERATOR MATCHES "Ninja")) )
-OCV_OPTION(ENABLE_PRECOMPILED_HEADERS "Use precompiled headers"                                  MSVC IF (MSVC OR (NOT IOS AND NOT CMAKE_CROSSCOMPILING) ) )
+OCV_OPTION(ENABLE_PRECOMPILED_HEADERS "Use precompiled headers"                                  ON IF (MSVC OR (NOT IOS AND NOT CMAKE_CROSSCOMPILING) ) )
 OCV_OPTION(ENABLE_SOLUTION_FOLDERS    "Solution folder in Visual Studio or in other IDEs"        (MSVC_IDE OR CMAKE_GENERATOR MATCHES Xcode) )
 OCV_OPTION(ENABLE_PROFILING           "Enable profiling in the GCC compiler (Add flags: -g -pg)" OFF  IF CV_GCC )
 OCV_OPTION(ENABLE_COVERAGE            "Enable coverage collection with  GCov"                    OFF  IF CV_GCC )
@@ -467,7 +469,7 @@ OCV_OPTION(OPENCV_ENABLE_MEMORY_SANITIZER "Better support for memory/address san
 OCV_OPTION(ENABLE_OMIT_FRAME_POINTER  "Enable -fomit-frame-pointer for GCC"                      ON   IF CV_GCC )
 OCV_OPTION(ENABLE_POWERPC             "Enable PowerPC for GCC"                                   ON   IF (CV_GCC AND CMAKE_SYSTEM_PROCESSOR MATCHES powerpc.*) )
 OCV_OPTION(ENABLE_FAST_MATH           "Enable compiler options for fast math optimizations on FP computations (not recommended)" OFF)
-if(NOT IOS)  # Use CPU_BASELINE instead
+if(NOT IOS AND (NOT ANDROID OR OPENCV_ANDROID_USE_LEGACY_FLAGS))  # Use CPU_BASELINE instead
 OCV_OPTION(ENABLE_NEON                "Enable NEON instructions"                                 (NEON OR ANDROID_ARM_NEON OR AARCH64) IF (CV_GCC OR CV_CLANG) AND (ARM OR AARCH64 OR IOS) )
 OCV_OPTION(ENABLE_VFPV3               "Enable VFPv3-D32 instructions"                            OFF  IF (CV_GCC OR CV_CLANG) AND (ARM OR AARCH64 OR IOS) )
 endif()
@@ -481,13 +483,12 @@ OCV_OPTION(ENABLE_BUILD_HARDENING     "Enable hardening of the resulting binarie
 OCV_OPTION(ENABLE_LTO                 "Enable Link Time Optimization" OFF IF CV_GCC OR MSVC)
 OCV_OPTION(ENABLE_THIN_LTO            "Enable Thin LTO" OFF IF CV_CLANG)
 OCV_OPTION(GENERATE_ABI_DESCRIPTOR    "Generate XML file for abi_compliance_checker tool" OFF IF UNIX)
-OCV_OPTION(OPENCV_GENERATE_PKGCONFIG  "Generate .pc file for pkg-config build tool (deprecated)" ON IF (UNIX AND NOT MSVC AND NOT IOS AND NOT ANDROID) )
+OCV_OPTION(OPENCV_GENERATE_PKGCONFIG  "Generate .pc file for pkg-config build tool (deprecated)" OFF)
 OCV_OPTION(CV_ENABLE_INTRINSICS       "Use intrinsic-based optimized code" ON )
 OCV_OPTION(CV_DISABLE_OPTIMIZATION    "Disable explicit optimized code (dispatched code/intrinsics/loop unrolling/etc)" OFF )
 OCV_OPTION(CV_TRACE                   "Enable OpenCV code trace" ON)
 OCV_OPTION(OPENCV_GENERATE_SETUPVARS  "Generate setup_vars* scripts" ON IF (NOT ANDROID AND NOT APPLE_FRAMEWORK) )
 OCV_OPTION(ENABLE_CONFIG_VERIFICATION "Fail build if actual configuration doesn't match requested (WITH_XXX != HAVE_XXX)" OFF)
-OCV_OPTION(OPENCV_ENABLE_MEMALIGN     "Enable posix_memalign or memalign usage" ON)
 
 OCV_OPTION(ENABLE_PYLINT              "Add target with Pylint checks"                            (BUILD_DOCS OR BUILD_EXAMPLES) IF (NOT CMAKE_CROSSCOMPILING AND NOT APPLE_FRAMEWORK) )
 OCV_OPTION(ENABLE_FLAKE8              "Add target with Python flake8 checker"                    (BUILD_DOCS OR BUILD_EXAMPLES) IF (NOT CMAKE_CROSSCOMPILING AND NOT APPLE_FRAMEWORK) )
@@ -496,7 +497,6 @@ if(ENABLE_IMPL_COLLECTION)
   add_definitions(-DCV_COLLECT_IMPL_DATA)
 endif()
 
-set(OPENCV_MATHJAX_RELPATH "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0" CACHE STRING "URI to a MathJax installation")
 
 # ----------------------------------------------------------------------------
 #  Get actual OpenCV version number from sources
@@ -509,21 +509,9 @@ ocv_cmake_hook(POST_OPTIONS)
 #  Build & install layouts
 # ----------------------------------------------------------------------------
 
-if(OPENCV_TEST_DATA_PATH)
-  get_filename_component(OPENCV_TEST_DATA_PATH ${OPENCV_TEST_DATA_PATH} ABSOLUTE)
-endif()
-
 # Save libs and executables in the same place
 set(EXECUTABLE_OUTPUT_PATH "${CMAKE_BINARY_DIR}/bin" CACHE PATH "Output directory for applications")
 
-if(ANDROID)
-  set(LIBRARY_OUTPUT_PATH                "${OpenCV_BINARY_DIR}/lib/${ANDROID_NDK_ABI_NAME}")
-  ocv_update(3P_LIBRARY_OUTPUT_PATH      "${OpenCV_BINARY_DIR}/3rdparty/lib/${ANDROID_NDK_ABI_NAME}")
-else()
-  set(LIBRARY_OUTPUT_PATH                "${OpenCV_BINARY_DIR}/lib")
-  ocv_update(3P_LIBRARY_OUTPUT_PATH      "${OpenCV_BINARY_DIR}/3rdparty/lib")
-endif()
-
 if(ANDROID)
   if(ANDROID_ABI MATCHES "NEON")
     set(ENABLE_NEON ON)
@@ -533,14 +521,134 @@ if(ANDROID)
   endif()
 endif()
 
+if(ANDROID OR WIN32)
+  ocv_update(OPENCV_DOC_INSTALL_PATH doc)
+endif()
+
+if(WIN32 AND CMAKE_HOST_SYSTEM_NAME MATCHES Windows)
+  if(DEFINED OpenCV_RUNTIME AND DEFINED OpenCV_ARCH)
+    ocv_update(OpenCV_INSTALL_BINARIES_PREFIX "${OpenCV_ARCH}/${OpenCV_RUNTIME}/")
+  else()
+    message(STATUS "Can't detect runtime and/or arch")
+    ocv_update(OpenCV_INSTALL_BINARIES_PREFIX "")
+  endif()
+elseif(ANDROID)
+  ocv_update(OpenCV_INSTALL_BINARIES_PREFIX "sdk/native/")
+else()
+  ocv_update(OpenCV_INSTALL_BINARIES_PREFIX "")
+endif()
+
+if(ANDROID)
+  ocv_update(OPENCV_SAMPLES_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}samples/${ANDROID_NDK_ABI_NAME}")
+else()
+  ocv_update(OPENCV_SAMPLES_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}samples")
+endif()
+
+if(ANDROID)
+  ocv_update(OPENCV_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}bin/${ANDROID_NDK_ABI_NAME}")
+else()
+  ocv_update(OPENCV_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}bin")
+endif()
+
+if(NOT OPENCV_TEST_INSTALL_PATH)
+  ocv_update(OPENCV_TEST_INSTALL_PATH "${OPENCV_BIN_INSTALL_PATH}")
+endif()
+
+if (OPENCV_TEST_DATA_PATH)
+  get_filename_component(OPENCV_TEST_DATA_PATH ${OPENCV_TEST_DATA_PATH} ABSOLUTE)
+endif()
+
+if(ANDROID)
+  ocv_update(OPENCV_TEST_DATA_INSTALL_PATH "sdk/etc/testdata")
+elseif(WIN32)
+  ocv_update(OPENCV_TEST_DATA_INSTALL_PATH "testdata")
+endif()
+
+if(ANDROID)
+  set(LIBRARY_OUTPUT_PATH                "${OpenCV_BINARY_DIR}/lib/${ANDROID_NDK_ABI_NAME}")
+  ocv_update(3P_LIBRARY_OUTPUT_PATH      "${OpenCV_BINARY_DIR}/3rdparty/lib/${ANDROID_NDK_ABI_NAME}")
+  ocv_update(OPENCV_LIB_INSTALL_PATH     sdk/native/libs/${ANDROID_NDK_ABI_NAME})
+  ocv_update(OPENCV_LIB_ARCHIVE_INSTALL_PATH sdk/native/staticlibs/${ANDROID_NDK_ABI_NAME})
+  ocv_update(OPENCV_3P_LIB_INSTALL_PATH  sdk/native/3rdparty/libs/${ANDROID_NDK_ABI_NAME})
+  ocv_update(OPENCV_CONFIG_INSTALL_PATH  sdk/native/jni)
+  ocv_update(OPENCV_INCLUDE_INSTALL_PATH sdk/native/jni/include)
+  ocv_update(OPENCV_SAMPLES_SRC_INSTALL_PATH samples/native)
+  ocv_update(OPENCV_OTHER_INSTALL_PATH   sdk/etc)
+  ocv_update(OPENCV_LICENSES_INSTALL_PATH "${OPENCV_OTHER_INSTALL_PATH}/licenses")
+else()
+  set(LIBRARY_OUTPUT_PATH                "${OpenCV_BINARY_DIR}/lib")
+  ocv_update(3P_LIBRARY_OUTPUT_PATH      "${OpenCV_BINARY_DIR}/3rdparty/lib${LIB_SUFFIX}")
+
+  if(WIN32 AND CMAKE_HOST_SYSTEM_NAME MATCHES Windows)
+    if(OpenCV_STATIC)
+      ocv_update(OPENCV_LIB_INSTALL_PATH   "${OpenCV_INSTALL_BINARIES_PREFIX}staticlib${LIB_SUFFIX}")
+    else()
+      ocv_update(OPENCV_LIB_INSTALL_PATH   "${OpenCV_INSTALL_BINARIES_PREFIX}lib${LIB_SUFFIX}")
+    endif()
+    ocv_update(OPENCV_3P_LIB_INSTALL_PATH  "${OpenCV_INSTALL_BINARIES_PREFIX}staticlib${LIB_SUFFIX}")
+    ocv_update(OPENCV_SAMPLES_SRC_INSTALL_PATH    samples)
+    ocv_update(OPENCV_JAR_INSTALL_PATH java)
+    ocv_update(OPENCV_OTHER_INSTALL_PATH   etc)
+    ocv_update(OPENCV_CONFIG_INSTALL_PATH  ".")
+    ocv_update(OPENCV_INCLUDE_INSTALL_PATH "include")
+    ocv_update(OPENCV_LICENSES_INSTALL_PATH "${OPENCV_OTHER_INSTALL_PATH}/licenses")
+  else()
+    # Note: layout differs from OpenCV 3.4
+    include(GNUInstallDirs)
+    ocv_update(OPENCV_INCLUDE_INSTALL_PATH       "${CMAKE_INSTALL_INCLUDEDIR}/opencv4")
+    ocv_update(OPENCV_LIB_INSTALL_PATH           "${CMAKE_INSTALL_LIBDIR}")
+    ocv_update(OPENCV_CONFIG_INSTALL_PATH        "${OPENCV_LIB_INSTALL_PATH}/cmake/opencv4")
+    ocv_update(OPENCV_3P_LIB_INSTALL_PATH        "${OPENCV_LIB_INSTALL_PATH}/opencv4/3rdparty")
+    ocv_update(OPENCV_SAMPLES_SRC_INSTALL_PATH   "${CMAKE_INSTALL_DATAROOTDIR}/opencv4/samples")
+    ocv_update(OPENCV_DOC_INSTALL_PATH           "${CMAKE_INSTALL_DATAROOTDIR}/doc/opencv4")
+    ocv_update(OPENCV_JAR_INSTALL_PATH           "${CMAKE_INSTALL_DATAROOTDIR}/java/opencv4")
+    ocv_update(OPENCV_TEST_DATA_INSTALL_PATH     "${CMAKE_INSTALL_DATAROOTDIR}/opencv4/testdata")
+    ocv_update(OPENCV_OTHER_INSTALL_PATH         "${CMAKE_INSTALL_DATAROOTDIR}/opencv4")
+    ocv_update(OPENCV_LICENSES_INSTALL_PATH      "${CMAKE_INSTALL_DATAROOTDIR}/licenses/opencv4")
+  endif()
+  #ocv_update(OPENCV_PYTHON_INSTALL_PATH  "python")  # no default value, see https://github.com/opencv/opencv/issues/13202
+endif()
+
+ocv_update(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${OPENCV_LIB_INSTALL_PATH}")
+set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+
+if(INSTALL_TO_MANGLED_PATHS)
+  foreach(v
+      OPENCV_INCLUDE_INSTALL_PATH
+      # file names include version (.so/.dll): OPENCV_LIB_INSTALL_PATH
+      OPENCV_CONFIG_INSTALL_PATH
+      OPENCV_3P_LIB_INSTALL_PATH
+      OPENCV_SAMPLES_SRC_INSTALL_PATH
+      OPENCV_DOC_INSTALL_PATH
+      # JAR file name includes version: OPENCV_JAR_INSTALL_PATH
+      OPENCV_TEST_DATA_INSTALL_PATH
+      OPENCV_OTHER_INSTALL_PATH
+    )
+    string(REGEX REPLACE "opencv[0-9]*" "opencv-${OPENCV_VERSION}" ${v} "${${v}}")
+  endforeach()
+endif()
+
+if(ANDROID)
+  ocv_update(OPENCV_JNI_INSTALL_PATH "${OPENCV_LIB_INSTALL_PATH}")
+elseif(INSTALL_CREATE_DISTRIB)
+  ocv_update(OPENCV_JNI_INSTALL_PATH "${OPENCV_JAR_INSTALL_PATH}/${OpenCV_ARCH}")
+else()
+  ocv_update(OPENCV_JNI_INSTALL_PATH "${OPENCV_JAR_INSTALL_PATH}")
+endif()
+ocv_update(OPENCV_JNI_BIN_INSTALL_PATH "${OPENCV_JNI_INSTALL_PATH}")
+
+if(NOT OPENCV_LIB_ARCHIVE_INSTALL_PATH)
+  set(OPENCV_LIB_ARCHIVE_INSTALL_PATH ${OPENCV_LIB_INSTALL_PATH})
+endif()
+
 if(WIN32)
   # Postfix of DLLs:
-  ocv_update(OPENCV_DLLVERSION "${OPENCV_VERSION_MAJOR}${OPENCV_VERSION_MINOR}${OPENCV_VERSION_PATCH}")
-  ocv_update(OPENCV_DEBUG_POSTFIX d)
+  set(OPENCV_DLLVERSION "${OPENCV_VERSION_MAJOR}${OPENCV_VERSION_MINOR}${OPENCV_VERSION_PATCH}")
+  set(OPENCV_DEBUG_POSTFIX d)
 else()
   # Postfix of so's:
-  ocv_update(OPENCV_DLLVERSION "")
-  ocv_update(OPENCV_DEBUG_POSTFIX "")
+  set(OPENCV_DLLVERSION "")
+  set(OPENCV_DEBUG_POSTFIX "")
 endif()
 
 if(DEFINED CMAKE_DEBUG_POSTFIX)
@@ -551,8 +659,6 @@ if((INSTALL_CREATE_DISTRIB AND BUILD_SHARED_LIBS AND NOT DEFINED BUILD_opencv_wo
   set(BUILD_opencv_world ON CACHE INTERNAL "")
 endif()
 
-include(cmake/OpenCVInstallLayout.cmake)
-
 # ----------------------------------------------------------------------------
 #  Path for build/platform -specific headers
 # ----------------------------------------------------------------------------
@@ -636,15 +742,10 @@ if(UNIX)
     set(HAVE_PTHREAD 1)
   endif()
 
-  if(OPENCV_ENABLE_MEMALIGN)
-    CHECK_SYMBOL_EXISTS(posix_memalign stdlib.h HAVE_POSIX_MEMALIGN)
-    CHECK_INCLUDE_FILE(malloc.h HAVE_MALLOC_H)
-    if(HAVE_MALLOC_H)
-      CHECK_SYMBOL_EXISTS(memalign malloc.h HAVE_MEMALIGN)
-    endif()
-    # TODO:
-    # - _aligned_malloc() on Win32
-    # - std::aligned_alloc() C++17 / C11
+  CHECK_SYMBOL_EXISTS(posix_memalign stdlib.h HAVE_POSIX_MEMALIGN)
+  CHECK_INCLUDE_FILE(malloc.h HAVE_MALLOC_H)
+  if(HAVE_MALLOC_H)
+    CHECK_SYMBOL_EXISTS(memalign malloc.h HAVE_MEMALIGN)
   endif()
 endif()
 
@@ -730,6 +831,11 @@ if(WITH_HALIDE)
   include(cmake/OpenCVDetectHalide.cmake)
 endif()
 
+# --- VkCom ---
+if(WITH_VULKAN)
+  include(cmake/OpenCVDetectVulkan.cmake)
+endif()
+
 # --- Inference Engine ---
 if(WITH_INF_ENGINE)
   include(cmake/OpenCVDetectInferenceEngine.cmake)
@@ -820,6 +926,9 @@ if(HAVE_CUDA)
   if(HAVE_CUBLAS)
     set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} ${CUDA_cublas_LIBRARY})
   endif()
+  if(HAVE_CUDNN)
+    set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} ${CUDNN_LIBRARIES})
+  endif()
   if(HAVE_CUFFT)
     set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} ${CUDA_cufft_LIBRARY})
   endif()
@@ -897,9 +1006,7 @@ ocv_cmake_hook(PRE_FINALIZE)
 include(cmake/OpenCVGenHeaders.cmake)
 
 # Generate opencv.pc for pkg-config command
-if(NOT OPENCV_SKIP_PKGCONFIG_GENERATION
-    AND OPENCV_GENERATE_PKGCONFIG
-    AND NOT CMAKE_GENERATOR MATCHES "Xcode")
+if(OPENCV_GENERATE_PKGCONFIG)
   include(cmake/OpenCVGenPkgconfig.cmake)
 endif()
 
@@ -1067,9 +1174,6 @@ string(STRIP "${OPENCV_COMPILER_STR}" OPENCV_COMPILER_STR)
 status("")
 status("  C/C++:")
 status("    Built as dynamic libs?:" BUILD_SHARED_LIBS THEN YES ELSE NO)
-if(ENABLE_CXX11 OR HAVE_CXX11)
-status("    C++11:" HAVE_CXX11 THEN YES ELSE NO)
-endif()
 status("    C++ Compiler:"           ${OPENCV_COMPILER_STR})
 status("    C++ flags (Release):"    ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE})
 status("    C++ flags (Debug):"      ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_DEBUG})
@@ -1204,12 +1308,8 @@ if(WITH_WIN32UI)
   status("    Win32 UI:" HAVE_WIN32UI THEN YES ELSE NO)
 endif()
 
-if(APPLE)
-  if(WITH_CARBON)
-    status("    Carbon:" YES)
-  else()
-    status("    Cocoa:"  YES)
-  endif()
+if(HAVE_COCOA)  # APPLE
+  status("    Cocoa:"  YES)
 endif()
 
 if(WITH_GTK OR HAVE_GTK)
@@ -1278,7 +1378,7 @@ if(WITH_GDAL OR HAVE_GDAL)
 endif()
 
 if(WITH_GDCM OR HAVE_GDCM)
-  status("    GDCM:" HAVE_GDCM THEN "YES (ver ${GDCM_VERSION})" ELSE "NO")
+  status("    GDCM:" HAVE_GDCM THEN "YES (${GDCM_VERSION})" ELSE "NO")
 endif()
 
 if(WITH_IMGCODEC_HDR OR DEFINED HAVE_IMGCODEC_HDR)
@@ -1293,22 +1393,16 @@ if(WITH_IMGCODEC_PXM OR DEFINED HAVE_IMGCODEC_PXM)
   status("    PXM:" HAVE_IMGCODEC_PXM THEN "YES" ELSE "NO")
 endif()
 
+if(WITH_IMGCODEC_PFM OR DEFINED HAVE_IMGCODEC_PFM)
+  status("    PFM:" HAVE_IMGCODEC_PFM THEN "YES" ELSE "NO")
+endif()
+
 # ========================== VIDEO IO ==========================
 status("")
 status("  Video I/O:")
 
-if(WITH_VFW OR HAVE_VFW)
-  status("    Video for Windows:" HAVE_VFW         THEN YES                                        ELSE NO)
-endif()
-
-if(WITH_1394 OR HAVE_DC1394)
-  if (HAVE_DC1394_2)
-    status("    DC1394:" "YES (ver ${DC1394_2_VERSION})")
-  elseif (HAVE_DC1394)
-    status("    DC1394:" "YES (ver ${DC1394_VERSION})")
-  else()
-    status("    DC1394:" "NO")
-  endif()
+if(WITH_1394 OR HAVE_DC1394_2)
+  status("    DC1394:" HAVE_DC1394_2 THEN "YES (${DC1394_2_VERSION})" ELSE NO)
 endif()
 
 if(WITH_FFMPEG OR HAVE_FFMPEG)
@@ -1319,89 +1413,64 @@ if(WITH_FFMPEG OR HAVE_FFMPEG)
   else()
     status("    FFMPEG:"       HAVE_FFMPEG         THEN YES ELSE NO)
   endif()
-  status("      avcodec:"      FFMPEG_libavcodec_FOUND    THEN "YES (ver ${FFMPEG_libavcodec_VERSION})"    ELSE NO)
-  status("      avformat:"     FFMPEG_libavformat_FOUND   THEN "YES (ver ${FFMPEG_libavformat_VERSION})"   ELSE NO)
-  status("      avutil:"       FFMPEG_libavutil_FOUND     THEN "YES (ver ${FFMPEG_libavutil_VERSION})"     ELSE NO)
-  status("      swscale:"      FFMPEG_libswscale_FOUND    THEN "YES (ver ${FFMPEG_libswscale_VERSION})"    ELSE NO)
-  status("      avresample:"   FFMPEG_libavresample_FOUND THEN "YES (ver ${FFMPEG_libavresample_VERSION})" ELSE NO)
+  status("      avcodec:"      FFMPEG_libavcodec_VERSION    THEN "YES (${FFMPEG_libavcodec_VERSION})"    ELSE NO)
+  status("      avformat:"     FFMPEG_libavformat_VERSION   THEN "YES (${FFMPEG_libavformat_VERSION})"   ELSE NO)
+  status("      avutil:"       FFMPEG_libavutil_VERSION     THEN "YES (${FFMPEG_libavutil_VERSION})"     ELSE NO)
+  status("      swscale:"      FFMPEG_libswscale_VERSION    THEN "YES (${FFMPEG_libswscale_VERSION})"    ELSE NO)
+  status("      avresample:"   FFMPEG_libavresample_VERSION THEN "YES (${FFMPEG_libavresample_VERSION})" ELSE NO)
 endif()
 
 if(WITH_GSTREAMER OR HAVE_GSTREAMER)
-  status("    GStreamer:"      HAVE_GSTREAMER      THEN "YES"                                      ELSE NO)
-  if(HAVE_GSTREAMER)
-    status("      base:"       "YES (ver ${GSTREAMER_BASE_VERSION})")
-    status("      video:"      "YES (ver ${GSTREAMER_VIDEO_VERSION})")
-    status("      app:"        "YES (ver ${GSTREAMER_APP_VERSION})")
-    status("      riff:"       "YES (ver ${GSTREAMER_RIFF_VERSION})")
-    status("      pbutils:"    "YES (ver ${GSTREAMER_PBUTILS_VERSION})")
-  endif(HAVE_GSTREAMER)
-endif()
-
-if(WITH_OPENNI OR HAVE_OPENNI)
-  status("    OpenNI:"         HAVE_OPENNI         THEN "YES (ver ${OPENNI_VERSION_STRING}, build ${OPENNI_VERSION_BUILD})" ELSE NO)
-  status("    OpenNI PrimeSensor Modules:" HAVE_OPENNI_PRIME_SENSOR_MODULE THEN "YES (${OPENNI_PRIME_SENSOR_MODULE})"      ELSE NO)
+  status("    GStreamer:" HAVE_GSTREAMER THEN "YES (${GSTREAMER_VERSION})" ELSE NO)
 endif()
 
 if(WITH_OPENNI2 OR HAVE_OPENNI2)
-  status("    OpenNI2:"        HAVE_OPENNI2    THEN "YES (ver ${OPENNI2_VERSION_STRING}, build ${OPENNI2_VERSION_BUILD})" ELSE NO)
+  status("    OpenNI2:"        HAVE_OPENNI2    THEN "YES (${OPENNI2_VERSION})" ELSE NO)
 endif()
 
 if(WITH_PVAPI OR HAVE_PVAPI)
-  status("    PvAPI:"          HAVE_PVAPI          THEN YES                                        ELSE NO)
-endif()
-
-if(WITH_GIGEAPI OR HAVE_GIGE_API)
-  status("    GigEVisionSDK:"  HAVE_GIGE_API       THEN YES                                        ELSE NO)
+  status("    PvAPI:" HAVE_PVAPI THEN YES ELSE NO)
 endif()
 
 if(WITH_ARAVIS OR HAVE_ARAVIS_API)
-  status("    Aravis SDK:"     HAVE_ARAVIS_API     THEN "YES (${ARAVIS_LIBRARIES})"                ELSE NO)
+  status("    Aravis SDK:" HAVE_ARAVIS_API THEN "YES (${ARAVIS_VERSION})" ELSE NO)
 endif()
 
-if(APPLE)
-  status("    AVFoundation:"   HAVE_AVFOUNDATION   THEN YES                                        ELSE NO)
-  if(WITH_QUICKTIME OR HAVE_QUICKTIME)
-    status("    QuickTime:"      HAVE_QUICKTIME      THEN YES                                        ELSE NO)
-  endif()
-  if(WITH_QTKIT OR HAVE_QTKIT)
-    status("    QTKit:"          HAVE_QTKIT          THEN "YES (deprecated)"                         ELSE NO)
-  endif()
+if(WITH_AVFOUNDATION OR HAVE_AVFOUNDATION)
+  status("    AVFoundation:" HAVE_AVFOUNDATION THEN YES ELSE NO)
 endif()
 
-if(WITH_UNICAP OR HAVE_UNICAP)
-  status("    UniCap:"         HAVE_UNICAP         THEN "YES (ver ${UNICAP_libunicap_VERSION})"   ELSE NO)
-  status("    UniCap ucil:"    HAVE_UNICAP         THEN "YES (ver ${UNICAP_libucil_VERSION})"     ELSE NO)
+if(HAVE_CAP_IOS)
+  status("    iOS capture:" YES)
 endif()
 
-if(WITH_V4L OR WITH_LIBV4L OR HAVE_LIBV4L OR HAVE_CAMV4L OR HAVE_CAMV4L2 OR HAVE_VIDEOIO)
-  status("    libv4l/libv4l2:" HAVE_LIBV4L THEN "${LIBV4L_libv4l1_VERSION} / ${LIBV4L_libv4l2_VERSION}" ELSE "NO")
+if(WITH_V4L OR HAVE_V4L)
   ocv_build_features_string(v4l_status
-    IF HAVE_CAMV4L THEN "linux/videodev.h"
     IF HAVE_CAMV4L2 THEN "linux/videodev2.h"
     IF HAVE_VIDEOIO THEN "sys/videoio.h"
     ELSE "NO")
-  status("    v4l/v4l2:" "${v4l_status}")
+  status("    v4l/v4l2:" HAVE_V4L THEN "YES (${v4l_status})" ELSE NO)
 endif()
 
 if(WITH_DSHOW OR HAVE_DSHOW)
-  status("    DirectShow:"     HAVE_DSHOW     THEN YES                                        ELSE NO)
+  status("    DirectShow:" HAVE_DSHOW THEN YES ELSE NO)
 endif()
 
 if(WITH_MSMF OR HAVE_MSMF)
-  status("    Media Foundation:" HAVE_MSMF    THEN YES                                        ELSE NO)
-  status("      DXVA:"           HAVE_MSMF_DXVA    THEN YES    ELSE NO)
+  status("    Media Foundation:" HAVE_MSMF THEN YES ELSE NO)
+  status("      DXVA:" HAVE_MSMF_DXVA THEN YES ELSE NO)
 endif()
 
 if(WITH_XIMEA OR HAVE_XIMEA)
-  status("    XIMEA:"          HAVE_XIMEA          THEN YES                                        ELSE NO)
+  status("    XIMEA:" HAVE_XIMEA THEN YES ELSE NO)
 endif()
 
 if(WITH_XINE OR HAVE_XINE)
   status("    Xine:"           HAVE_XINE           THEN "YES (ver ${XINE_VERSION})"     ELSE NO)
 endif()
 
-if(WITH_INTELPERC OR HAVE_INTELPERC)
-  status("    Intel PerC:"     HAVE_INTELPERC      THEN "YES"                                 ELSE NO)
+if(WITH_LIBREALSENSE OR HAVE_LIBREALSENSE)
+  status("    Intel RealSense:" HAVE_LIBREALSENSE THEN "YES (${LIBREALSENSE_VERSION})" ELSE NO)
 endif()
 
 if(WITH_MFX OR HAVE_MFX)
@@ -1415,7 +1484,7 @@ endif()
 # Order is similar to CV_PARALLEL_FRAMEWORK in core/src/parallel.cpp
 ocv_build_features_string(parallel_status EXCLUSIVE
   IF HAVE_TBB THEN "TBB (ver ${TBB_VERSION_MAJOR}.${TBB_VERSION_MINOR} interface ${TBB_INTERFACE_VERSION})"
-  IF HAVE_CSTRIPES THEN "C="
+  IF HAVE_HPX THEN "HPX"
   IF HAVE_OPENMP THEN "OpenMP"
   IF HAVE_GCD THEN "GCD"
   IF WINRT OR HAVE_CONCURRENCY THEN "Concurrency"
@@ -1472,22 +1541,19 @@ endif()
 
 if(WITH_INF_ENGINE OR INF_ENGINE_TARGET)
   if(INF_ENGINE_TARGET)
-    list(GET INF_ENGINE_TARGET 0 ie_target)
     set(__msg "YES (${INF_ENGINE_RELEASE} / ${INF_ENGINE_VERSION})")
-    get_target_property(_lib ${ie_target} IMPORTED_LOCATION)
-    get_target_property(_lib_imp_rel ${ie_target} IMPORTED_IMPLIB_RELEASE)
-    get_target_property(_lib_imp_dbg ${ie_target} IMPORTED_IMPLIB_DEBUG)
-    get_target_property(_lib_rel ${ie_target} IMPORTED_LOCATION_RELEASE)
-    get_target_property(_lib_dbg ${ie_target} IMPORTED_LOCATION_DEBUG)
+    get_target_property(_lib ${INF_ENGINE_TARGET} IMPORTED_LOCATION)
+    get_target_property(_lib_imp_rel ${INF_ENGINE_TARGET} IMPORTED_IMPLIB_RELEASE)
+    get_target_property(_lib_imp_dbg ${INF_ENGINE_TARGET} IMPORTED_IMPLIB_DEBUG)
+    get_target_property(_lib_rel ${INF_ENGINE_TARGET} IMPORTED_LOCATION_RELEASE)
+    get_target_property(_lib_dbg ${INF_ENGINE_TARGET} IMPORTED_LOCATION_DEBUG)
     ocv_build_features_string(_lib
       IF _lib THEN "${_lib}"
       IF _lib_imp_rel AND _lib_imp_dbg THEN "${_lib_imp_rel} / ${_lib_imp_dbg}"
       IF _lib_rel AND _lib_dbg THEN "${_lib_rel} / ${_lib_dbg}"
-      IF _lib_rel  THEN "${_lib_rel}"
-      IF _lib_dbg  THEN "${_lib_dbg}"
       ELSE "unknown"
     )
-    get_target_property(_inc ${ie_target} INTERFACE_INCLUDE_DIRECTORIES)
+    get_target_property(_inc ${INF_ENGINE_TARGET} INTERFACE_INCLUDE_DIRECTORIES)
     status("    Inference Engine:" "${__msg}")
     status("                libs:" "${_lib}")
     status("            includes:" "${_inc}")
@@ -1523,6 +1589,20 @@ if(WITH_CUDA OR HAVE_CUDA)
     status("    NVIDIA GPU arch:"      ${OPENCV_CUDA_ARCH_BIN})
     status("    NVIDIA PTX archs:"     ${OPENCV_CUDA_ARCH_PTX})
   endif()
+ endif()
+
+ if(WITH_CUDNN OR HAVE_CUDNN)
+    status("")
+    status("  cuDNN:" HAVE_CUDNN THEN "YES (ver ${CUDNN_VERSION})" ELSE NO)
+endif()
+
+if(WITH_VULKAN OR HAVE_VULKAN)
+  status("")
+  status("  Vulkan:"     HAVE_VULKAN THEN "YES" ELSE "NO")
+  if(HAVE_VULKAN)
+    status("    Include path:"  VULKAN_INCLUDE_DIRS THEN "${VULKAN_INCLUDE_DIRS}" ELSE "NO")
+    status("    Link libraries:" VULKAN_LIBRARIES THEN "${VULKAN_LIBRARIES}" ELSE "Dynamic load")
+  endif()
 endif()
 
 if(WITH_OPENCL OR HAVE_OPENCL)
@@ -1577,7 +1657,7 @@ if(FLAKE8_FOUND AND FLAKE8_EXECUTABLE)
 endif()
 
 # ========================== java ==========================
-if(BUILD_JAVA)
+if(BUILD_JAVA OR BUILD_opencv_java)
   status("")
   status("  Java:"            BUILD_FAT_JAVA_LIB  THEN "export all functions"                                      ELSE "")
   status("    ant:"           ANT_EXECUTABLE      THEN "${ANT_EXECUTABLE} (ver ${ANT_VERSION})"                    ELSE NO)

README.md

@@ -2,8 +2,8 @@
 
 ### Resources
 
-* Homepage: <http://opencv.org>
-* Docs: <http://docs.opencv.org/master/>
+* Homepage: <https://opencv.org>
+* Docs: <https://docs.opencv.org/master/>
 * Q&A forum: <http://answers.opencv.org>
 * Issue tracking: <https://github.com/opencv/opencv/issues>
 

apps/CMakeLists.txt

@@ -49,8 +49,8 @@ macro(ocv_add_app directory)
   endif()
 endmacro()
 
-ocv_add_app(traincascade)
-ocv_add_app(createsamples)
+#ocv_add_app(traincascade)
+#ocv_add_app(createsamples)
 ocv_add_app(annotation)
 ocv_add_app(visualisation)
 ocv_add_app(interactive-calibration)

apps/createsamples/utility.cpp

@@ -895,7 +895,7 @@ void icvGetNextFromBackgroundData( CvBackgroundData* data,
  * #pragma omp parallel
  * {
  *     ...
- *     icvGetBackgroundImage( cvbgdata, cvbgreader, img );
+ *     icvGetBackgourndImage( cvbgdata, cvbgreader, img );
  *     ...
  * }
  * ...
@@ -990,7 +990,7 @@ static int icvInitBackgroundReaders( const char* filename, Size winsize )
 /*
  * icvDestroyBackgroundReaders
  *
- * Finish background reading process
+ * Finish backgournd reading process
  */
 static
 void icvDestroyBackgroundReaders()

apps/interactive-calibration/calibController.cpp

@@ -210,7 +210,7 @@ void calib::calibDataController::filterFrames()
                 worstElemIndex = i;
             }
         }
-        showOverlayMessage(cv::format("Frame %d is worst", worstElemIndex + 1));
+        showOverlayMessage(cv::format("Frame %zu is worst", worstElemIndex + 1));
 
         if(mCalibData->imagePoints.size()) {
             mCalibData->imagePoints.erase(mCalibData->imagePoints.begin() + worstElemIndex);

apps/interactive-calibration/frameProcessor.cpp

@@ -318,7 +318,7 @@ cv::Mat CalibProcessor::processFrame(const cv::Mat &frame)
             saveFrameData();
             bool isFrameBad = checkLastFrame();
             if (!isFrameBad) {
-                std::string displayMessage = cv::format("Frame # %d captured", std::max(mCalibData->imagePoints.size(),
+                std::string displayMessage = cv::format("Frame # %zu captured", std::max(mCalibData->imagePoints.size(),
                                                                                         mCalibData->allCharucoCorners.size()));
                 if(!showOverlayMessage(displayMessage))
                     showCaptureMessage(frame, displayMessage);

apps/traincascade/boost.cpp

@@ -30,7 +30,6 @@ using cv::ParallelLoopBody;
 #include "boost.h"
 #include "cascadeclassifier.h"
 #include <queue>
-#include "cxmisc.h"
 
 #include "cvconfig.h"
 

apps/traincascade/old_ml.hpp

@@ -144,8 +144,8 @@ public:
     CV_WRAP virtual void save( const char* filename, const char* name=0 ) const;
     CV_WRAP virtual void load( const char* filename, const char* name=0 );
 
-    virtual void write( CvFileStorage* storage, const char* name ) const;
-    virtual void read( CvFileStorage* storage, CvFileNode* node );
+    virtual void write( cv::FileStorage& storage, const char* name ) const;
+    virtual void read( const cv::FileNode& node );
 
 protected:
     const char* default_model_name;
@@ -210,8 +210,8 @@ public:
                        bool update=false );
     CV_WRAP virtual float predict( const cv::Mat& samples, CV_OUT cv::Mat* results=0, CV_OUT cv::Mat* results_prob=0 ) const;
 
-    virtual void write( CvFileStorage* storage, const char* name ) const;
-    virtual void read( CvFileStorage* storage, CvFileNode* node );
+    virtual void write( cv::FileStorage& storage, const char* name ) const;
+    virtual void read( const cv::FileNode& node );
 
 protected:
     int     var_count, var_all;
@@ -521,8 +521,8 @@ public:
 
     static CvParamGrid get_default_grid( int param_id );
 
-    virtual void write( CvFileStorage* storage, const char* name ) const;
-    virtual void read( CvFileStorage* storage, CvFileNode* node );
+    virtual void write( cv::FileStorage& storage, const char* name ) const;
+    virtual void read( const cv::FileNode& node );
     CV_WRAP int get_var_count() const { return var_idx ? var_idx->cols : var_all; }
 
 protected:
@@ -538,8 +538,8 @@ protected:
 
     virtual float predict( const float* row_sample, int row_len, bool returnDFVal=false ) const;
 
-    virtual void write_params( CvFileStorage* fs ) const;
-    virtual void read_params( CvFileStorage* fs, CvFileNode* node );
+    virtual void write_params( cv::FileStorage& fs ) const;
+    virtual void read_params( const cv::FileNode& node );
 
     void optimize_linear_svm();
 
@@ -673,8 +673,8 @@ struct CvDTreeTrainData
 
     virtual CvDTreeNode* subsample_data( const CvMat* _subsample_idx );
 
-    virtual void write_params( CvFileStorage* fs ) const;
-    virtual void read_params( CvFileStorage* fs, CvFileNode* node );
+    virtual void write_params( cv::FileStorage& fs ) const;
+    virtual void read_params( const cv::FileNode& node );
 
     // release all the data
     virtual void clear();
@@ -1738,7 +1738,7 @@ protected:
     // Read parameters of the gtb model and data.
     //
     // API
-    // virtual void read_params( CvFileStorage* fs );
+    // virtual void read_params( const cv::FileStorage& fs );
     //
     // INPUT
     // fs           - file storage to read parameters from.
@@ -2033,7 +2033,8 @@ typedef CvANN_MLP NeuralNet_MLP;
 typedef CvGBTreesParams GradientBoostingTreeParams;
 typedef CvGBTrees GradientBoostingTrees;
 
-template<> void DefaultDeleter<CvDTreeSplit>::operator ()(CvDTreeSplit* obj) const;
+template<> struct DefaultDeleter<CvDTreeSplit>{ void operator ()(CvDTreeSplit* obj) const; };
+
 }
 
 #endif // __cplusplus

apps/traincascade/old_ml_tree.cpp

@@ -1880,10 +1880,7 @@ double CvDTree::calc_node_dir( CvDTreeNode* node )
 namespace cv
 {
 
-template<> void DefaultDeleter<CvDTreeSplit>::operator ()(CvDTreeSplit* obj) const
-{
-    fastFree(obj);
-}
+void DefaultDeleter<CvDTreeSplit>::operator ()(CvDTreeSplit* obj) const { fastFree(obj); }
 
 DTreeBestSplitFinder::DTreeBestSplitFinder( CvDTree* _tree, CvDTreeNode* _node)
 {

cmake/FindCUDA/run_nvcc.cmake

@@ -136,7 +136,7 @@ macro(cuda_execute_process status command)
     # copy and paste a runnable command line.
     set(cuda_execute_process_string)
     foreach(arg ${ARGN})
-      # If there are quotes, escape them, so they come through.
+      # If there are quotes, excape them, so they come through.
       string(REPLACE "\"" "\\\"" arg ${arg})
       # Args with spaces need quotes around them to get them to be parsed as a single argument.
       if(arg MATCHES " ")

cmake/FindCUDNN.cmake

@@ -0,0 +1,105 @@
+# template taken from https://cmake.org/cmake/help/v3.14/manual/cmake-developer.7.html
+
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+FindCUDNN
+---------
+
+Finds the cuDNN library.
+
+Requires:
+^^^^^^^^^
+
+find_cuda_helper_libs from FindCUDA.cmake
+i.e. CUDA module should be found using FindCUDA.cmake before attempting to find cuDNN
+
+Result Variables
+^^^^^^^^^^^^^^^^
+
+This will define the following variables:
+
+``CUDNN_FOUND``
+``CUDNN_INCLUDE_DIRS``    location of cudnn.h
+``CUDNN_LIBRARIES``       location of cudnn library
+
+Cache Variables
+^^^^^^^^^^^^^^^
+
+The following cache variables will be set if cuDNN was found. They may also be set on failure.
+
+``CUDNN_LIBRARY``
+``CUDNN_INCLUDE_DIR``
+``CUDNN_VERSION``
+
+``CUDNN_VERSION_MAJOR`` INTERNAL
+``CUDNN_VERSION_MINOR`` INTERNAL
+``CUDNN_VERSION_PATCH`` INTERNAL
+
+#]=======================================================================]
+
+# find the library
+if(CUDA_FOUND)
+  find_cuda_helper_libs(cudnn)
+  set(CUDNN_LIBRARY ${CUDA_cudnn_LIBRARY} CACHE FILEPATH "location of the cuDNN library")
+  unset(CUDA_cudnn_LIBRARY CACHE)
+endif()
+
+# find the include
+if(CUDNN_LIBRARY)
+  find_path(CUDNN_INCLUDE_DIR
+    cudnn.h
+    PATHS ${CUDA_TOOLKIT_INCLUDE}
+    DOC "location of cudnn.h"
+    NO_DEFAULT_PATH
+  )
+
+  if(NOT CUDNN_INCLUDE_DIR)
+    find_path(CUDNN_INCLUDE_DIR
+      cudnn.h
+      DOC "location of cudnn.h"
+    )
+  endif()
+endif()
+
+# extract version from the include
+if(CUDNN_INCLUDE_DIR)
+  file(READ "${CUDNN_INCLUDE_DIR}/cudnn.h" CUDNN_H_CONTENTS)
+
+  string(REGEX MATCH "define CUDNN_MAJOR ([0-9]+)" _ "${CUDNN_H_CONTENTS}")
+  set(CUDNN_MAJOR_VERSION ${CMAKE_MATCH_1} CACHE INTERNAL "")
+  string(REGEX MATCH "define CUDNN_MINOR ([0-9]+)" _ "${CUDNN_H_CONTENTS}")
+  set(CUDNN_MINOR_VERSION ${CMAKE_MATCH_1} CACHE INTERNAL "")
+  string(REGEX MATCH "define CUDNN_PATCHLEVEL ([0-9]+)" _ "${CUDNN_H_CONTENTS}")
+  set(CUDNN_PATCH_VERSION ${CMAKE_MATCH_1} CACHE INTERNAL "")
+
+  set(CUDNN_VERSION
+    "${CUDNN_MAJOR_VERSION}.${CUDNN_MINOR_VERSION}.${CUDNN_PATCH_VERSION}"
+    CACHE
+    STRING
+    "cuDNN version"
+  )
+
+  unset(CUDNN_H_CONTENTS)
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(CUDNN
+  FOUND_VAR CUDNN_FOUND
+  REQUIRED_VARS
+    CUDNN_LIBRARY
+    CUDNN_INCLUDE_DIR
+  VERSION_VAR CUDNN_VERSION
+)
+
+if(CUDNN_FOUND)
+  set(CUDNN_LIBRARIES ${CUDNN_LIBRARY})
+  set(CUDNN_INCLUDE_DIRS ${CUDNN_INCLUDE_DIR})
+endif()
+
+mark_as_advanced(
+  CUDNN_LIBRARY
+  CUDNN_INCLUDE_DIR
+  CUDNN_VERSION
+)

cmake/FindGstreamerWindows.cmake

@@ -1,139 +0,0 @@
-FILE(TO_CMAKE_PATH "$ENV{GSTREAMER_DIR}" TRY1_DIR)
-FILE(TO_CMAKE_PATH "${GSTREAMER_DIR}" TRY2_DIR)
-FILE(GLOB GSTREAMER_DIR ${TRY1_DIR} ${TRY2_DIR})
-
-FIND_PATH(GSTREAMER_gst_INCLUDE_DIR gst/gst.h
-          PATHS ${GSTREAMER_DIR}/include/gstreamer-1.0 ${GSTREAMER_DIR}/include /usr/local/include/gstreamer-1.0 /usr/include/gstreamer-1.0
-          ENV INCLUDE DOC "Directory containing gst/gst.h include file")
-
-FIND_PATH(GSTREAMER_glib_INCLUDE_DIR glib.h
-    PATHS ${GSTREAMER_DIR}/include/glib-2.0/
-    ENV INCLUDE DOC "Directory containing glib.h include file")
-
-FIND_PATH(GSTREAMER_glibconfig_INCLUDE_DIR glibconfig.h
-    PATHS ${GSTREAMER_DIR}/lib/glib-2.0/include
-    ENV INCLUDE DOC "Directory containing glibconfig.h include file")
-
-FIND_PATH(GSTREAMER_gstconfig_INCLUDE_DIR gst/gstconfig.h
-                                          PATHS ${GSTREAMER_DIR}/lib/gstreamer-1.0/include ${GSTREAMER_DIR}/include ${GSTREAMER_DIR}/include/gstreamer-1.0 ${GSTREAMER_DIR}/lib/include /usr/local/include/gstreamer-1.0 /usr/include/gstreamer-1.0 /usr/local/lib/include/gstreamer-1.0 /usr/lib/include/gstreamer-1.0
-                                          ENV INCLUDE DOC "Directory containing gst/gstconfig.h include file")
-
-FIND_LIBRARY(GSTREAMER_gstaudio_LIBRARY NAMES gstaudio libgstaudio-1.0 gstaudio-1.0
-                                        PATHS ${GSTREMAER_DIR}/lib ${GSTREAMER_DIR}/bin ${GSTREAMER_DIR}/win32/bin ${GSTREAMER_DIR}/bin/bin C:/gstreamer/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/lib /usr/local/lib /usr/lib
-                                        ENV LIB
-                                        DOC "gstaudio library to link with"
-                                        NO_SYSTEM_ENVIRONMENT_PATH)
-
-FIND_LIBRARY(GSTREAMER_gstapp_LIBRARY NAMES gstapp libgstapp-1.0 gstapp-1.0
-                                        PATHS ${GSTREAMER_DIR}/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/bin ${GSTREAMER_DIR}/bin/bin C:/gstreamer/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/lib /usr/local/lib /usr/lib
-                                        ENV LIB
-                                        DOC "gstapp library to link with"
-                                        NO_SYSTEM_ENVIRONMENT_PATH)
-
-FIND_LIBRARY(GSTREAMER_gstbase_LIBRARY NAMES gstbase libgstbase-1.0 gstbase-1.0
-                                       PATHS ${GSTREAMER_DIR}/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/bin ${GSTREAMER_DIR}/bin/bin C:/gstreamer/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/lib /usr/local/lib /usr/lib
-                                       ENV LIB
-                                       DOC "gstbase library to link with"
-                                       NO_SYSTEM_ENVIRONMENT_PATH)
-
-FIND_LIBRARY(GLIB_gstcdda_LIBRARY NAMES gstcdda libgstcdda-1.0 gstcdda-1.0
-                                  PATHS ${GSTREAMER_DIR}/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/bin ${GSTREAMER_DIR}/bin/bin C:/gstreamer/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/lib /usr/local/lib /usr/lib
-                                  ENV LIB
-                                  DOC "gstcdda library to link with"
-                                  NO_SYSTEM_ENVIRONMENT_PATH)
-
-FIND_LIBRARY(GSTREAMER_gstcontroller_LIBRARY NAMES gstcontroller libgstcontroller-1.0 gstcontroller-1.0
-                                             PATHS ${GSTREAMER_DIR}/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/bin ${GSTREAMER_DIR}/bin/bin C:/gstreamer/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/lib /usr/local/lib /usr/lib
-                                             ENV LIB
-                                             DOC "gstcontroller library to link with"
-                                             NO_SYSTEM_ENVIRONMENT_PATH)
-
-
-FIND_LIBRARY(GSTREAMER_gstnet_LIBRARY NAMES gstnet libgstnet-1.0 gstnet-1.0
-                                      PATHS ${GSTREAMER_DIR}/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/bin ${GSTREAMER_DIR}/bin/bin C:/gstreamer/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/lib /usr/local/lib /usr/lib
-                                      ENV LIB
-                                      DOC "gstnet library to link with"
-                                      NO_SYSTEM_ENVIRONMENT_PATH)
-
-FIND_LIBRARY(GSTREAMER_gstpbutils_LIBRARY NAMES gstpbutils libgstpbutils-1.0 gstpbutils-1.0
-                                          PATHS ${GSTREAMER_DIR}/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/bin ${GSTREAMER_DIR}/bin/bin C:/gstreamer/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/lib /usr/local/lib /usr/lib
-                                          ENV LIB
-                                          DOC "gstpbutils library to link with"
-                                          NO_SYSTEM_ENVIRONMENT_PATH)
-
-FIND_LIBRARY(GSTREAMER_gstreamer_LIBRARY NAMES gstreamer libgstreamer-1.0 gstreamer-1.0
-                                         PATHS ${GSTREAMER_DIR}/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/bin ${GSTREAMER_DIR}/bin/bin C:/gstreamer/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/lib /usr/local/lib /usr/lib
-                                         ENV LIB
-                                         DOC "gstreamer library to link with"
-                                         NO_SYSTEM_ENVIRONMENT_PATH)
-
-FIND_LIBRARY(GSTREAMER_gstriff_LIBRARY NAMES gstriff libgstriff-1.0 gstriff-1.0
-                                             PATHS ${GSTREAMER_DIR}/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/bin ${GSTREAMER_DIR}/bin/bin C:/gstreamer/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/lib /usr/local/lib /usr/lib
-                                             ENV LIB
-                                             DOC "gstriff library to link with"
-                                             NO_SYSTEM_ENVIRONMENT_PATH)
-
-FIND_LIBRARY(GSTREAMER_gstrtp_LIBRARY NAMES gstrtp libgstrtp-1.0 gstrtp-1.0
-                                    PATHS ${GSTREAMER_DIR}/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/bin ${GSTREAMER_DIR}/bin/bin C:/gstreamer/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/lib /usr/local/lib /usr/lib
-                                    ENV LIB
-                                    DOC "gstrtp library to link with"
-                                    NO_SYSTEM_ENVIRONMENT_PATH)
-
-FIND_LIBRARY(GSTREAMER_gstrtsp_LIBRARY NAMES gstrtsp libgstrtsp-1.0 gstrtsp-1.0
-                                       PATHS ${GSTREAMER_DIR}/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/bin ${GSTREAMER_DIR}/bin/bin C:/gstreamer/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/lib /usr/local/lib /usr/lib
-                                       ENV LIB
-                                       DOC "gstrtsp library to link with"
-                                       NO_SYSTEM_ENVIRONMENT_PATH)
-
-FIND_LIBRARY(GSTREAMER_gstsdp_LIBRARY NAMES gstsdp libgstsdp-1.0 gstsdp-1.0
-                                      PATHS ${GSTREAMER_DIR}/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/bin ${GSTREAMER_DIR}/bin/bin C:/gstreamer/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/lib /usr/local/lib /usr/lib
-                                      ENV LIB
-                                      DOC "gstsdp library to link with"
-                                      NO_SYSTEM_ENVIRONMENT_PATH)
-
-FIND_LIBRARY(GSTREAMER_gsttag_LIBRARY NAMES gsttag libgsttag-1.0 gsttag-1.0
-                                 PATHS ${GSTREAMER_DIR}/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/bin ${GSTREAMER_DIR}/bin/bin C:/gstreamer/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/lib /usr/local/lib /usr/lib
-                                 ENV LIB
-                                 DOC "gsttag library to link with"
-                                 NO_SYSTEM_ENVIRONMENT_PATH)
-
-FIND_LIBRARY(GSTREAMER_gstvideo_LIBRARY NAMES gstvideo libgstvideo-1.0 gstvideo-1.0
-                                        PATHS ${GSTREAMER_DIR}/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/bin ${GSTREAMER_DIR}/bin/bin C:/gstreamer/bin ${GSTREAMER_DIR}/lib ${GSTREAMER_DIR}/win32/lib /usr/local/lib /usr/lib
-                                        ENV LIB
-                                        DOC "gstvideo library to link with"
-                                        NO_SYSTEM_ENVIRONMENT_PATH)
-
-FIND_LIBRARY(GLIB_LIBRARY NAMES libglib-2.0 glib-2.0
-                PATHS ${GSTREAMER_DIR}/lib
-                ENV LIB
-                DOC "Glib library"
-                NO_SYSTEM_ENVIRONMENT_PATH)
-
-FIND_LIBRARY(GOBJECT_LIBRARY NAMES libobject-2.0 gobject-2.0
-                PATHS ${GSTREAMER_DIR}/lib
-                ENV LIB
-                DOC "Glib library"
-                NO_SYSTEM_ENVIRONMENT_PATH)
-
-IF (GSTREAMER_gst_INCLUDE_DIR AND GSTREAMER_gstconfig_INCLUDE_DIR AND
-    GSTREAMER_gstaudio_LIBRARY AND GSTREAMER_gstbase_LIBRARY AND GSTREAMER_gstcontroller_LIBRARY AND GSTREAMER_gstnet_LIBRARY
-    AND GSTREAMER_gstpbutils_LIBRARY AND GSTREAMER_gstreamer_LIBRARY AND
-    GSTREAMER_gstriff_LIBRARY AND GSTREAMER_gstrtp_LIBRARY AND GSTREAMER_gstrtsp_LIBRARY AND GSTREAMER_gstsdp_LIBRARY AND
-    GSTREAMER_gsttag_LIBRARY AND GSTREAMER_gstvideo_LIBRARY AND GLIB_LIBRARY AND GSTREAMER_gstapp_LIBRARY AND GOBJECT_LIBRARY)
-  SET(GSTREAMER_INCLUDE_DIR ${GSTREAMER_gst_INCLUDE_DIR} ${GSTREAMER_gstconfig_INCLUDE_DIR} ${GSTREAMER_glib_INCLUDE_DIR} ${GSTREAMER_glibconfig_INCLUDE_DIR})
-
-  list(REMOVE_DUPLICATES GSTREAMER_INCLUDE_DIR)
-  SET(GSTREAMER_LIBRARIES ${GSTREAMER_gstaudio_LIBRARY} ${GSTREAMER_gstbase_LIBRARY}
-                          ${GSTREAMER_gstcontroller_LIBRARY} ${GSTREAMER_gstdataprotocol_LIBRARY} ${GSTREAMER_gstinterfaces_LIBRARY}
-                          ${GSTREAMER_gstnet_LIBRARY} ${GSTREAMER_gstpbutils_LIBRARY}
-                          ${GSTREAMER_gstreamer_LIBRARY} ${GSTREAMER_gstriff_LIBRARY} ${GSTREAMER_gstrtp_LIBRARY}
-                          ${GSTREAMER_gstrtsp_LIBRARY} ${GSTREAMER_gstsdp_LIBRARY} ${GSTREAMER_gsttag_LIBRARY} ${GSTREAMER_gstvideo_LIBRARY} ${GLIB_LIBRARY}
-                          ${GSTREAMER_gstapp_LIBRARY} ${GOBJECT_LIBRARY})
-
-  list(REMOVE_DUPLICATES GSTREAMER_LIBRARIES)
-  SET(GSTREAMER_FOUND TRUE)
-ENDIF (GSTREAMER_gst_INCLUDE_DIR AND GSTREAMER_gstconfig_INCLUDE_DIR AND
-       GSTREAMER_gstaudio_LIBRARY AND GSTREAMER_gstbase_LIBRARY AND GSTREAMER_gstcontroller_LIBRARY
-       AND GSTREAMER_gstnet_LIBRARY AND GSTREAMER_gstpbutils_LIBRARY AND GSTREAMER_gstreamer_LIBRARY AND
-       GSTREAMER_gstriff_LIBRARY AND GSTREAMER_gstrtp_LIBRARY AND GSTREAMER_gstrtsp_LIBRARY AND GSTREAMER_gstsdp_LIBRARY AND
-       GSTREAMER_gsttag_LIBRARY AND GSTREAMER_gstvideo_LIBRARY AND GLIB_LIBRARY AND GSTREAMER_gstapp_LIBRARY AND GOBJECT_LIBRARY)

cmake/FindVulkan.cmake

@@ -0,0 +1,27 @@
+# Find Vulkan
+#
+# Vulkan_INCLUDE_DIRS
+# Vulkan_LIBRARIES
+# Vulkan_FOUND
+if (WIN32)
+    find_path(Vulkan_INCLUDE_DIRS NAMES vulkan/vulkan.h HINTS
+        "$ENV{VULKAN_SDK}/Include"
+        "$ENV{VK_SDK_PATH}/Include")
+    if (CMAKE_CL_64)
+        find_library(Vulkan_LIBRARIES NAMES vulkan-1 HINTS
+            "$ENV{VULKAN_SDK}/Bin"
+            "$ENV{VK_SDK_PATH}/Bin")
+    else()
+        find_library(Vulkan_LIBRARIES NAMES vulkan-1 HINTS
+            "$ENV{VULKAN_SDK}/Bin32"
+            "$ENV{VK_SDK_PATH}/Bin32")
+    endif()
+else()
+    find_path(Vulkan_INCLUDE_DIRS NAMES vulkan/vulkan.h HINTS
+        "$ENV{VULKAN_SDK}/include")
+    find_library(Vulkan_LIBRARIES NAMES vulkan HINTS
+        "$ENV{VULKAN_SDK}/lib")
+endif()
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Vulkan DEFAULT_MSG Vulkan_LIBRARIES Vulkan_INCLUDE_DIRS)
+mark_as_advanced(Vulkan_INCLUDE_DIRS Vulkan_LIBRARIES)

cmake/OpenCVCRTLinkage.cmake

@@ -4,6 +4,16 @@ if(NOT MSVC)
   message(FATAL_ERROR "CRT options are available only for MSVC")
 endif()
 
+if (WINRT)
+  if (CMAKE_SYSTEM_VERSION MATCHES 10)
+    add_definitions(/DWINVER=_WIN32_WINNT_WIN10 /DNTDDI_VERSION=NTDDI_WIN10 /D_WIN32_WINNT=_WIN32_WINNT_WIN10)
+  elseif(CMAKE_SYSTEM_VERSION MATCHES 8.1)
+    add_definitions(/DWINVER=_WIN32_WINNT_WINBLUE /DNTDDI_VERSION=NTDDI_WINBLUE /D_WIN32_WINNT=_WIN32_WINNT_WINBLUE)
+  else()
+    add_definitions(/DWINVER=_WIN32_WINNT_WIN8 /DNTDDI_VERSION=NTDDI_WIN8 /D_WIN32_WINNT=_WIN32_WINNT_WIN8)
+  endif()
+endif()
+
 # Removing LNK4075 warnings for debug WinRT builds
 # "LNK4075: ignoring '/INCREMENTAL' due to '/OPT:ICF' specification"
 # "LNK4075: ignoring '/INCREMENTAL' due to '/OPT:REF' specification"

cmake/OpenCVCompilerOptimizations.cmake

@@ -5,15 +5,13 @@
 # AVX / AVX2 / AVX_512F
 # FMA3
 #
-# AVX512 details: https://en.wikipedia.org/wiki/AVX-512#CPUs_with_AVX-512
-#
 # CPU features groups:
 # AVX512_COMMON (Common instructions AVX-512F/CD for all CPUs that support AVX-512)
 # AVX512_KNL (Knights Landing with AVX-512F/CD/ER/PF)
 # AVX512_KNM (Knights Mill with AVX-512F/CD/ER/PF/4FMAPS/4VNNIW/VPOPCNTDQ)
 # AVX512_SKX (Skylake-X with AVX-512F/CD/BW/DQ/VL)
 # AVX512_CNL (Cannon Lake with AVX-512F/CD/BW/DQ/VL/IFMA/VBMI)
-# AVX512_CLX (Cascade Lake with AVX-512F/CD/BW/DQ/VL/VNNI)
+# AVX512_CEL (Cascade Lake with AVX-512F/CD/BW/DQ/VL/IFMA/VBMI/VNNI)
 # AVX512_ICL (Ice Lake with AVX-512F/CD/BW/DQ/VL/IFMA/VBMI/VNNI/VBMI2/BITALG/VPOPCNTDQ/VPCLMULQDQ*/GFNI*/VAES*)
 
 # ppc64le arch:
@@ -45,9 +43,8 @@
 # CPU_{opt}_ENABLED_DEFAULT=ON/OFF - has compiler support without additional flag (CPU_BASELINE_DETECT=ON only)
 
 set(CPU_ALL_OPTIMIZATIONS "SSE;SSE2;SSE3;SSSE3;SSE4_1;SSE4_2;POPCNT;AVX;FP16;AVX2;FMA3;AVX_512F")
-list(APPEND CPU_ALL_OPTIMIZATIONS "AVX512_COMMON;AVX512_KNL;AVX512_KNM;AVX512_SKX;AVX512_CNL;AVX512_CLX;AVX512_ICL")
+list(APPEND CPU_ALL_OPTIMIZATIONS "AVX512_COMMON;AVX512_KNL;AVX512_KNM;AVX512_SKX;AVX512_CNL;AVX512_CEL;AVX512_ICL")
 list(APPEND CPU_ALL_OPTIMIZATIONS NEON VFPV3 FP16)
-list(APPEND CPU_ALL_OPTIMIZATIONS MSA)
 list(APPEND CPU_ALL_OPTIMIZATIONS VSX VSX3)
 list(REMOVE_DUPLICATES CPU_ALL_OPTIMIZATIONS)
 
@@ -165,15 +162,15 @@ elseif(" ${CMAKE_CXX_FLAGS} " MATCHES " -march=native | -xHost | /QxHost ")
 endif()
 
 if(X86 OR X86_64)
-  ocv_update(CPU_KNOWN_OPTIMIZATIONS "SSE;SSE2;SSE3;SSSE3;SSE4_1;POPCNT;SSE4_2;FP16;FMA3;AVX;AVX2;AVX_512F;AVX512_COMMON;AVX512_KNL;AVX512_KNM;AVX512_SKX;AVX512_CNL;AVX512_CLX;AVX512_ICL")
+  ocv_update(CPU_KNOWN_OPTIMIZATIONS "SSE;SSE2;SSE3;SSSE3;SSE4_1;POPCNT;SSE4_2;FP16;FMA3;AVX;AVX2;AVX_512F;AVX512_COMMON;AVX512_KNL;AVX512_KNM;AVX512_SKX;AVX512_CNL;AVX512_CEL;AVX512_ICL")
 
   ocv_update(CPU_AVX512_COMMON_GROUP "AVX_512F;AVX_512CD")
   ocv_update(CPU_AVX512_KNL_GROUP "AVX512_COMMON;AVX512_KNL_EXTRA")
   ocv_update(CPU_AVX512_KNM_GROUP "AVX512_KNL;AVX512_KNM_EXTRA;AVX_512VPOPCNTDQ")
   ocv_update(CPU_AVX512_SKX_GROUP "AVX512_COMMON;AVX_512VL;AVX_512BW;AVX_512DQ")
   ocv_update(CPU_AVX512_CNL_GROUP "AVX512_SKX;AVX_512IFMA;AVX_512VBMI")
-  ocv_update(CPU_AVX512_CLX_GROUP "AVX512_SKX;AVX_512VNNI")
-  ocv_update(CPU_AVX512_ICL_GROUP "AVX512_SKX;AVX_512IFMA;AVX_512VBMI;AVX_512VNNI;AVX_512VBMI2;AVX_512BITALG;AVX_512VPOPCNTDQ") # ? VPCLMULQDQ, GFNI, VAES
+  ocv_update(CPU_AVX512_CEL_GROUP "AVX512_CNL;AVX_512VNNI")
+  ocv_update(CPU_AVX512_ICL_GROUP "AVX512_CEL;AVX_512VBMI2;AVX_512BITALG;AVX_512VPOPCNTDQ") # ? VPCLMULQDQ, GFNI, VAES
 
   ocv_update(CPU_SSE_TEST_FILE "${OpenCV_SOURCE_DIR}/cmake/checks/cpu_sse.cpp")
   ocv_update(CPU_SSE2_TEST_FILE "${OpenCV_SOURCE_DIR}/cmake/checks/cpu_sse2.cpp")
@@ -191,12 +188,12 @@ if(X86 OR X86_64)
   ocv_update(CPU_AVX512_KNM_TEST_FILE "${OpenCV_SOURCE_DIR}/cmake/checks/cpu_avx512knm.cpp")
   ocv_update(CPU_AVX512_SKX_TEST_FILE "${OpenCV_SOURCE_DIR}/cmake/checks/cpu_avx512skx.cpp")
   ocv_update(CPU_AVX512_CNL_TEST_FILE "${OpenCV_SOURCE_DIR}/cmake/checks/cpu_avx512cnl.cpp")
-  ocv_update(CPU_AVX512_CLX_TEST_FILE "${OpenCV_SOURCE_DIR}/cmake/checks/cpu_avx512clx.cpp")
+  ocv_update(CPU_AVX512_CEL_TEST_FILE "${OpenCV_SOURCE_DIR}/cmake/checks/cpu_avx512cel.cpp")
   ocv_update(CPU_AVX512_ICL_TEST_FILE "${OpenCV_SOURCE_DIR}/cmake/checks/cpu_avx512icl.cpp")
 
   if(NOT OPENCV_CPU_OPT_IMPLIES_IGNORE)
-    ocv_update(CPU_AVX512_ICL_IMPLIES "AVX512_SKX")
-    ocv_update(CPU_AVX512_CLX_IMPLIES "AVX512_SKX")
+    ocv_update(CPU_AVX512_ICL_IMPLIES "AVX512_CEL")
+    ocv_update(CPU_AVX512_CEL_IMPLIES "AVX512_CNL")
     ocv_update(CPU_AVX512_CNL_IMPLIES "AVX512_SKX")
     ocv_update(CPU_AVX512_SKX_IMPLIES "AVX512_COMMON")
     ocv_update(CPU_AVX512_KNM_IMPLIES "AVX512_KNL")
@@ -253,7 +250,7 @@ if(X86 OR X86_64)
     ocv_intel_compiler_optimization_option(AVX512_KNM "-xKNM" "/Qx:KNM")
     ocv_intel_compiler_optimization_option(AVX512_SKX "-xSKYLAKE-AVX512" "/Qx:SKYLAKE-AVX512")
     ocv_intel_compiler_optimization_option(AVX512_CNL "-xCANNONLAKE" "/Qx:CANNONLAKE")
-    ocv_intel_compiler_optimization_option(AVX512_CLX "-xCASCADELAKE" "/Qx:CASCADELAKE")
+    ocv_intel_compiler_optimization_option(AVX512_CEL "-xCASCADELAKE" "/Qx:CASCADELAKE")
     ocv_intel_compiler_optimization_option(AVX512_ICL "-xICELAKE-CLIENT" "/Qx:ICELAKE-CLIENT")
   elseif(CV_GCC OR CV_CLANG)
     ocv_update(CPU_AVX2_FLAGS_ON "-mavx2")
@@ -342,11 +339,6 @@ elseif(ARM OR AARCH64)
     ocv_update(CPU_FP16_IMPLIES "NEON")
     set(CPU_BASELINE "NEON;FP16" CACHE STRING "${HELP_CPU_BASELINE}")
   endif()
-elseif(MIPS)
-  ocv_update(CPU_MSA_TEST_FILE "${OpenCV_SOURCE_DIR}/cmake/checks/cpu_msa.cpp")
-  ocv_update(CPU_KNOWN_OPTIMIZATIONS "MSA")
-  ocv_update(CPU_MSA_FLAGS_ON "-mmsa")
-  set(CPU_BASELINE "MSA" CACHE STRING "${HELP_CPU_BASELINE}")
 elseif(PPC64LE)
   ocv_update(CPU_KNOWN_OPTIMIZATIONS "VSX;VSX3")
   ocv_update(CPU_VSX_TEST_FILE "${OpenCV_SOURCE_DIR}/cmake/checks/cpu_vsx.cpp")
@@ -862,7 +854,7 @@ macro(__ocv_add_dispatched_file filename target_src_var src_directory dst_direct
 
       if(";${CPU_DISPATCH_FINAL};" MATCHES "${OPT}" OR __CPU_DISPATCH_INCLUDE_ALL)
         if(EXISTS "${src_directory}/${filename}.${OPT_LOWER}.cpp")
-          message(STATUS "Using overridden ${OPT} source: ${src_directory}/${filename}.${OPT_LOWER}.cpp")
+          message(STATUS "Using overrided ${OPT} source: ${src_directory}/${filename}.${OPT_LOWER}.cpp")
         else()
           list(APPEND ${target_src_var} "${__file}")
         endif()

cmake/OpenCVCompilerOptions.cmake

@@ -117,13 +117,12 @@ if(CV_GCC OR CV_CLANG)
   add_extra_compiler_option(-Wundef)
   add_extra_compiler_option(-Winit-self)
   add_extra_compiler_option(-Wpointer-arith)
-  add_extra_compiler_option(-Wshadow)
+  if(NOT (CV_GCC AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS "5.0"))
+    add_extra_compiler_option(-Wshadow)  # old GCC emits warnings for variables + methods combination
+  endif()
   add_extra_compiler_option(-Wsign-promo)
   add_extra_compiler_option(-Wuninitialized)
   add_extra_compiler_option(-Winit-self)
-  if(CV_GCC AND (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 6.0) AND (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.0))
-    add_extra_compiler_option(-Wno-psabi)
-  endif()
   if(HAVE_CXX11)
     if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND NOT ENABLE_PRECOMPILED_HEADERS)
       add_extra_compiler_option(-Wsuggest-override)
@@ -283,6 +282,11 @@ if(MSVC)
   endif()
 endif()
 
+# Adding additional using directory for WindowsPhone 8.0 to get Windows.winmd properly
+if(WINRT_PHONE AND WINRT_8_0)
+  set(OPENCV_EXTRA_CXX_FLAGS "${OPENCV_EXTRA_CXX_FLAGS} /AI\$(WindowsSDK_MetadataPath)")
+endif()
+
 include(cmake/OpenCVCompilerOptimizations.cmake)
 if(COMMAND ocv_compiler_optimization_options)
   ocv_compiler_optimization_options()

cmake/OpenCVDetectApacheAnt.cmake

@@ -27,7 +27,7 @@ if(ANT_EXECUTABLE)
     unset(ANT_EXECUTABLE CACHE)
   else()
     string(REGEX MATCH "[0-9]+.[0-9]+.[0-9]+" ANT_VERSION "${ANT_VERSION_FULL}")
-    set(ANT_VERSION "${ANT_VERSION}" CACHE INTERNAL "Detected ant version")
+    set(ANT_VERSION "${ANT_VERSION}" CACHE INTERNAL "Detected ant vesion")
 
     message(STATUS "Found apache ant: ${ANT_EXECUTABLE} (${ANT_VERSION})")
   endif()

cmake/OpenCVDetectCStripes.cmake

@@ -1,11 +0,0 @@
-if(WIN32)
-    find_path( CSTRIPES_LIB_DIR
-               NAMES "C=.lib"
-               DOC "The path to C= lib and dll")
-    if(CSTRIPES_LIB_DIR)
-        ocv_include_directories("${CSTRIPES_LIB_DIR}/..")
-        link_directories("${CSTRIPES_LIB_DIR}")
-        set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} "C=")
-        set(HAVE_CSTRIPES 1)
-    endif()
-endif()

cmake/OpenCVDetectCUDA.cmake

@@ -37,6 +37,16 @@ if(CUDA_FOUND)
     set(HAVE_CUBLAS 1)
   endif()
 
+  if(WITH_CUDNN)
+      set(CMAKE_MODULE_PATH "${OpenCV_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
+      find_host_package(CUDNN "${MIN_VER_CUDNN}")
+      list(REMOVE_AT CMAKE_MODULE_PATH 0)
+
+      if(CUDNN_FOUND)
+        set(HAVE_CUDNN 1)
+      endif()
+  endif()
+
   if(WITH_NVCUVID)
     find_cuda_helper_libs(nvcuvid)
     if(WIN32)
@@ -70,6 +80,12 @@ if(CUDA_FOUND)
     unset(CUDA_ARCH_PTX CACHE)
   endif()
 
+  SET(DETECT_ARCHS_COMMAND "${CUDA_NVCC_EXECUTABLE}" ${CUDA_NVCC_FLAGS} "${OpenCV_SOURCE_DIR}/cmake/checks/OpenCVDetectCudaArch.cu" "--run")
+  if(WIN32 AND CMAKE_LINKER) #Workaround for VS cl.exe not being in the env. path
+    get_filename_component(host_compiler_bindir ${CMAKE_LINKER} DIRECTORY)
+    SET(DETECT_ARCHS_COMMAND ${DETECT_ARCHS_COMMAND} "-ccbin" "${host_compiler_bindir}")
+  endif()
+
   set(__cuda_arch_ptx "")
   if(CUDA_GENERATION STREQUAL "Fermi")
     set(__cuda_arch_bin "2.0")
@@ -84,10 +100,11 @@ if(CUDA_FOUND)
   elseif(CUDA_GENERATION STREQUAL "Turing")
     set(__cuda_arch_bin "7.5")
   elseif(CUDA_GENERATION STREQUAL "Auto")
-    execute_process( COMMAND "${CUDA_NVCC_EXECUTABLE}" ${CUDA_NVCC_FLAGS} "${OpenCV_SOURCE_DIR}/cmake/checks/OpenCVDetectCudaArch.cu" "--run"
+    execute_process( COMMAND ${DETECT_ARCHS_COMMAND}
                      WORKING_DIRECTORY "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/"
                      RESULT_VARIABLE _nvcc_res OUTPUT_VARIABLE _nvcc_out
                      ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+    string(REGEX REPLACE ".*\n" "" _nvcc_out "${_nvcc_out}") #Strip leading warning messages, if any
     if(NOT _nvcc_res EQUAL 0)
       message(STATUS "Automatic detection of CUDA generation failed. Going to build for all known architectures.")
     else()
@@ -101,10 +118,11 @@ if(CUDA_FOUND)
       set(__cuda_arch_bin "3.2")
       set(__cuda_arch_ptx "")
     elseif(AARCH64)
-      execute_process( COMMAND "${CUDA_NVCC_EXECUTABLE}" ${CUDA_NVCC_FLAGS} "${OpenCV_SOURCE_DIR}/cmake/checks/OpenCVDetectCudaArch.cu" "--run"
+      execute_process( COMMAND ${DETECT_ARCHS_COMMAND}
                        WORKING_DIRECTORY "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/"
                        RESULT_VARIABLE _nvcc_res OUTPUT_VARIABLE _nvcc_out
                        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+      string(REGEX REPLACE ".*\n" "" _nvcc_out "${_nvcc_out}") #Strip leading warning messages, if any
       if(NOT _nvcc_res EQUAL 0)
         message(STATUS "Automatic detection of CUDA generation failed. Going to build for all known architectures.")
         set(__cuda_arch_bin "5.3 6.2 7.2")
@@ -244,7 +262,7 @@ if(CUDA_FOUND)
     endif()
 
     if(UNIX OR APPLE)
-      set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -Xcompiler -fPIC)
+      set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -Xcompiler -fPIC --std=c++11)
     endif()
     if(APPLE)
       set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -Xcompiler -fno-finite-math-only)
@@ -285,6 +303,13 @@ if(HAVE_CUDA)
     endforeach()
   endif()
 
+  if(HAVE_CUDNN)
+    foreach(p ${CUDNN_LIBRARIES})
+      get_filename_component(_tmp ${p} PATH)
+      list(APPEND CUDA_LIBS_PATH ${_tmp})
+    endforeach()
+  endif()
+
   if(HAVE_CUFFT)
     foreach(p ${CUDA_cufft_LIBRARY})
       get_filename_component(_tmp ${p} PATH)
@@ -303,7 +328,10 @@ if(HAVE_CUDA)
     set(CUDA_cublas_LIBRARY_ABS ${CUDA_cublas_LIBRARY})
     ocv_convert_to_lib_name(CUDA_cublas_LIBRARY ${CUDA_cublas_LIBRARY})
   endif()
-
+  if(HAVE_CUDNN)
+    set(CUDNN_LIBRARIES_ABS ${CUDNN_LIBRARIES})
+    ocv_convert_to_lib_name(CUDNN_LIBRARIES ${CUDNN_LIBRARIES})
+  endif()
   if(HAVE_CUFFT)
     set(CUDA_cufft_LIBRARY_ABS ${CUDA_cufft_LIBRARY})
     ocv_convert_to_lib_name(CUDA_cufft_LIBRARY ${CUDA_cufft_LIBRARY})

cmake/OpenCVDetectCXXCompiler.cmake

@@ -100,8 +100,6 @@ elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)64le")
   set(PPC64LE 1)
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)64")
   set(PPC64 1)
-elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(mips.*|MIPS.*)")
-  set(MIPS 1)
 endif()
 
 # Workaround for 32-bit operating systems on x86_64/aarch64 processor
@@ -177,18 +175,15 @@ if(CMAKE_VERSION VERSION_LESS "3.1")
   endforeach()
 endif()
 
-if(ENABLE_CXX11)
-  #cmake_minimum_required(VERSION 3.1.0 FATAL_ERROR)
-  set(CMAKE_CXX_STANDARD 11)
-  set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
-  set(CMAKE_CXX_EXTENSIONS OFF) # use -std=c++11 instead of -std=gnu++11
-  if(CMAKE_CXX11_COMPILE_FEATURES)
-    set(HAVE_CXX11 ON)
-  endif()
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
+set(CMAKE_CXX_EXTENSIONS OFF) # use -std=c++11 instead of -std=gnu++11
+if(CMAKE_CXX11_COMPILE_FEATURES)
+  set(HAVE_CXX11 ON)
 endif()
 if(NOT HAVE_CXX11)
   ocv_check_compiler_flag(CXX "" HAVE_CXX11 "${OpenCV_SOURCE_DIR}/cmake/checks/cxx11.cpp")
-  if(NOT HAVE_CXX11 AND ENABLE_CXX11)
+  if(NOT HAVE_CXX11)
     ocv_check_compiler_flag(CXX "-std=c++11" HAVE_STD_CXX11 "${OpenCV_SOURCE_DIR}/cmake/checks/cxx11.cpp")
     if(HAVE_STD_CXX11)
       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
@@ -196,21 +191,6 @@ if(NOT HAVE_CXX11)
     endif()
   endif()
 endif()
-
-if((HAVE_CXX11
-        AND NOT MSVC
-        AND NOT (X86 OR X86_64)
-    AND NOT OPENCV_SKIP_LIBATOMIC_COMPILER_CHECK)
-    OR OPENCV_FORCE_LIBATOMIC_COMPILER_CHECK
-)
-  ocv_check_compiler_flag(CXX "" HAVE_CXX_ATOMICS_WITHOUT_LIB "${OpenCV_SOURCE_DIR}/cmake/checks/atomic_check.cpp")
-  if(NOT HAVE_CXX_ATOMICS_WITHOUT_LIB)
-    list(APPEND CMAKE_REQUIRED_LIBRARIES atomic)
-    ocv_check_compiler_flag(CXX "" HAVE_CXX_ATOMICS_WITH_LIB "${OpenCV_SOURCE_DIR}/cmake/checks/atomic_check.cpp")
-    if(HAVE_CXX_ATOMICS_WITH_LIB)
-      list(APPEND OPENCV_LINKER_LIBS atomic)
-    else()
-      message(FATAL_ERROR "C++11 compiler must support std::atomic")
-    endif()
-  endif()
+if(NOT HAVE_CXX11)
+  message(FATAL_ERROR "OpenCV 4.x requires C++11")
 endif()

cmake/OpenCVDetectInferenceEngine.cmake

@@ -5,7 +5,7 @@
 #
 # Detect parameters:
 # 1. Native cmake IE package:
-#    - environment variable InferenceEngine_DIR is set to location of cmake module
+#    - enironment variable InferenceEngine_DIR is set to location of cmake module
 # 2. Custom location:
 #    - INF_ENGINE_INCLUDE_DIRS - headers search location
 #    - INF_ENGINE_LIB_DIRS     - library search location
@@ -17,13 +17,6 @@
 # INF_ENGINE_TARGET - set to name of imported library target representing InferenceEngine
 #
 
-if(NOT HAVE_CXX11)
-    message(WARNING "DL Inference engine requires C++11. You can turn it on via ENABLE_CXX11=ON CMake flag.")
-    return()
-endif()
-
-# =======================
-
 function(add_custom_ie_build _inc _lib _lib_rel _lib_dbg _msg)
   if(NOT _inc OR NOT (_lib OR _lib_rel OR _lib_dbg))
     return()
@@ -52,7 +45,7 @@ endfunction()
 
 find_package(InferenceEngine QUIET)
 if(InferenceEngine_FOUND)
-  set(INF_ENGINE_TARGET ${InferenceEngine_LIBRARIES})
+  set(INF_ENGINE_TARGET IE::inference_engine)
   set(INF_ENGINE_VERSION "${InferenceEngine_VERSION}" CACHE STRING "")
   message(STATUS "Detected InferenceEngine: cmake package")
 endif()
@@ -87,9 +80,9 @@ endif()
 
 if(INF_ENGINE_TARGET)
   if(NOT INF_ENGINE_RELEASE)
-    message(WARNING "InferenceEngine version have not been set, 2019R3 will be used by default. Set INF_ENGINE_RELEASE variable if you experience build errors.")
+    message(WARNING "InferenceEngine version have not been set, 2019R2 will be used by default. Set INF_ENGINE_RELEASE variable if you experience build errors.")
   endif()
-  set(INF_ENGINE_RELEASE "2019030000" CACHE STRING "Force IE version, should be in form YYYYAABBCC (e.g. 2018R2.0.2 -> 2018020002)")
+  set(INF_ENGINE_RELEASE "2019020000" CACHE STRING "Force IE version, should be in form YYYYAABBCC (e.g. 2018R2.0.2 -> 2018020002)")
   set_target_properties(${INF_ENGINE_TARGET} PROPERTIES
     INTERFACE_COMPILE_DEFINITIONS "HAVE_INF_ENGINE=1;INF_ENGINE_RELEASE=${INF_ENGINE_RELEASE}"
   )

cmake/OpenCVDetectMediaSDK.cmake

@@ -1,59 +0,0 @@
-set(HAVE_MFX 0)
-
-if (UNIX)
-    set(root "$ENV{MFX_HOME}")
-elseif(WIN32)
-    set(root "$ENV{INTELMEDIASDKROOT}")
-endif()
-
-# TODO: ICC? MINGW? ARM? IOS?
-if(WIN32)
-    if(X86_64)
-        set(arch "x64")
-    else()
-        set(arch "win32")
-    endif()
-elseif(UNIX)
-    set(arch "lin_x64")
-else()
-    # ???
-endif()
-
-find_path(MFX_INCLUDE mfxdefs.h PATHS "${root}/include" NO_DEFAULT_PATH)
-message(STATUS "MFX_INCLUDE: ${MFX_INCLUDE} (${root}/include)")
-find_library(MFX_LIBRARY NAMES mfx PATHS "${root}/lib/${arch}" NO_DEFAULT_PATH)
-if(MSVC)
-    if(MSVC14)
-        find_library(MFX_LIBRARY NAMES libmfx_vs2015.lib PATHS "${root}/lib/${arch}" NO_DEFAULT_PATH)
-    else()
-        find_library(MFX_LIBRARY NAMES libmfx.lib PATHS "${root}/lib/${arch}" NO_DEFAULT_PATH)
-    endif()
-endif()
-
-if(NOT MFX_INCLUDE OR NOT MFX_LIBRARY)
-    return()
-endif()
-
-set(deps)
-
-if (UNIX)
-    find_library(MFX_VA_LIBRARY va)
-    find_library(MFX_VA_DRM_LIBRARY va-drm)
-    if (NOT MFX_VA_LIBRARY OR NOT MFX_VA_DRM_LIBRARY)
-        return()
-    endif()
-    add_library(mfx-va UNKNOWN IMPORTED)
-    set_target_properties(mfx-va PROPERTIES IMPORTED_LOCATION "${MFX_VA_LIBRARY}")
-    add_library(mfx-va-drm UNKNOWN IMPORTED)
-    set_target_properties(mfx-va-drm PROPERTIES IMPORTED_LOCATION "${MFX_VA_DRM_LIBRARY}")
-    list(APPEND deps mfx-va mfx-va-drm "-Wl,--exclude-libs=libmfx")
-endif()
-
-add_library(mfx UNKNOWN IMPORTED)
-set_target_properties(mfx PROPERTIES
-  IMPORTED_LOCATION "${MFX_LIBRARY}"
-  INTERFACE_INCLUDE_DIRECTORIES "${MFX_INCLUDE}"
-  INTERFACE_LINK_LIBRARIES "${deps}"
-)
-
-set(HAVE_MFX 1)

cmake/OpenCVDetectPython.cmake

@@ -186,7 +186,11 @@ if(NOT ${found})
         else() #debian based assumed, install to the dist-packages.
           set(_packages_path "python${_version_major_minor}/dist-packages")
         endif()
-        set(_packages_path "lib/${_packages_path}")
+        if(EXISTS "${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}/${${packages_path}}")
+          set(_packages_path "lib${LIB_SUFFIX}/${_packages_path}")
+        else()
+          set(_packages_path "lib/${_packages_path}")
+        endif()
       elseif(CMAKE_HOST_WIN32)
         get_filename_component(_path "${_executable}" PATH)
         file(TO_CMAKE_PATH "${_path}" _path)
@@ -245,7 +249,7 @@ if(NOT ${found})
 
   # Export return values
   set(${found} "${_found}" CACHE INTERNAL "")
-  set(${executable} "${_executable}" CACHE FILEPATH "Path to Python interpreter")
+  set(${executable} "${_executable}" CACHE FILEPATH "Path to Python interpretor")
   set(${version_string} "${_version_string}" CACHE INTERNAL "")
   set(${version_major} "${_version_major}" CACHE INTERNAL "")
   set(${version_minor} "${_version_minor}" CACHE INTERNAL "")

cmake/OpenCVDetectVTK.cmake

@@ -52,5 +52,18 @@ if(HAVE_QT AND VTK_VERSION VERSION_GREATER "6.0.0" AND NOT ${VTK_QT_VERSION} STR
   endif()
 endif()
 
+try_compile(VTK_COMPILE_STATUS
+    "${OpenCV_BINARY_DIR}"
+    "${OpenCV_SOURCE_DIR}/cmake/checks/vtk_test.cpp"
+    CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${VTK_INCLUDE_DIRS}"
+    LINK_LIBRARIES ${VTK_LIBRARIES}
+    OUTPUT_VARIABLE OUTPUT
+)
+
+if(NOT ${VTK_COMPILE_STATUS})
+  message(STATUS "VTK support is disabled. Compilation of the sample code has failed.")
+  return()
+endif()
+
 set(HAVE_VTK ON)
 message(STATUS "Found VTK ${VTK_VERSION} (${VTK_USE_FILE})")

cmake/OpenCVDetectVulkan.cmake

@@ -0,0 +1,20 @@
+set(VULKAN_INCLUDE_DIRS "${OpenCV_SOURCE_DIR}/3rdparty/include" CACHE PATH "Vulkan include directory")
+set(VULKAN_LIBRARIES "")
+
+try_compile(VALID_VULKAN
+      "${OpenCV_BINARY_DIR}"
+      "${OpenCV_SOURCE_DIR}/cmake/checks/vulkan.cpp"
+      CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${VULKAN_INCLUDE_DIRS}"
+      OUTPUT_VARIABLE TRY_OUT
+      )
+if(NOT ${VALID_VULKAN})
+  message(WARNING "Can't use Vulkan")
+  return()
+endif()
+
+set(HAVE_VULKAN 1)
+
+if(HAVE_VULKAN)
+  add_definitions(-DVK_NO_PROTOTYPES)
+  include_directories(${VULKAN_INCLUDE_DIRS})
+endif()

cmake/OpenCVDownload.cmake

@@ -22,9 +22,6 @@ set(OPENCV_DOWNLOAD_PATH "${OpenCV_SOURCE_DIR}/.cache" CACHE PATH "${HELP_OPENCV
 set(OPENCV_DOWNLOAD_LOG "${OpenCV_BINARY_DIR}/CMakeDownloadLog.txt")
 set(OPENCV_DOWNLOAD_WITH_CURL "${OpenCV_BINARY_DIR}/download_with_curl.sh")
 set(OPENCV_DOWNLOAD_WITH_WGET "${OpenCV_BINARY_DIR}/download_with_wget.sh")
-set(OPENCV_DOWNLOAD_TRIES_LIST 1 CACHE STRING "List of download tries") # a list
-set(OPENCV_DOWNLOAD_PARAMS INACTIVITY_TIMEOUT 60 TIMEOUT 600 CACHE STRING "Download parameters to be passed to file(DOWNLAOD ...)")
-mark_as_advanced(OPENCV_DOWNLOAD_TRIES_LIST OPENCV_DOWNLOAD_PARAMS)
 
 # Init download cache directory and log file and helper scripts
 if(NOT EXISTS "${OPENCV_DOWNLOAD_PATH}")
@@ -157,17 +154,11 @@ function(ocv_download)
   # Download
   if(NOT EXISTS "${CACHE_CANDIDATE}")
     ocv_download_log("#cmake_download \"${CACHE_CANDIDATE}\" \"${DL_URL}\"")
-    foreach(try ${OPENCV_DOWNLOAD_TRIES_LIST})
-      ocv_download_log("#try ${try}")
-      file(DOWNLOAD "${DL_URL}" "${CACHE_CANDIDATE}"
-           STATUS status
-           LOG __log
-           ${OPENCV_DOWNLOAD_PARAMS})
-      if(status EQUAL 0)
-        break()
-      endif()
-      message(STATUS "Try ${try} failed")
-    endforeach()
+    file(DOWNLOAD "${DL_URL}" "${CACHE_CANDIDATE}"
+         INACTIVITY_TIMEOUT 60
+         TIMEOUT 600
+         STATUS status
+         LOG __log)
     if(NOT OPENCV_SKIP_FILE_DOWNLOAD_DUMP)  # workaround problem with old CMake versions: "Invalid escape sequence"
       string(LENGTH "${__log}" __log_length)
       if(__log_length LESS 65536)
@@ -204,8 +195,8 @@ For details please refer to the download log file:
 ${OPENCV_DOWNLOAD_LOG}
 ")
       # write helper scripts for failed downloads
-      file(APPEND "${OPENCV_DOWNLOAD_WITH_CURL}" "curl --create-dirs --output \"${CACHE_CANDIDATE}\" \"${DL_URL}\"\n")
-      file(APPEND "${OPENCV_DOWNLOAD_WITH_WGET}" "mkdir -p $(dirname ${CACHE_CANDIDATE}) && wget -O \"${CACHE_CANDIDATE}\" \"${DL_URL}\"\n")
+      file(APPEND "${OPENCV_DOWNLOAD_WITH_CURL}" "curl --output \"${CACHE_CANDIDATE}\" \"${DL_URL}\"\n")
+      file(APPEND "${OPENCV_DOWNLOAD_WITH_WGET}" "wget -O \"${CACHE_CANDIDATE}\" \"${DL_URL}\"\n")
       return()
     endif()
 

cmake/OpenCVFindFrameworks.cmake

@@ -2,22 +2,22 @@
 #  Detect frameworks that may be used by 3rd-party libraries as well as OpenCV
 # ----------------------------------------------------------------------------
 
-# --- C= ---
-if(WITH_CSTRIPES AND NOT HAVE_TBB)
-  include("${OpenCV_SOURCE_DIR}/cmake/OpenCVDetectCStripes.cmake")
-else()
-  set(HAVE_CSTRIPES 0)
-endif()
+# --- HPX ---
+if(WITH_HPX)
+  find_package(HPX REQUIRED)
+  ocv_include_directories(${HPX_INCLUDE_DIRS})
+  set(HAVE_HPX TRUE)
+endif(WITH_HPX)
 
 # --- GCD ---
-if(APPLE AND NOT HAVE_TBB AND NOT HAVE_CSTRIPES)
+if(APPLE AND NOT HAVE_TBB)
   set(HAVE_GCD 1)
 else()
   set(HAVE_GCD 0)
 endif()
 
 # --- Concurrency ---
-if(MSVC AND NOT HAVE_TBB AND NOT HAVE_CSTRIPES)
+if(MSVC AND NOT HAVE_TBB)
   set(_fname "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/concurrencytest.cpp")
   file(WRITE "${_fname}" "#if _MSC_VER < 1600\n#error\n#endif\nint main() { return 0; }\n")
   try_compile(HAVE_CONCURRENCY "${CMAKE_BINARY_DIR}" "${_fname}")

cmake/OpenCVFindIPPIW.cmake

@@ -29,16 +29,6 @@ macro(ippiw_debugmsg MESSAGE)
     message(STATUS "${MESSAGE}")
   endif()
 endmacro()
-
-macro(ippiw_done)
-  foreach(__file ${IPP_IW_LICENSE_FILES})
-    if(EXISTS "${__file}")
-      ocv_install_3rdparty_licenses(ippiw "${__file}")
-    endif()
-  endforeach()
-  return()
-endmacro()
-
 file(TO_CMAKE_PATH "${IPPROOT}" IPPROOT)
 
 # This function detects Intel IPP Integration Wrappers version by analyzing .h file
@@ -91,7 +81,7 @@ macro(ippiw_setup PATH BUILD)
           if(EXISTS "${FILE}")
             set(HAVE_IPP_IW_LL 1)
           endif()
-          ippiw_done()
+          return()
         else()
           ippiw_debugmsg("sources\tno")
         endif()
@@ -130,7 +120,7 @@ macro(ippiw_setup PATH BUILD)
           if(EXISTS "${FILE}")
             set(HAVE_IPP_IW_LL 1)
           endif()
-          ippiw_done()
+          return()
         else()
           ippiw_debugmsg("binaries\tno")
         endif()
@@ -157,12 +147,14 @@ if(BUILD_IPP_IW)
   ippiw_setup("${OpenCV_SOURCE_DIR}/3rdparty/ippiw" 1)
 
   set(IPPIW_ROOT "${IPPROOT}/../iw")
-  set(IPP_IW_LICENSE_FILES ${IPP_IW_LICENSE_FILES_EXTRA}
-      "${IPPIW_ROOT}/../support.txt"
-      "${IPPIW_ROOT}/../third-party-programs.txt"
-      "${IPPIW_ROOT}/../EULA.rtf"
-      "${IPPIW_ROOT}/../EULA.txt"
-  )
+  ocv_install_3rdparty_licenses(ippiw
+    "${IPPIW_ROOT}/../support.txt"
+    "${IPPIW_ROOT}/../third-party-programs.txt")
+  if(WIN32)
+    ocv_install_3rdparty_licenses(ippiw "${IPPIW_ROOT}/../EULA.rtf")
+  else()
+    ocv_install_3rdparty_licenses(ippiw "${IPPIW_ROOT}/../EULA.txt")
+  endif()
 
   # Package sources
   get_filename_component(__PATH "${IPPROOT}/../iw/" ABSOLUTE)
@@ -175,11 +167,10 @@ if(BUILD_IPP_IW)
     include("${OpenCV_SOURCE_DIR}/3rdparty/ippicv/ippicv.cmake")
     download_ippicv(TEMP_ROOT)
     set(IPPIW_ROOT "${TEMP_ROOT}/iw/")
-    set(IPP_IW_LICENSE_FILES ${IPP_IW_LICENSE_FILES_EXTRA}
-        "${IPPIW_ROOT}/../EULA.txt"
-        "${IPPIW_ROOT}/../support.txt"
-        "${IPPIW_ROOT}/../third-party-programs.txt"
-    )
+    ocv_install_3rdparty_licenses(ippiw
+      "${IPPIW_ROOT}/../EULA.txt"
+      "${IPPIW_ROOT}/../support.txt"
+      "${IPPIW_ROOT}/../third-party-programs.txt")
 
     ippiw_setup("${IPPIW_ROOT}" 1)
   endif()

cmake/OpenCVFindIntelPerCSDK.cmake

@@ -1,20 +0,0 @@
-# Main variables:
-# INTELPERC_LIBRARIES and INTELPERC_INCLUDE to link Intel Perceptial Computing SDK modules
-# HAVE_INTELPERC for conditional compilation OpenCV with/without Intel Perceptial Computing SDK
-
-if(X86_64)
-    find_path(INTELPERC_INCLUDE_DIR "pxcsession.h" PATHS "$ENV{PCSDK_DIR}include" DOC "Path to Intel Perceptual Computing SDK interface headers")
-    find_file(INTELPERC_LIBRARIES "libpxc.lib" PATHS "$ENV{PCSDK_DIR}lib/x64" DOC "Path to Intel Perceptual Computing SDK interface libraries")
-else()
-    find_path(INTELPERC_INCLUDE_DIR "pxcsession.h" PATHS "$ENV{PCSDK_DIR}include" DOC "Path to Intel Perceptual Computing SDK interface headers")
-    find_file(INTELPERC_LIBRARIES "libpxc.lib" PATHS "$ENV{PCSDK_DIR}lib/Win32" DOC "Path to Intel Perceptual Computing SDK interface libraries")
-endif()
-
-if(INTELPERC_INCLUDE_DIR AND INTELPERC_LIBRARIES)
-    set(HAVE_INTELPERC TRUE)
-else()
-    set(HAVE_INTELPERC FALSE)
-    message(WARNING "Intel Perceptual Computing SDK library directory (set by INTELPERC_LIB_DIR variable) is not found or does not have Intel Perceptual Computing SDK libraries.")
-endif() #if(INTELPERC_INCLUDE_DIR AND INTELPERC_LIBRARIES)
-
-mark_as_advanced(FORCE INTELPERC_LIBRARIES INTELPERC_INCLUDE_DIR)

cmake/OpenCVFindLibsGUI.cmake

@@ -86,11 +86,9 @@ if(WITH_OPENGL)
   endif()
 endif(WITH_OPENGL)
 
-# --- Carbon & Cocoa ---
+# --- Cocoa ---
 if(APPLE)
-  if(WITH_CARBON)
-    set(HAVE_CARBON YES)
-  elseif(NOT IOS AND CV_CLANG)
+  if(NOT IOS AND CV_CLANG)
     set(HAVE_COCOA YES)
   endif()
 endif()

cmake/OpenCVFindLibsGrfmt.cmake

@@ -269,3 +269,8 @@ if(WITH_IMGCODEC_PXM)
 elseif(DEFINED WITH_IMGCODEC_PXM)
   set(HAVE_IMGCODEC_PXM OFF)
 endif()
+if(WITH_IMGCODEC_PFM)
+  set(HAVE_IMGCODEC_PFM ON)
+elseif(DEFINED WITH_IMGCODEC_PFM)
+  set(HAVE_IMGCODEC_PFM OFF)
+endif()

cmake/OpenCVFindLibsVideo.cmake

@@ -1,333 +1,8 @@
-# ----------------------------------------------------------------------------
-#  Detect 3rd-party video IO libraries
-# ----------------------------------------------------------------------------
-
-ocv_clear_vars(HAVE_VFW)
-if(WITH_VFW)
-  try_compile(HAVE_VFW
-    "${OpenCV_BINARY_DIR}"
-    "${OpenCV_SOURCE_DIR}/cmake/checks/vfwtest.cpp"
-    CMAKE_FLAGS "-DLINK_LIBRARIES:STRING=vfw32")
-endif(WITH_VFW)
-
-# --- GStreamer ---
-ocv_clear_vars(HAVE_GSTREAMER)
-# try to find gstreamer 1.x first if 0.10 was not requested
-if(WITH_GSTREAMER AND NOT WITH_GSTREAMER_0_10)
-  if(WIN32)
-    SET(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH};${CMAKE_CURRENT_LIST_DIR}")
-    FIND_PACKAGE(GstreamerWindows)
-    IF(GSTREAMER_gstbase_LIBRARY AND GSTREAMER_gstvideo_LIBRARY AND GSTREAMER_gstapp_LIBRARY AND GSTREAMER_gstpbutils_LIBRARY AND GSTREAMER_gstriff_LIBRARY)
-      set(HAVE_GSTREAMER TRUE)
-      set(GSTREAMER_BASE_VERSION 1.0)
-      set(GSTREAMER_VIDEO_VERSION 1.0)
-      set(GSTREAMER_APP_VERSION 1.0)
-      set(GSTREAMER_RIFF_VERSION 1.0)
-      set(GSTREAMER_PBUTILS_VERSION 1.0)
-    ENDIF(GSTREAMER_gstbase_LIBRARY AND GSTREAMER_gstvideo_LIBRARY AND GSTREAMER_gstapp_LIBRARY AND GSTREAMER_gstpbutils_LIBRARY AND GSTREAMER_gstriff_LIBRARY)
-
-  else(WIN32)
-    ocv_check_modules(GSTREAMER-1.0 gstreamer-base-1.0 gstreamer-video-1.0 gstreamer-app-1.0 gstreamer-riff-1.0 gstreamer-pbutils-1.0)
-    if(HAVE_GSTREAMER-1.0)
-      set(HAVE_GSTREAMER TRUE)
-      ocv_append_build_options(VIDEOIO GSTREAMER-1.0)
-      set(GSTREAMER_BASE_VERSION ${GSTREAMER-1.0_gstreamer-base-1.0_VERSION})
-      set(GSTREAMER_VIDEO_VERSION ${GSTREAMER-1.0_gstreamer-video-1.0_VERSION})
-      set(GSTREAMER_APP_VERSION ${GSTREAMER-1.0_gstreamer-app-1.0_VERSION})
-      set(GSTREAMER_RIFF_VERSION ${GSTREAMER-1.0_gstreamer-riff-1.0_VERSION})
-      set(GSTREAMER_PBUTILS_VERSION ${GSTREAMER-1.0_gstreamer-pbutils-1.0_VERSION})
-    endif()
-  endif(WIN32)
-endif()
-
-# if gstreamer 1.x was not found, or we specified we wanted 0.10, try to find it
-if(WITH_GSTREAMER AND NOT HAVE_GSTREAMER OR WITH_GSTREAMER_0_10)
-  ocv_check_modules(GSTREAMER-0.10 gstreamer-base-0.10 gstreamer-video-0.10 gstreamer-app-0.10 gstreamer-riff-0.10 gstreamer-pbutils-0.10)
-  if(HAVE_GSTREAMER-0.10)
-    set(HAVE_GSTREAMER TRUE)
-    ocv_append_build_options(VIDEOIO GSTREAMER-0.10)
-    set(GSTREAMER_BASE_VERSION ${GSTREAMER-0.10_gstreamer-base-0.10_VERSION})
-    set(GSTREAMER_VIDEO_VERSION ${GSTREAMER-0.10_gstreamer-video-0.10_VERSION})
-    set(GSTREAMER_APP_VERSION ${GSTREAMER-0.10_gstreamer-app-0.10_VERSION})
-    set(GSTREAMER_RIFF_VERSION ${GSTREAMER-0.10_gstreamer-riff-0.10_VERSION})
-    set(GSTREAMER_PBUTILS_VERSION ${GSTREAMER-0.10_gstreamer-pbutils-0.10_VERSION})
-  endif()
-endif()
-
-# --- unicap ---
-ocv_clear_vars(HAVE_UNICAP)
-if(WITH_UNICAP)
-  ocv_check_modules(HAVE_UNICAP libunicap libucil)
-  if(HAVE_UNICAP)
-    ocv_append_build_options(VIDEOIO UNICAP)
-  endif()
-endif()
-
-# --- PvApi ---
-ocv_clear_vars(HAVE_PVAPI)
-if(WITH_PVAPI)
-  find_path(PVAPI_INCLUDE_PATH "PvApi.h"
-            PATHS /usr/local /opt /usr ENV ProgramFiles ENV ProgramW6432
-            PATH_SUFFIXES include "Allied Vision Technologies/GigESDK/inc-pc" "AVT GigE SDK/inc-pc" "GigESDK/inc-pc"
-            DOC "The path to PvAPI header")
-
-  if(PVAPI_INCLUDE_PATH)
-    if(X86 AND NOT WIN32)
-      set(PVAPI_SDK_SUBDIR x86)
-    elseif(X86_64)
-      set(PVAPI_SDK_SUBDIR x64)
-    elseif(ARM)
-      set(PVAPI_SDK_SUBDIR arm)
-    endif()
-
-    get_filename_component(_PVAPI_LIBRARY_HINT "${PVAPI_INCLUDE_PATH}/../lib-pc" ABSOLUTE)
-
-    find_library(PVAPI_LIBRARY NAMES "PvAPI" PATHS "${_PVAPI_LIBRARY_HINT}")
-
-    if(PVAPI_LIBRARY)
-      if(WIN32)
-        if(MINGW)
-          set(PVAPI_DEFINITIONS "-DPVDECL=__stdcall")
-        endif(MINGW)
-      endif()
-      set(HAVE_PVAPI TRUE)
-    endif()
-  endif(PVAPI_INCLUDE_PATH)
-endif(WITH_PVAPI)
-
-# --- GigEVisionSDK ---
-ocv_clear_vars(HAVE_GIGE_API)
-if(WITH_GIGEAPI)
-  find_path(GIGEAPI_INCLUDE_PATH "GigEVisionSDK.h"
-            PATHS /usr/local /var /opt /usr ENV ProgramFiles ENV ProgramW6432
-            PATH_SUFFIXES include "Smartek Vision Technologies/GigEVisionSDK/gige_cpp" "GigEVisionSDK/gige_cpp" "GigEVisionSDK/gige_c"
-            DOC "The path to Smartek GigEVisionSDK header")
-  FIND_LIBRARY(GIGEAPI_LIBRARIES NAMES GigEVisionSDK)
-  if(GIGEAPI_LIBRARIES AND GIGEAPI_INCLUDE_PATH)
-    set(HAVE_GIGE_API TRUE)
-  endif()
-endif(WITH_GIGEAPI)
-
-# --- Aravis SDK ---
-ocv_clear_vars(HAVE_ARAVIS_API)
-if(WITH_ARAVIS)
-  ocv_check_modules(ARAVIS_GLIB glib-2.0)
-  if(HAVE_ARAVIS_GLIB)
-    find_path(ARAVIS_INCLUDE_PATH "arv.h"
-              PATHS /usr/local /var /opt /usr ENV ProgramFiles ENV ProgramW6432
-              PATH_SUFFIXES include "aravis-0.6" "aravis-0.4"
-              DOC "The path to Aravis SDK headers")
-    find_library(ARAVIS_LIBRARIES NAMES "aravis-0.6" "aravis-0.4" )
-    if(ARAVIS_LIBRARIES AND ARAVIS_INCLUDE_PATH)
-      ocv_append_build_options(VIDEOIO ARAVIS_GLIB)
-      set(HAVE_ARAVIS_API TRUE)
-    endif()
-  else()
-    message("Can not build Aravis support without glib2")
-  endif()
-endif(WITH_ARAVIS)
-
-# --- Dc1394 ---
-ocv_clear_vars(HAVE_DC1394 HAVE_DC1394_2)
-if(WITH_1394)
-  if(WIN32 AND MINGW)
-      # TODO remove this, use pkgconfig from MinGW instead
-      find_path(CMU1394_INCLUDE_PATH "/1394common.h"
-                PATH_SUFFIXES include
-                DOC "The path to cmu1394 headers")
-      find_path(DC1394_2_INCLUDE_PATH "/dc1394/dc1394.h"
-                PATH_SUFFIXES include
-                DOC "The path to DC1394 2.x headers")
-      if(CMU1394_INCLUDE_PATH AND DC1394_2_INCLUDE_PATH)
-        set(CMU1394_LIB_DIR  "${CMU1394_INCLUDE_PATH}/../lib"  CACHE PATH "Full path of CMU1394 library directory")
-        set(DC1394_2_LIB_DIR "${DC1394_2_INCLUDE_PATH}/../lib" CACHE PATH "Full path of DC1394 2.x library directory")
-        if(EXISTS "${CMU1394_LIB_DIR}/lib1394camera.a" AND EXISTS "${DC1394_2_LIB_DIR}/libdc1394.a")
-          set(HAVE_DC1394_2 TRUE)
-        endif()
-      endif()
-      if(HAVE_DC1394_2)
-        ocv_parse_pkg(DC1394_2_VERSION "libdc1394-2" "${DC1394_2_LIB_DIR}/pkgconfig")
-        ocv_include_directories(${DC1394_2_INCLUDE_PATH})
-        set(VIDEOIO_LIBRARIES ${VIDEOIO_LIBRARIES}
-            "${DC1394_2_LIB_DIR}/libdc1394.a"
-            "${CMU1394_LIB_DIR}/lib1394camera.a")
-      endif()
-  endif()
-  if(NOT HAVE_DC1394_2)
-    ocv_check_modules(DC1394_2 libdc1394-2)
-    if(HAVE_DC1394_2)
-      ocv_append_build_options(VIDEOIO DC1394_2)
-    else()
-      ocv_check_modules(DC1394 libdc1394)
-      if(HAVE_DC1394)
-        ocv_append_build_options(VIDEOIO DC1394)
-      endif()
-    endif()
-  endif()
-endif()
-
-# --- xine ---
-ocv_clear_vars(HAVE_XINE)
-if(WITH_XINE)
-  ocv_check_modules(XINE libxine)
-  if(HAVE_XINE)
-    ocv_append_build_options(VIDEOIO XINE)
-  endif()
-endif(WITH_XINE)
-
-# --- V4L ---
-ocv_clear_vars(HAVE_LIBV4L HAVE_CAMV4L HAVE_CAMV4L2 HAVE_VIDEOIO)
-if(WITH_V4L)
-  if(WITH_LIBV4L)
-    ocv_check_modules(LIBV4L libv4l1 libv4l2)
-    if(HAVE_LIBV4L)
-      ocv_append_build_options(VIDEOIO LIBV4L)
-    endif()
-  endif()
-  CHECK_INCLUDE_FILE(linux/videodev.h HAVE_CAMV4L)
-  CHECK_INCLUDE_FILE(linux/videodev2.h HAVE_CAMV4L2)
-  CHECK_INCLUDE_FILE(sys/videoio.h HAVE_VIDEOIO)
-endif(WITH_V4L)
-
-# --- OpenNI ---
-ocv_clear_vars(HAVE_OPENNI HAVE_OPENNI_PRIME_SENSOR_MODULE)
-if(WITH_OPENNI)
-  include("${OpenCV_SOURCE_DIR}/cmake/OpenCVFindOpenNI.cmake")
-endif(WITH_OPENNI)
-
-ocv_clear_vars(HAVE_OPENNI2)
-if(WITH_OPENNI2)
-  include("${OpenCV_SOURCE_DIR}/cmake/OpenCVFindOpenNI2.cmake")
-endif(WITH_OPENNI2)
-
-# --- XIMEA ---
-ocv_clear_vars(HAVE_XIMEA)
-if(WITH_XIMEA)
-  include("${OpenCV_SOURCE_DIR}/cmake/OpenCVFindXimea.cmake")
-  if(XIMEA_FOUND)
-    set(HAVE_XIMEA TRUE)
-  endif()
-endif(WITH_XIMEA)
-
-# --- FFMPEG ---
-ocv_clear_vars(HAVE_FFMPEG)
-if(WITH_FFMPEG)  # try FFmpeg autodetection
-  if(OPENCV_FFMPEG_USE_FIND_PACKAGE)
-    if(OPENCV_FFMPEG_USE_FIND_PACKAGE STREQUAL "1" OR OPENCV_FFMPEG_USE_FIND_PACKAGE STREQUAL "ON")
-      set(OPENCV_FFMPEG_USE_FIND_PACKAGE "FFMPEG")
-    endif()
-    find_package(${OPENCV_FFMPEG_USE_FIND_PACKAGE}) # Required components: AVCODEC AVFORMAT AVUTIL SWSCALE
-    if(FFMPEG_FOUND OR FFmpeg_FOUND)
-      set(HAVE_FFMPEG TRUE)
-    else()
-      message(STATUS "Can't find FFmpeg via find_package(${OPENCV_FFMPEG_USE_FIND_PACKAGE})")
-    endif()
-  elseif(WIN32 AND NOT ARM AND NOT OPENCV_FFMPEG_SKIP_DOWNLOAD)
-    include("${OpenCV_SOURCE_DIR}/3rdparty/ffmpeg/ffmpeg.cmake")
-    download_win_ffmpeg(FFMPEG_CMAKE_SCRIPT)
-    if(FFMPEG_CMAKE_SCRIPT)
-      set(HAVE_FFMPEG TRUE)
-      set(HAVE_FFMPEG_WRAPPER 1)
-      include("${FFMPEG_CMAKE_SCRIPT}")
-    endif()
-  elseif(PKG_CONFIG_FOUND)
-    ocv_check_modules(FFMPEG libavcodec libavformat libavutil libswscale)
-    ocv_check_modules(FFMPEG_libavresample libavresample)
-    if(FFMPEG_libavresample_FOUND)
-      ocv_append_build_options(FFMPEG FFMPEG_libavresample)
-    endif()
-  else()
-    message(STATUS "Can't find ffmpeg - 'pkg-config' utility is missing")
-  endif()
-endif()
-if(HAVE_FFMPEG
-    AND NOT HAVE_FFMPEG_WRAPPER
-)
-  try_compile(__VALID_FFMPEG
-      "${OpenCV_BINARY_DIR}"
-      "${OpenCV_SOURCE_DIR}/cmake/checks/ffmpeg_test.cpp"
-      CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${FFMPEG_INCLUDE_DIRS}"
-                  "-DLINK_DIRECTORIES:STRING=${FFMPEG_LIBRARY_DIRS}"
-                  "-DLINK_LIBRARIES:STRING=${FFMPEG_LIBRARIES}"
-      OUTPUT_VARIABLE TRY_OUT
-  )
-  if(NOT __VALID_FFMPEG)
-    #message(FATAL_ERROR "FFMPEG: test check build log:\n${TRY_OUT}")
-    message(STATUS "WARNING: Can't build ffmpeg test code")
-    set(HAVE_FFMPEG FALSE)
-  else()
-    ocv_append_build_options(VIDEOIO FFMPEG)
-  endif()
-endif()
-
-# --- VideoInput/DirectShow ---
-if(WITH_DSHOW)
-  if(MSVC_VERSION GREATER 1499)
-    set(HAVE_DSHOW 1)
-  elseif(NOT HAVE_DSHOW)
-    check_include_file(DShow.h HAVE_DSHOW)
-  endif()
-endif(WITH_DSHOW)
-
-# --- VideoInput/Microsoft Media Foundation ---
-ocv_clear_vars(HAVE_MSMF)
-if(WITH_MSMF)
-  check_include_file(Mfapi.h HAVE_MSMF)
-  set(HAVE_MSMF_DXVA "")
-  if(WITH_MSMF_DXVA)
-    check_include_file(D3D11.h D3D11_found)
-    check_include_file(D3d11_4.h D3D11_4_found)
-    if(D3D11_found AND D3D11_4_found)
-      set(HAVE_MSMF_DXVA YES)
-    endif()
-  endif()
-endif()
-
 # --- Extra HighGUI and VideoIO libs on Windows ---
 if(WIN32)
   list(APPEND HIGHGUI_LIBRARIES comctl32 gdi32 ole32 setupapi ws2_32)
-  if(HAVE_VFW)
-    list(APPEND VIDEOIO_LIBRARIES vfw32)
-  endif()
-  if(MINGW64)
-    list(APPEND VIDEOIO_LIBRARIES avifil32 avicap32 winmm msvfw32)
-    list(REMOVE_ITEM VIDEOIO_LIBRARIES vfw32)
-  elseif(MINGW)
-    list(APPEND VIDEOIO_LIBRARIES winmm)
-  endif()
 endif(WIN32)
 
-if(APPLE)
-  if(WITH_AVFOUNDATION)
-    set(HAVE_AVFOUNDATION YES)
-  endif()
-  if(NOT IOS)
-    if(WITH_QUICKTIME)
-      set(HAVE_QUICKTIME YES)
-    elseif(WITH_QTKIT)
-      set(HAVE_QTKIT YES)
-    endif()
-  endif()
-endif(APPLE)
-
-# --- Intel Perceptual Computing SDK ---
-if(WITH_INTELPERC)
-  include("${OpenCV_SOURCE_DIR}/cmake/OpenCVFindIntelPerCSDK.cmake")
-endif(WITH_INTELPERC)
-
-if(WITH_MFX)
-  include("${OpenCV_SOURCE_DIR}/cmake/OpenCVDetectMediaSDK.cmake")
-endif()
-
-# --- gPhoto2 ---
-ocv_clear_vars(HAVE_GPHOTO2)
-if(WITH_GPHOTO2)
-  ocv_check_modules(GPHOTO2 libgphoto2)
-  if(HAVE_GPHOTO2)
-    ocv_append_build_options(VIDEOIO GPHOTO2)
-  endif()
-endif()
-
 # --- VA & VA_INTEL ---
 if(WITH_VA_INTEL)
   include("${OpenCV_SOURCE_DIR}/cmake/OpenCVFindVA_INTEL.cmake")

cmake/OpenCVFindOpenNI.cmake

@@ -1,89 +0,0 @@
-# Main variables:
-# OPENNI_LIBRARY and OPENNI_INCLUDES to link OpenCV modules with OpenNI
-# HAVE_OPENNI for conditional compilation OpenCV with/without OpenNI
-
-if(NOT "${OPENNI_LIB_DIR}" STREQUAL "${OPENNI_LIB_DIR_INTERNAL}")
-    unset(OPENNI_LIBRARY CACHE)
-    unset(OPENNI_LIB_DIR CACHE)
-endif()
-
-if(NOT "${OPENNI_INCLUDE_DIR}" STREQUAL "${OPENNI_INCLUDE_DIR_INTERNAL}")
-    unset(OPENNI_INCLUDES CACHE)
-    unset(OPENNI_INCLUDE_DIR CACHE)
-endif()
-
-if(NOT "${OPENNI_PRIME_SENSOR_MODULE_BIN_DIR}" STREQUAL "${OPENNI_PRIME_SENSOR_MODULE_BIN_DIR_INTERNAL}")
-    unset(OPENNI_PRIME_SENSOR_MODULE CACHE)
-    unset(OPENNI_PRIME_SENSOR_MODULE_BIN_DIR CACHE)
-endif()
-
-if(WIN32)
-    if(NOT (MSVC64 OR MINGW64))
-        find_file(OPENNI_INCLUDES "XnCppWrapper.h" PATHS "$ENV{OPEN_NI_INSTALL_PATH}Include" DOC "OpenNI c++ interface header")
-        find_library(OPENNI_LIBRARY "OpenNI" PATHS $ENV{OPEN_NI_LIB} DOC "OpenNI library")
-    else()
-        find_file(OPENNI_INCLUDES "XnCppWrapper.h" PATHS "$ENV{OPEN_NI_INSTALL_PATH64}Include" DOC "OpenNI c++ interface header")
-        find_library(OPENNI_LIBRARY "OpenNI64" PATHS $ENV{OPEN_NI_LIB64} DOC "OpenNI library")
-    endif()
-elseif(UNIX OR APPLE)
-    find_file(OPENNI_INCLUDES "XnCppWrapper.h" PATHS "/usr/include/ni" "/usr/include/openni" DOC "OpenNI c++ interface header")
-    find_library(OPENNI_LIBRARY "OpenNI" PATHS "/usr/lib" DOC "OpenNI library")
-endif()
-
-if(OPENNI_LIBRARY AND OPENNI_INCLUDES)
-    set(HAVE_OPENNI TRUE)
-    # the check: are PrimeSensor Modules for OpenNI installed
-    if(WIN32)
-    if(NOT (MSVC64 OR MINGW64))
-            find_file(OPENNI_PRIME_SENSOR_MODULE "XnCore.dll" PATHS "$ENV{OPEN_NI_INSTALL_PATH}../PrimeSense/Sensor/Bin" "$ENV{OPEN_NI_INSTALL_PATH}../PrimeSense/SensorKinect/Bin" DOC "Core library of PrimeSensor Modules for OpenNI")
-        else()
-            find_file(OPENNI_PRIME_SENSOR_MODULE "XnCore64.dll" PATHS "$ENV{OPEN_NI_INSTALL_PATH64}../PrimeSense/Sensor/Bin64" "$ENV{OPEN_NI_INSTALL_PATH64}../PrimeSense/SensorKinect/Bin64" DOC "Core library of PrimeSensor Modules for OpenNI")
-        endif()
-    elseif(UNIX OR APPLE)
-        find_library(OPENNI_PRIME_SENSOR_MODULE "XnCore" PATHS "/usr/lib" DOC "Core library of PrimeSensor Modules for OpenNI")
-    endif()
-
-    if(OPENNI_PRIME_SENSOR_MODULE)
-        set(HAVE_OPENNI_PRIME_SENSOR_MODULE TRUE)
-    endif()
-endif() #if(OPENNI_LIBRARY AND OPENNI_INCLUDES)
-
-get_filename_component(OPENNI_LIB_DIR "${OPENNI_LIBRARY}" PATH)
-get_filename_component(OPENNI_INCLUDE_DIR ${OPENNI_INCLUDES} PATH)
-get_filename_component(OPENNI_PRIME_SENSOR_MODULE_BIN_DIR "${OPENNI_PRIME_SENSOR_MODULE}" PATH)
-
-if(HAVE_OPENNI)
-  set(OPENNI_LIB_DIR "${OPENNI_LIB_DIR}" CACHE PATH "Path to OpenNI libraries" FORCE)
-  set(OPENNI_INCLUDE_DIR "${OPENNI_INCLUDE_DIR}" CACHE PATH "Path to OpenNI headers" FORCE)
-  set(OPENNI_PRIME_SENSOR_MODULE_BIN_DIR "${OPENNI_PRIME_SENSOR_MODULE_BIN_DIR}" CACHE PATH "Path to OpenNI PrimeSensor Module binaries" FORCE)
-endif()
-
-if(OPENNI_LIBRARY)
-    set(OPENNI_LIB_DIR_INTERNAL "${OPENNI_LIB_DIR}" CACHE INTERNAL "This is the value of the last time OPENNI_LIB_DIR was set successfully." FORCE)
-else()
-    message( WARNING, " OpenNI library directory (set by OPENNI_LIB_DIR variable) is not found or does not have OpenNI libraries." )
-endif()
-
-if(OPENNI_INCLUDES)
-    set(OPENNI_INCLUDE_DIR_INTERNAL "${OPENNI_INCLUDE_DIR}" CACHE INTERNAL "This is the value of the last time OPENNI_INCLUDE_DIR was set successfully." FORCE)
-else()
-    message( WARNING, " OpenNI include directory (set by OPENNI_INCLUDE_DIR variable) is not found or does not have OpenNI include files." )
-endif()
-
-if(OPENNI_PRIME_SENSOR_MODULE)
-    set(OPENNI_PRIME_SENSOR_MODULE_BIN_DIR_INTERNAL "${OPENNI_PRIME_SENSOR_MODULE_BIN_DIR}" CACHE INTERNAL "This is the value of the last time OPENNI_PRIME_SENSOR_MODULE_BIN_DIR was set successfully." FORCE)
-else()
-    message( WARNING, " PrimeSensor Module binaries directory (set by OPENNI_PRIME_SENSOR_MODULE_BIN_DIR variable) is not found or does not have PrimeSensor Module binaries." )
-endif()
-
-mark_as_advanced(FORCE OPENNI_PRIME_SENSOR_MODULE)
-mark_as_advanced(FORCE OPENNI_LIBRARY)
-mark_as_advanced(FORCE OPENNI_INCLUDES)
-
-if(HAVE_OPENNI)
-  ocv_parse_header("${OPENNI_INCLUDE_DIR}/XnVersion.h" OPENNI_VERSION_LINES XN_MAJOR_VERSION XN_MINOR_VERSION XN_MAINTENANCE_VERSION XN_BUILD_VERSION)
-  if(XN_MAJOR_VERSION)
-    set(OPENNI_VERSION_STRING ${XN_MAJOR_VERSION}.${XN_MINOR_VERSION}.${XN_MAINTENANCE_VERSION} CACHE INTERNAL "OpenNI version")
-    set(OPENNI_VERSION_BUILD ${XN_BUILD_VERSION} CACHE INTERNAL "OpenNI build version")
-  endif()
-endif()

cmake/OpenCVFindOpenNI2.cmake

@@ -1,61 +0,0 @@
-# Main variables:
-# OPENNI2_LIBRARY and OPENNI2_INCLUDES to link OpenCV modules with OpenNI2
-# HAVE_OPENNI2 for conditional compilation OpenCV with/without OpenNI2
-
-if(NOT "${OPENNI2_LIB_DIR}" STREQUAL "${OPENNI2_LIB_DIR_INTERNAL}")
-    unset(OPENNI2_LIBRARY CACHE)
-    unset(OPENNI2_LIB_DIR CACHE)
-endif()
-
-if(NOT "${OPENNI2_INCLUDE_DIR}" STREQUAL "${OPENNI2_INCLUDE_DIR_INTERNAL}")
-    unset(OPENNI2_INCLUDES CACHE)
-    unset(OPENNI2_INCLUDE_DIR CACHE)
-endif()
-
-if(WIN32)
-    if(NOT (MSVC64 OR MINGW64))
-        find_file(OPENNI2_INCLUDES "OpenNI.h" PATHS $ENV{OPENNI2_INCLUDE} "$ENV{OPEN_NI_INSTALL_PATH}Include" DOC "OpenNI2 c++ interface header")
-        find_library(OPENNI2_LIBRARY "OpenNI2" PATHS $ENV{OPENNI2_LIB} DOC "OpenNI2 library")
-    else()
-        find_file(OPENNI2_INCLUDES "OpenNI.h" PATHS $ENV{OPENNI2_INCLUDE64} "$ENV{OPEN_NI_INSTALL_PATH64}Include" DOC "OpenNI2 c++ interface header")
-        find_library(OPENNI2_LIBRARY "OpenNI2" PATHS $ENV{OPENNI2_LIB64} DOC "OpenNI2 library")
-    endif()
-elseif(UNIX OR APPLE)
-    find_file(OPENNI2_INCLUDES "OpenNI.h" PATHS "/usr/include/ni2" "/usr/include/openni2" $ENV{OPENNI2_INCLUDE} DOC "OpenNI2 c++ interface header")
-    find_library(OPENNI2_LIBRARY "OpenNI2" PATHS "/usr/lib" $ENV{OPENNI2_REDIST} DOC "OpenNI2 library")
-endif()
-
-if(OPENNI2_LIBRARY AND OPENNI2_INCLUDES)
-    set(HAVE_OPENNI2 TRUE)
-endif() #if(OPENNI2_LIBRARY AND OPENNI2_INCLUDES)
-
-get_filename_component(OPENNI2_LIB_DIR "${OPENNI2_LIBRARY}" PATH)
-get_filename_component(OPENNI2_INCLUDE_DIR ${OPENNI2_INCLUDES} PATH)
-
-if(HAVE_OPENNI2)
-  set(OPENNI2_LIB_DIR "${OPENNI2_LIB_DIR}" CACHE PATH "Path to OpenNI2 libraries" FORCE)
-  set(OPENNI2_INCLUDE_DIR "${OPENNI2_INCLUDE_DIR}" CACHE PATH "Path to OpenNI2 headers" FORCE)
-endif()
-
-if(OPENNI2_LIBRARY)
-    set(OPENNI2_LIB_DIR_INTERNAL "${OPENNI2_LIB_DIR}" CACHE INTERNAL "This is the value of the last time OPENNI_LIB_DIR was set successfully." FORCE)
-else()
-    message( WARNING, " OpenNI2 library directory (set by OPENNI2_LIB_DIR variable) is not found or does not have OpenNI2 libraries." )
-endif()
-
-if(OPENNI2_INCLUDES)
-    set(OPENNI2_INCLUDE_DIR_INTERNAL "${OPENNI2_INCLUDE_DIR}" CACHE INTERNAL "This is the value of the last time OPENNI2_INCLUDE_DIR was set successfully." FORCE)
-else()
-    message( WARNING, " OpenNI2 include directory (set by OPENNI2_INCLUDE_DIR variable) is not found or does not have OpenNI2 include files." )
-endif()
-
-mark_as_advanced(FORCE OPENNI2_LIBRARY)
-mark_as_advanced(FORCE OPENNI2_INCLUDES)
-
-if(HAVE_OPENNI2)
-  ocv_parse_header("${OPENNI2_INCLUDE_DIR}/OniVersion.h" ONI_VERSION_LINE ONI_VERSION_MAJOR ONI_VERSION_MINOR ONI_VERSION_MAINTENANCE ONI_VERSION_BUILD)
-  if(ONI_VERSION_MAJOR)
-    set(OPENNI2_VERSION_STRING ${ONI_VERSION_MAJOR}.${ONI_VERSION_MINOR}.${ONI_VERSION_MAINTENANCE} CACHE INTERNAL "OpenNI2 version")
-    set(OPENNI2_VERSION_BUILD ${ONI_VERSION_BUILD} CACHE INTERNAL "OpenNI2 build version")
-  endif()
-endif()

cmake/OpenCVFindXimea.cmake

@@ -1,52 +0,0 @@
-# - Find XIMEA
-# This module finds if XIMEA Software package is installed
-# and determines where the binaries and header files are.
-# This code sets the following variables:
-#
-#  XIMEA_FOUND          - True if XIMEA API found
-#  XIMEA_PATH:          - Path to the XIMEA API folder
-#  XIMEA_LIBRARY_DIR    - XIMEA libraries folder
-#
-# Created: 5 Aug 2011 by Marian Zajko (marian.zajko@ximea.com)
-# Updated: 25 June 2012 by Igor Kuzmin (parafin@ximea.com)
-# Updated: 22 October 2012 by Marian Zajko (marian.zajko@ximea.com)
-#
-
-set(XIMEA_FOUND)
-set(XIMEA_PATH)
-set(XIMEA_LIBRARY_DIR)
-
-if(WIN32)
-  # Try to find the XIMEA API path in registry.
-  GET_FILENAME_COMPONENT(XIMEA_PATH "[HKEY_CURRENT_USER\\Software\\XIMEA\\CamSupport\\API;Path]" ABSOLUTE)
-
-  if(EXISTS ${XIMEA_PATH})
-    set(XIMEA_FOUND 1)
-    # set LIB folders
-    if(X86_64)
-      set(XIMEA_LIBRARY_DIR "${XIMEA_PATH}/x64")
-    else()
-      set(XIMEA_LIBRARY_DIR "${XIMEA_PATH}/x86")
-    endif()
-  else()
-    set(XIMEA_FOUND 0)
-  endif()
-elseif(APPLE)
-  if(EXISTS /Library/Frameworks/m3api.framework)
-    set(XIMEA_FOUND 1)
-  else()
-    set(XIMEA_FOUND 0)
-  endif()
-else()
-  if(EXISTS /opt/XIMEA)
-    set(XIMEA_FOUND 1)
-    # set folders
-    set(XIMEA_PATH /opt/XIMEA/include)
-  else()
-    set(XIMEA_FOUND 0)
-  endif()
-endif()
-
-mark_as_advanced(FORCE XIMEA_FOUND)
-mark_as_advanced(FORCE XIMEA_PATH)
-mark_as_advanced(FORCE XIMEA_LIBRARY_DIR)

cmake/OpenCVGenABI.cmake

@@ -22,8 +22,6 @@ set(OPENCV_ABI_HEADERS "{RELPATH}/${OPENCV_INCLUDE_INSTALL_PATH}")
 # Libraries
 set(OPENCV_ABI_LIBRARIES "{RELPATH}/${OPENCV_LIB_INSTALL_PATH}")
 
-set(OPENCV_ABI_SKIP_HEADERS "")
-set(OPENCV_ABI_SKIP_LIBRARIES "")
 foreach(mod ${OPENCV_MODULES_BUILD})
   string(REGEX REPLACE "^opencv_" "" mod "${mod}")
   if(NOT OPENCV_MODULE_opencv_${mod}_CLASS STREQUAL "PUBLIC"
@@ -44,7 +42,7 @@ string(REPLACE ";" "\n    " OPENCV_ABI_SKIP_HEADERS "${OPENCV_ABI_SKIP_HEADERS}"
 string(REPLACE ";" "\n    " OPENCV_ABI_SKIP_LIBRARIES "${OPENCV_ABI_SKIP_LIBRARIES}")
 
 # Options
-set(OPENCV_ABI_GCC_OPTIONS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE} -DOPENCV_ABI_CHECK=1")
+set(OPENCV_ABI_GCC_OPTIONS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE} -DOPENCV_ABI_CHECK=1 -DCV_DNN_DONT_ADD_INLINE_NS=1")
 string(REGEX REPLACE "([^ ]) +([^ ])" "\\1\\n    \\2" OPENCV_ABI_GCC_OPTIONS "${OPENCV_ABI_GCC_OPTIONS}")
 
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/templates/opencv_abi.xml.in" "${path1}.base")

cmake/OpenCVGenAndroidMK.cmake

@@ -48,7 +48,7 @@ if(ANDROID)
   string(REPLACE "opencv_" "" OPENCV_MODULES_CONFIGMAKE "${OPENCV_MODULES_CONFIGMAKE}")
 
   if(BUILD_FAT_JAVA_LIB)
-    set(OPENCV_LIBS_CONFIGMAKE java3)
+    set(OPENCV_LIBS_CONFIGMAKE java4)
   else()
     set(OPENCV_LIBS_CONFIGMAKE "${OPENCV_MODULES_CONFIGMAKE}")
   endif()

cmake/OpenCVGenConfig.cmake

@@ -33,7 +33,7 @@ endif()
 # -------------------------------------------------------------------------------------------
 #  Part 1/3: ${BIN_DIR}/OpenCVConfig.cmake              -> For use *without* "make install"
 # -------------------------------------------------------------------------------------------
-set(OpenCV_INCLUDE_DIRS_CONFIGCMAKE "\"${OPENCV_CONFIG_FILE_INCLUDE_DIR}\" \"${OpenCV_SOURCE_DIR}/include\" \"${OpenCV_SOURCE_DIR}/include/opencv\"")
+set(OpenCV_INCLUDE_DIRS_CONFIGCMAKE "\"${OPENCV_CONFIG_FILE_INCLUDE_DIR}\" \"${OpenCV_SOURCE_DIR}/include\"")
 
 foreach(m ${OPENCV_MODULES_BUILD})
   if(EXISTS "${OPENCV_MODULE_${m}_LOCATION}/include")
@@ -41,7 +41,7 @@ foreach(m ${OPENCV_MODULES_BUILD})
   endif()
 endforeach()
 
-export(TARGETS ${OpenCVModules_TARGETS} FILE "${CMAKE_BINARY_DIR}/OpenCVModules.cmake")
+export(EXPORT OpenCVModules FILE "${CMAKE_BINARY_DIR}/OpenCVModules.cmake")
 
 if(TARGET ippicv AND NOT BUILD_SHARED_LIBS)
   set(USE_IPPICV TRUE)
@@ -69,9 +69,9 @@ configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/OpenCVConfig-version.cmake.
 # -------------------------------------------------------------------------------------------
 file(RELATIVE_PATH OpenCV_INSTALL_PATH_RELATIVE_CONFIGCMAKE "${CMAKE_INSTALL_PREFIX}/${OPENCV_CONFIG_INSTALL_PATH}/" ${CMAKE_INSTALL_PREFIX})
 if (IS_ABSOLUTE ${OPENCV_INCLUDE_INSTALL_PATH})
-  set(OpenCV_INCLUDE_DIRS_CONFIGCMAKE "\"${OPENCV_INCLUDE_INSTALL_PATH}\" \"${OPENCV_INCLUDE_INSTALL_PATH}/opencv\"")
+  set(OpenCV_INCLUDE_DIRS_CONFIGCMAKE "\"${OPENCV_INCLUDE_INSTALL_PATH}\"")
 else()
-  set(OpenCV_INCLUDE_DIRS_CONFIGCMAKE "\"\${OpenCV_INSTALL_PATH}/${OPENCV_INCLUDE_INSTALL_PATH}\" \"\${OpenCV_INSTALL_PATH}/${OPENCV_INCLUDE_INSTALL_PATH}/opencv\"")
+  set(OpenCV_INCLUDE_DIRS_CONFIGCMAKE "\"\${OpenCV_INSTALL_PATH}/${OPENCV_INCLUDE_INSTALL_PATH}\"")
 endif()
 
 if(USE_IPPICV)
@@ -122,10 +122,13 @@ endif()
 #  Part 3/3: ${BIN_DIR}/win-install/OpenCVConfig.cmake  -> For use within binary installers/packages
 # --------------------------------------------------------------------------------------------
 if(WIN32)
-  if(CMAKE_HOST_SYSTEM_NAME MATCHES Windows AND NOT OPENCV_SKIP_CMAKE_ROOT_CONFIG)
-    ocv_gen_config("${CMAKE_BINARY_DIR}/win-install"
-                   "${OPENCV_INSTALL_BINARIES_PREFIX}${OPENCV_INSTALL_BINARIES_SUFFIX}"
-                   "OpenCVConfig.root-WIN32.cmake.in")
+  if(CMAKE_HOST_SYSTEM_NAME MATCHES Windows)
+    if(BUILD_SHARED_LIBS)
+      set(_lib_suffix "lib")
+    else()
+      set(_lib_suffix "staticlib")
+    endif()
+    ocv_gen_config("${CMAKE_BINARY_DIR}/win-install" "${OpenCV_INSTALL_BINARIES_PREFIX}${_lib_suffix}" "OpenCVConfig.root-WIN32.cmake.in")
   else()
     ocv_gen_config("${CMAKE_BINARY_DIR}/win-install" "" "")
   endif()

cmake/OpenCVGenPkgconfig.cmake

@@ -43,9 +43,9 @@ endmacro()
 if(NOT DEFINED CMAKE_HELPER_SCRIPT)
 
 if(INSTALL_TO_MANGLED_PATHS)
-  set(OPENCV_PC_FILE_NAME "opencv-${OPENCV_VERSION}.pc")
+  ocv_update(OPENCV_PC_FILE_NAME "opencv-${OPENCV_VERSION}.pc")
 else()
-  set(OPENCV_PC_FILE_NAME opencv.pc)
+  ocv_update(OPENCV_PC_FILE_NAME opencv4.pc)
 endif()
 
 # build the list of opencv libs and dependencies for all modules

cmake/OpenCVGenSetupVars.cmake

@@ -15,7 +15,7 @@ endif()
 if(INSTALL_TO_MANGLED_PATHS)
   ocv_update(OPENCV_SETUPVARS_FILENAME "setup_vars_opencv-${OPENCV_VERSION}${OPENCV_SCRIPT_EXTENSION}")
 else()
-  ocv_update(OPENCV_SETUPVARS_FILENAME setup_vars_opencv3${OPENCV_SCRIPT_EXTENSION})
+  ocv_update(OPENCV_SETUPVARS_FILENAME setup_vars_opencv4${OPENCV_SCRIPT_EXTENSION})
 endif()
 
 ##### build directory

cmake/OpenCVInstallLayout.cmake

@@ -1,101 +0,0 @@
-# message(STATUS "Initial install layout:")
-# ocv_cmake_dump_vars("OPENCV_.*_INSTALL_PATH")
-
-if(ANDROID)
-
-  ocv_update(OPENCV_BIN_INSTALL_PATH            "sdk/native/bin/${ANDROID_NDK_ABI_NAME}")
-  ocv_update(OPENCV_TEST_INSTALL_PATH           "${OPENCV_BIN_INSTALL_PATH}")
-  ocv_update(OPENCV_SAMPLES_BIN_INSTALL_PATH    "sdk/native/samples/${ANDROID_NDK_ABI_NAME}")
-  ocv_update(OPENCV_LIB_INSTALL_PATH            "sdk/native/libs/${ANDROID_NDK_ABI_NAME}")
-  ocv_update(OPENCV_LIB_ARCHIVE_INSTALL_PATH    "sdk/native/staticlibs/${ANDROID_NDK_ABI_NAME}")
-  ocv_update(OPENCV_3P_LIB_INSTALL_PATH         "sdk/native/3rdparty/libs/${ANDROID_NDK_ABI_NAME}")
-  ocv_update(OPENCV_CONFIG_INSTALL_PATH         "sdk/native/jni")
-  ocv_update(OPENCV_INCLUDE_INSTALL_PATH        "sdk/native/jni/include")
-  ocv_update(OPENCV_OTHER_INSTALL_PATH          "sdk/etc")
-  ocv_update(OPENCV_SAMPLES_SRC_INSTALL_PATH    "samples/native")
-  ocv_update(OPENCV_LICENSES_INSTALL_PATH       "${OPENCV_OTHER_INSTALL_PATH}/licenses")
-  ocv_update(OPENCV_TEST_DATA_INSTALL_PATH      "sdk/etc/testdata")
-  ocv_update(OPENCV_DOC_INSTALL_PATH            "doc")
-  ocv_update(OPENCV_JAR_INSTALL_PATH            ".")
-  ocv_update(OPENCV_JNI_INSTALL_PATH            "${OPENCV_LIB_INSTALL_PATH}")
-  ocv_update(OPENCV_JNI_BIN_INSTALL_PATH        "${OPENCV_JNI_INSTALL_PATH}")
-
-elseif(WIN32 AND CMAKE_HOST_SYSTEM_NAME MATCHES Windows)
-
-  if(DEFINED OpenCV_RUNTIME AND DEFINED OpenCV_ARCH)
-    ocv_update(OPENCV_INSTALL_BINARIES_PREFIX "${OpenCV_ARCH}/${OpenCV_RUNTIME}/")
-  else()
-    message(STATUS "Can't detect runtime and/or arch")
-    ocv_update(OPENCV_INSTALL_BINARIES_PREFIX "")
-  endif()
-  if(OpenCV_STATIC)
-    ocv_update(OPENCV_INSTALL_BINARIES_SUFFIX "staticlib")
-  else()
-    ocv_update(OPENCV_INSTALL_BINARIES_SUFFIX "lib")
-  endif()
-  if(INSTALL_CREATE_DISTRIB)
-    set(_jni_suffix "/${OpenCV_ARCH}")
-  else()
-    set(_jni_suffix "")
-  endif()
-
-  ocv_update(OPENCV_BIN_INSTALL_PATH           "${OPENCV_INSTALL_BINARIES_PREFIX}bin")
-  ocv_update(OPENCV_TEST_INSTALL_PATH          "${OPENCV_BIN_INSTALL_PATH}")
-  ocv_update(OPENCV_SAMPLES_BIN_INSTALL_PATH   "${OPENCV_INSTALL_BINARIES_PREFIX}samples")
-  ocv_update(OPENCV_LIB_INSTALL_PATH           "${OPENCV_INSTALL_BINARIES_PREFIX}${OPENCV_INSTALL_BINARIES_SUFFIX}")
-  ocv_update(OPENCV_LIB_ARCHIVE_INSTALL_PATH   "${OPENCV_LIB_INSTALL_PATH}")
-  ocv_update(OPENCV_3P_LIB_INSTALL_PATH        "${OPENCV_INSTALL_BINARIES_PREFIX}staticlib")
-  ocv_update(OPENCV_CONFIG_INSTALL_PATH        ".")
-  ocv_update(OPENCV_INCLUDE_INSTALL_PATH       "include")
-  ocv_update(OPENCV_OTHER_INSTALL_PATH         "etc")
-  ocv_update(OPENCV_SAMPLES_SRC_INSTALL_PATH   "samples")
-  ocv_update(OPENCV_LICENSES_INSTALL_PATH      "${OPENCV_OTHER_INSTALL_PATH}/licenses")
-  ocv_update(OPENCV_TEST_DATA_INSTALL_PATH     "testdata")
-  ocv_update(OPENCV_DOC_INSTALL_PATH           "doc")
-  ocv_update(OPENCV_JAR_INSTALL_PATH           "java")
-  ocv_update(OPENCV_JNI_INSTALL_PATH           "${OPENCV_JAR_INSTALL_PATH}${_jni_suffix}")
-  ocv_update(OPENCV_JNI_BIN_INSTALL_PATH       "${OPENCV_JNI_INSTALL_PATH}")
-
-else() # UNIX
-
-  include(GNUInstallDirs)
-  ocv_update(OPENCV_BIN_INSTALL_PATH           "bin")
-  ocv_update(OPENCV_TEST_INSTALL_PATH          "${OPENCV_BIN_INSTALL_PATH}")
-  ocv_update(OPENCV_SAMPLES_BIN_INSTALL_PATH   "${OPENCV_BIN_INSTALL_PATH}")
-  ocv_update(OPENCV_LIB_INSTALL_PATH           "${CMAKE_INSTALL_LIBDIR}")
-  ocv_update(OPENCV_LIB_ARCHIVE_INSTALL_PATH   "${OPENCV_LIB_INSTALL_PATH}")
-  ocv_update(OPENCV_3P_LIB_INSTALL_PATH        "share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH}")
-  ocv_update(OPENCV_CONFIG_INSTALL_PATH        "share/OpenCV")
-  ocv_update(OPENCV_INCLUDE_INSTALL_PATH       "include")
-  ocv_update(OPENCV_OTHER_INSTALL_PATH         "share/OpenCV")
-  ocv_update(OPENCV_SAMPLES_SRC_INSTALL_PATH   "share/OpenCV/samples")
-  ocv_update(OPENCV_LICENSES_INSTALL_PATH      "${CMAKE_INSTALL_DATAROOTDIR}/licenses/opencv3")
-  ocv_update(OPENCV_TEST_DATA_INSTALL_PATH     "share/OpenCV/testdata")
-  ocv_update(OPENCV_DOC_INSTALL_PATH           "share/OpenCV/doc")
-  ocv_update(OPENCV_JAR_INSTALL_PATH           "share/OpenCV/java")
-  ocv_update(OPENCV_JNI_INSTALL_PATH           "${OPENCV_JAR_INSTALL_PATH}")
-  ocv_update(OPENCV_JNI_BIN_INSTALL_PATH       "${OPENCV_JNI_INSTALL_PATH}")
-
-endif()
-
-ocv_update(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${OPENCV_LIB_INSTALL_PATH}")
-set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
-
-if(INSTALL_TO_MANGLED_PATHS)
-  set(OPENCV_INCLUDE_INSTALL_PATH ${OPENCV_INCLUDE_INSTALL_PATH}/opencv-${OPENCV_VERSION})
-  foreach(v
-      OPENCV_CONFIG_INSTALL_PATH
-      OPENCV_3P_LIB_INSTALL_PATH
-      OPENCV_SAMPLES_SRC_INSTALL_PATH
-      OPENCV_DOC_INSTALL_PATH
-      OPENCV_JAR_INSTALL_PATH
-      OPENCV_TEST_DATA_INSTALL_PATH
-      OPENCV_OTHER_INSTALL_PATH
-    )
-    string(REPLACE "OpenCV" "OpenCV-${OPENCV_VERSION}" ${v} "${${v}}")
-    string(REPLACE "opencv" "opencv-${OPENCV_VERSION}" ${v} "${${v}}")
-  endforeach()
-endif()
-
-# message(STATUS "Final install layout:")
-# ocv_cmake_dump_vars("OPENCV_.*_INSTALL_PATH")

cmake/OpenCVMinDepVersions.cmake

@@ -1,7 +1,6 @@
-if(NOT DEFINED MIN_VER_CMAKE)
-  set(MIN_VER_CMAKE 2.8.12.2)
-endif()
+set(MIN_VER_CMAKE 3.5.1)
 set(MIN_VER_CUDA 6.5)
+set(MIN_VER_CUDNN 6)
 set(MIN_VER_PYTHON2 2.7)
 set(MIN_VER_PYTHON3 3.2)
 set(MIN_VER_ZLIB 1.2.3)

cmake/OpenCVModule.cmake

@@ -33,7 +33,7 @@
 # The verbose template for OpenCV module:
 #
 #   ocv_add_module(modname <dependencies>)
-#   ocv_glob_module_sources(([EXCLUDE_CUDA] <extra sources&headers>)
+#   ocv_glob_module_sources(([EXCLUDE_OPENCL] [EXCLUDE_CUDA] <extra sources&headers>)
 #                          or glob them manually and ocv_set_module_sources(...)
 #   ocv_module_include_directories(<extra include directories>)
 #   ocv_create_module()
@@ -185,6 +185,7 @@ macro(ocv_add_module _name)
     # add self to the world dependencies
     if((NOT DEFINED OPENCV_MODULE_IS_PART_OF_WORLD
         AND NOT OPENCV_MODULE_${the_module}_CLASS STREQUAL "BINDINGS"
+        AND (NOT DEFINED OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD OR OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD)
         AND (NOT OPENCV_PROCESSING_EXTRA_MODULES OR NOT OPENCV_WORLD_EXCLUDE_EXTRA_MODULES)
         AND (NOT BUILD_SHARED_LIBS OR NOT "x${OPENCV_MODULE_TYPE}" STREQUAL "xSTATIC"))
         OR OPENCV_MODULE_IS_PART_OF_WORLD
@@ -779,6 +780,7 @@ macro(ocv_glob_module_sources)
        "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/hal/*.h"
        "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/utils/*.hpp"
        "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/utils/*.h"
+       "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/legacy/*.h"
   )
   file(GLOB lib_hdrs_detail
        "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/detail/*.hpp"
@@ -850,7 +852,7 @@ macro(ocv_create_module)
     set(the_module_target ${the_module})
   endif()
 
-  if(WINRT AND BUILD_TESTS)
+  if(WINRT)
     # removing APPCONTAINER from modules to run from console
     # in case of usual starting of WinRT test apps output is missing
     # so starting of console version w/o APPCONTAINER is required to get test results
@@ -1015,6 +1017,8 @@ macro(_ocv_create_module)
       string(REGEX REPLACE "^.*opencv2/" "opencv2/" hdr2 "${hdr}")
       if(NOT hdr2 MATCHES "private" AND hdr2 MATCHES "^(opencv2/?.*)/[^/]+.h(..)?$" )
         install(FILES ${hdr} OPTIONAL DESTINATION "${OPENCV_INCLUDE_INSTALL_PATH}/${CMAKE_MATCH_1}" COMPONENT dev)
+      else()
+        #message("Header file will be NOT installed: ${hdr}")
       endif()
     endforeach()
   endif()
@@ -1149,6 +1153,15 @@ function(ocv_add_perf_tests)
       ocv_target_link_libraries(${the_target} LINK_PRIVATE ${perf_deps} ${OPENCV_MODULE_${the_module}_DEPS} ${OPENCV_LINKER_LIBS} ${OPENCV_PERF_${the_module}_DEPS})
       add_dependencies(opencv_perf_tests ${the_target})
 
+      if(TARGET opencv_videoio_plugins)
+        add_dependencies(${the_target} opencv_videoio_plugins)
+      endif()
+
+      if(HAVE_HPX)
+        message("Linking HPX to Perf test of module ${name}")
+        ocv_target_link_libraries(${the_target} LINK_PRIVATE "${HPX_LIBRARIES}")
+      endif()
+
       set_target_properties(${the_target} PROPERTIES LABELS "${OPENCV_MODULE_${the_module}_LABEL};PerfTest")
       set_source_files_properties(${OPENCV_PERF_${the_module}_SOURCES} ${${the_target}_pch}
         PROPERTIES LABELS "${OPENCV_MODULE_${the_module}_LABEL};PerfTest")
@@ -1193,6 +1206,10 @@ endfunction()
 function(ocv_add_accuracy_tests)
   ocv_debug_message("ocv_add_accuracy_tests(" ${ARGN} ")")
 
+  if(WINRT)
+    set(OPENCV_DEBUG_POSTFIX "")
+  endif()
+
   set(test_path "${CMAKE_CURRENT_LIST_DIR}/test")
   if(BUILD_TESTS AND EXISTS "${test_path}")
     __ocv_parse_test_sources(TEST ${ARGN})
@@ -1230,6 +1247,15 @@ function(ocv_add_accuracy_tests)
       ocv_target_link_libraries(${the_target} LINK_PRIVATE ${test_deps} ${OPENCV_MODULE_${the_module}_DEPS} ${OPENCV_LINKER_LIBS} ${OPENCV_TEST_${the_module}_DEPS})
       add_dependencies(opencv_tests ${the_target})
 
+      if(TARGET opencv_videoio_plugins)
+        add_dependencies(${the_target} opencv_videoio_plugins)
+      endif()
+
+      if(HAVE_HPX)
+        message("Linking HPX to Perf test of module ${name}")
+        ocv_target_link_libraries(${the_target} LINK_PRIVATE "${HPX_LIBRARIES}")
+      endif()
+
       set_target_properties(${the_target} PROPERTIES LABELS "${OPENCV_MODULE_${the_module}_LABEL};AccuracyTest")
       set_source_files_properties(${OPENCV_TEST_${the_module}_SOURCES} ${${the_target}_pch}
         PROPERTIES LABELS "${OPENCV_MODULE_${the_module}_LABEL};AccuracyTest")
@@ -1307,6 +1333,10 @@ function(ocv_add_samples)
         endif()
         add_dependencies(${parent_target} ${the_target})
 
+        if(TARGET opencv_videoio_plugins)
+          add_dependencies(${the_target} opencv_videoio_plugins)
+        endif()
+
         if(WIN32)
           install(TARGETS ${the_target} RUNTIME DESTINATION "samples/${module_id}" COMPONENT samples)
         endif()

cmake/OpenCVPCHSupport.cmake

@@ -305,13 +305,10 @@ fi
 ${_command} '-D$<JOIN:$<TARGET_PROPERTY:${_targetName},COMPILE_DEFINITIONS>,' '-D>'
 ")
     GET_FILENAME_COMPONENT(_outdir ${_output} PATH)
-    if(NOT CMAKE_HOST_WIN32)  # chmod may be not available on Win32/MinGW (and it is not required)
-      set(_pch_prepare_command COMMAND chmod +x "${_pch_generate_file_cmd}")
-    endif()
     ADD_CUSTOM_COMMAND(
       OUTPUT "${_output}"
       COMMAND ${CMAKE_COMMAND} -E make_directory "${_outdir}"
-      ${_pch_prepare_command}
+      COMMAND chmod +x "${_pch_generate_file_cmd}"
       COMMAND "${_pch_generate_file_cmd}"
       DEPENDS "${_input}" "${_pch_generate_file_cmd}"
       DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/${_name}"

cmake/OpenCVPackaging.cmake

@@ -99,10 +99,15 @@ if(HAVE_CUDA)
       set(CPACK_DEB_libs_PACKAGE_DEPENDS "${CPACK_DEB_libs_PACKAGE_DEPENDS}, cuda-cufft-${cuda_version_suffix}")
       set(CPACK_DEB_dev_PACKAGE_DEPENDS "${CPACK_DEB_dev_PACKAGE_DEPENDS}, cuda-cufft-dev-${cuda_version_suffix}")
     endif()
-    if(HAVE_HAVE_CUBLAS)
+    if(HAVE_CUBLAS)
       set(CPACK_DEB_libs_PACKAGE_DEPENDS "${CPACK_DEB_libs_PACKAGE_DEPENDS}, cuda-cublas-${cuda_version_suffix}")
       set(CPACK_DEB_dev_PACKAGE_DEPENDS "${CPACK_DEB_dev_PACKAGE_DEPENDS}, cuda-cublas-dev-${cuda_version_suffix}")
     endif()
+    if(HAVE_CUDNN)
+      # TODO
+      #ex: libcudnn7_7.5.1.10-1+cuda10.1_amd64
+      #ex: libcudnn7-dev_7.5.1.10-1+cuda10.1_amd64
+    endif()
   endif()
   set(CPACK_COMPONENT_dev_DEPENDS libs)
 endif()
@@ -123,7 +128,7 @@ foreach(module calib3d core cudaarithm cudabgsegm cudacodec cudafeatures2d cudaf
                cudev features2d flann hal highgui imgcodecs imgproc ml objdetect ocl
                photo shape stitching superres ts video videoio videostab viz)
   if(HAVE_opencv_${module})
-    list(APPEND STD_OPENCV_LIBS "libopencv-${module}3.0")
+    list(APPEND STD_OPENCV_LIBS "libopencv-${module}4.0")
     list(APPEND STD_OPENCV_DEV "libopencv-${module}-dev")
   endif()
 endforeach()
@@ -140,9 +145,9 @@ set(CPACK_COMPONENT_PYTHON_CONFLICTS python-opencv)
 set(CPACK_COMPONENT_PYTHON_PROVIDES python-opencv)
 set(CPACK_COMPONENT_PYTHON_REPLACES python-opencv)
 
-set(CPACK_COMPONENT_JAVA_CONFLICTS "libopencv3.0-java, libopencv3.0-jni")
-set(CPACK_COMPONENT_JAVA_PROVIDES "libopencv3.0-java, libopencv3.0-jni")
-set(CPACK_COMPONENT_JAVA_REPLACES "libopencv3.0-java, libopencv3.0-jni")
+set(CPACK_COMPONENT_JAVA_CONFLICTS "libopencv4.0-java, libopencv4.0-jni")
+set(CPACK_COMPONENT_JAVA_PROVIDES "libopencv4.0-java, libopencv4.0-jni")
+set(CPACK_COMPONENT_JAVA_REPLACES "libopencv4.0-java, libopencv4.0-jni")
 
 set(CPACK_COMPONENT_DOCS_CONFLICTS opencv-doc)
 set(CPACK_COMPONENT_SAMPLES_CONFLICTS opencv-doc)

cmake/OpenCVUtils.cmake

@@ -16,8 +16,7 @@ function(ocv_cmake_dump_vars)
     string(TOLOWER "${__variableName}" __variableName_lower)
     if((__variableName MATCHES "${regex}" OR __variableName_lower MATCHES "${regex_lower}")
         AND NOT __variableName_lower MATCHES "^__")
-      get_property(__value VARIABLE PROPERTY "${__variableName}")
-      set(__VARS "${__VARS}${__variableName}=${__value}\n")
+      set(__VARS "${__VARS}${__variableName}=${${__variableName}}\n")
     endif()
   endforeach()
   if(DUMP_TOFILE)
@@ -415,34 +414,12 @@ MACRO(ocv_check_compiler_flag LANG FLAG RESULT)
       else()
         set(__msg "")
       endif()
-      if(CMAKE_REQUIRED_LIBRARIES)
-        set(__link_libs LINK_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES})
-      else()
-        set(__link_libs)
-      endif()
-      set(__cmake_flags "")
-      if(CMAKE_EXE_LINKER_FLAGS)  # CMP0056 do this on new CMake
-        list(APPEND __cmake_flags "-DCMAKE_EXE_LINKER_FLAGS=${CMAKE_EXE_LINKER_FLAGS}")
-      endif()
-
-      # CMP0067 do this on new CMake
-      if(DEFINED CMAKE_CXX_STANDARD)
-        list(APPEND __cmake_flags "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}")
-      endif()
-      if(DEFINED CMAKE_CXX_STANDARD_REQUIRED)
-        list(APPEND __cmake_flags "-DCMAKE_CXX_STANDARD_REQUIRED=${CMAKE_CXX_STANDARD_REQUIRED}")
-      endif()
-      if(DEFINED CMAKE_CXX_EXTENSIONS)
-        list(APPEND __cmake_flags "-DCMAKE_CXX_EXTENSIONS=${CMAKE_CXX_EXTENSIONS}")
-      endif()
-
       MESSAGE(STATUS "Performing Test ${RESULT}${__msg}")
       TRY_COMPILE(${RESULT}
         "${CMAKE_BINARY_DIR}"
         "${_fname}"
-        CMAKE_FLAGS ${__cmake_flags}
+        CMAKE_FLAGS "-DCMAKE_EXE_LINKER_FLAGS=${CMAKE_EXE_LINKER_FLAGS}"   # CMP0056 do this on new CMake
         COMPILE_DEFINITIONS "${FLAG}"
-        ${__link_libs}
         OUTPUT_VARIABLE OUTPUT)
 
       if(${RESULT})
@@ -804,7 +781,7 @@ macro(ocv_check_modules define)
           if(pkgcfg_lib_${define}_${_lib})
             list(APPEND _libs "${pkgcfg_lib_${define}_${_lib}}")
           else()
-            message(WARNING "ocv_check_modules(${define}): can't find library '${_lib}'. Specify 'pkgcfg_lib_${define}_${_lib}' manually")
+            message(WARNING "ocv_check_modules(${define}): can't find library '${_lib}'. Specify 'pkgcfg_lib_${define}_${_lib}' manualy")
             list(APPEND _libs "${_lib}")
           endif()
         else()
@@ -1340,15 +1317,6 @@ macro(ocv_parse_header2 LIBNAME HDR_PATH VARNAME)
   endif()
 endmacro()
 
-# TODO remove this
-# read single version info from the pkg file
-macro(ocv_parse_pkg ver_varname LIBNAME PKG_PATH)
-  if(EXISTS "${PKG_PATH}/${LIBNAME}.pc")
-    file(STRINGS "${PKG_PATH}/${LIBNAME}.pc" line_to_parse REGEX "^Version:[ \t]+[0-9.]*.*$" LIMIT_COUNT 1)
-    STRING(REGEX REPLACE ".*Version: ([^ ]+).*" "\\1" ${ver_varname} "${line_to_parse}" )
-  endif()
-endmacro()
-
 ################################################################################################
 # short command to setup source group
 function(ocv_source_group group)

cmake/android/OpenCVDetectAndroidSDK.cmake

@@ -8,6 +8,25 @@ if(DEFINED ANDROID_NDK_REVISION AND ANDROID_NDK_REVISION MATCHES "(1[56])([0-9]+
   set(ANDROID_NDK_REVISION "${ANDROID_NDK_REVISION}" CACHE INTERNAL "Android NDK revision")
 endif()
 
+# fixup -g option: https://github.com/opencv/opencv/issues/8460#issuecomment-434249750
+if(INSTALL_CREATE_DISTRIB
+  AND (NOT BUILD_WITH_DEBUG_INFO AND NOT CMAKE_BUILD_TYPE MATCHES "Debug")
+  AND NOT OPENCV_SKIP_ANDROID_G_OPTION_FIX
+)
+  if(" ${CMAKE_CXX_FLAGS} " MATCHES " -g ")
+    message(STATUS "Android: fixup -g compiler option from Android toolchain")
+  endif()
+  string(REPLACE " -g " " " CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} ")
+  string(REPLACE " -g " " " CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} ")
+  string(REPLACE " -g " " " CMAKE_ASM_FLAGS " ${CMAKE_ASM_FLAGS} ")
+  if(NOT " ${CMAKE_CXX_FLAGS_DEBUG}" MATCHES " -g")
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g")
+  endif()
+  if(NOT " ${CMAKE_C_FLAGS_DEBUG}" MATCHES " -g")
+    set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -g")
+  endif()
+endif()
+
 # https://developer.android.com/studio/command-line/variables.html
 ocv_check_environment_variables(ANDROID_SDK_ROOT ANDROID_HOME ANDROID_SDK)
 

cmake/android/android_ant_projects.cmake

@@ -49,7 +49,7 @@ macro(android_get_compatible_target VAR)
     list(GET ANDROID_SDK_TARGETS 0 __lvl)
     string(REGEX MATCH "[0-9]+$" __lvl "${__lvl}")
 
-    #find minimal level matching to all provided levels
+    #find minimal level mathing to all provided levels
     foreach(lvl ${ARGN})
       string(REGEX MATCH "[0-9]+$" __level "${lvl}")
       if(__level GREATER __lvl)
@@ -201,8 +201,8 @@ macro(add_android_project target path)
             LIBRARY_OUTPUT_DIRECTORY "${android_proj_bin_dir}/libs/${ANDROID_NDK_ABI_NAME}"
             )
 
-        if (NOT (CMAKE_BUILD_TYPE MATCHES "debug"))
-            add_custom_command(TARGET ${JNI_LIB_NAME} POST_BUILD COMMAND ${CMAKE_STRIP} --strip-unneeded "$<TARGET_FILE:${JNI_LIB_NAME}>")
+        if(NOT BUILD_WITH_DEBUG_INFO AND NOT CMAKE_BUILD_TYPE MATCHES "Debug")
+          add_custom_command(TARGET ${JNI_LIB_NAME} POST_BUILD COMMAND ${CMAKE_STRIP} --strip-unneeded "$<TARGET_FILE:${JNI_LIB_NAME}>")
         endif()
       endif()
     endif()

cmake/android/android_gradle_projects.cmake

@@ -1,5 +1,151 @@
-message(FATAL_ERROR "
-Android gradle-based build/projects are not supported in this version of OpenCV.
-You need to downgrade Android SDK Tools to version 25.2.5.
-Details: https://github.com/opencv/opencv/issues/8460
+# https://developer.android.com/studio/releases/gradle-plugin
+set(ANDROID_GRADLE_PLUGIN_VERSION "3.2.1" CACHE STRING "Android Gradle Plugin version (3.0+)")
+message(STATUS "Android Gradle Plugin version: ${ANDROID_GRADLE_PLUGIN_VERSION}")
+
+set(ANDROID_COMPILE_SDK_VERSION "26" CACHE STRING "Android compileSdkVersion")
+set(ANDROID_MIN_SDK_VERSION "21" CACHE STRING "Android minSdkVersion")
+set(ANDROID_TARGET_SDK_VERSION "26" CACHE STRING "Android minSdkVersion")
+
+set(ANDROID_BUILD_BASE_DIR "${OpenCV_BINARY_DIR}/opencv_android" CACHE INTERNAL "")
+set(ANDROID_TMP_INSTALL_BASE_DIR "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/install/opencv_android")
+
+set(ANDROID_INSTALL_SAMPLES_DIR "samples")
+
+set(ANDROID_BUILD_ABI_FILTER "
+reset()
+include '${ANDROID_ABI}'
 ")
+
+set(ANDROID_INSTALL_ABI_FILTER "
+//reset()
+//include 'armeabi-v7a'
+//include 'arm64-v8a'
+//include 'x86'
+//include 'x86_64'
+")
+if(NOT INSTALL_CREATE_DISTRIB)
+  set(ANDROID_INSTALL_ABI_FILTER "${ANDROID_BUILD_ABI_FILTER}")
+endif()
+
+# BUG: Ninja generator generates broken targets with ANDROID_ABI_FILTER name (CMake 3.11.2)
+#set(__spaces "                        ")
+#string(REPLACE "\n" "\n${__spaces}" ANDROID_ABI_FILTER "${__spaces}${ANDROID_BUILD_ABI_FILTER}")
+#string(REPLACE REGEX "[ ]+$" "" ANDROID_ABI_FILTER "${ANDROID_ABI_FILTER}")
+set(ANDROID_ABI_FILTER "${ANDROID_BUILD_ABI_FILTER}")
+configure_file("${OpenCV_SOURCE_DIR}/samples/android/build.gradle.in" "${ANDROID_BUILD_BASE_DIR}/build.gradle" @ONLY)
+
+set(ANDROID_ABI_FILTER "${ANDROID_INSTALL_ABI_FILTER}")
+configure_file("${OpenCV_SOURCE_DIR}/samples/android/build.gradle.in" "${ANDROID_TMP_INSTALL_BASE_DIR}/${ANDROID_INSTALL_SAMPLES_DIR}/build.gradle" @ONLY)
+install(FILES "${ANDROID_TMP_INSTALL_BASE_DIR}/${ANDROID_INSTALL_SAMPLES_DIR}/build.gradle" DESTINATION "${ANDROID_INSTALL_SAMPLES_DIR}" COMPONENT samples)
+
+set(GRADLE_WRAPPER_FILES
+    "gradle/wrapper/gradle-wrapper.jar"
+    "gradle/wrapper/gradle-wrapper.properties"
+    "gradlew.bat"
+    "gradlew"
+    "gradle.properties"
+)
+foreach(fname ${GRADLE_WRAPPER_FILES})
+  get_filename_component(__dir "${fname}" DIRECTORY)
+  set(__permissions "")
+  set(__permissions_prefix "")
+  if(fname STREQUAL "gradlew")
+    set(__permissions FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
+  endif()
+  file(COPY "${OpenCV_SOURCE_DIR}/platforms/android/gradle-wrapper/${fname}" DESTINATION "${ANDROID_BUILD_BASE_DIR}/${__dir}" ${__permissions})
+  string(REPLACE "FILE_PERMISSIONS" "PERMISSIONS" __permissions "${__permissions}")
+  if("${__dir}" STREQUAL "")
+    set(__dir ".")
+  endif()
+  install(FILES "${OpenCV_SOURCE_DIR}/platforms/android/gradle-wrapper/${fname}" DESTINATION "${ANDROID_INSTALL_SAMPLES_DIR}/${__dir}" COMPONENT samples ${__permissions})
+endforeach()
+
+file(WRITE "${ANDROID_BUILD_BASE_DIR}/settings.gradle" "
+include ':opencv'
+")
+
+file(WRITE "${ANDROID_TMP_INSTALL_BASE_DIR}/settings.gradle" "
+rootProject.name = 'opencv_samples'
+
+def opencvsdk='../'
+//def opencvsdk='/<path to OpenCV-android-sdk>'
+//println opencvsdk
+include ':opencv'
+project(':opencv').projectDir = new File(opencvsdk + '/sdk')
+")
+
+
+macro(add_android_project target path)
+  get_filename_component(__dir "${path}" NAME)
+
+  set(OPENCV_ANDROID_CMAKE_EXTRA_ARGS "")
+  if(DEFINED ANDROID_TOOLCHAIN)
+    set(OPENCV_ANDROID_CMAKE_EXTRA_ARGS "${OPENCV_ANDROID_CMAKE_EXTRA_ARGS},\n\"-DANDROID_TOOLCHAIN=${ANDROID_TOOLCHAIN}\"")
+  endif()
+  if(DEFINED ANDROID_STL)
+    set(OPENCV_ANDROID_CMAKE_EXTRA_ARGS "${OPENCV_ANDROID_CMAKE_EXTRA_ARGS},\n\"-DANDROID_STL=${ANDROID_STL}\"")
+  endif()
+
+  #
+  # Build
+  #
+  set(ANDROID_SAMPLE_JNI_PATH "${path}/jni")
+  set(ANDROID_SAMPLE_JAVA_PATH "${path}/src")
+  set(ANDROID_SAMPLE_RES_PATH "${path}/res")
+  set(ANDROID_SAMPLE_MANIFEST_PATH "${path}/gradle/AndroidManifest.xml")
+
+  set(ANDROID_ABI_FILTER "${ANDROID_BUILD_ABI_FILTER}")
+  set(ANDROID_PROJECT_JNI_PATH "../../")
+
+  string(REPLACE ";" "', '" ANDROID_SAMPLE_JAVA_PATH "['${ANDROID_SAMPLE_JAVA_PATH}']")
+  string(REPLACE ";" "', '" ANDROID_SAMPLE_RES_PATH "['${ANDROID_SAMPLE_RES_PATH}']")
+  configure_file("${path}/build.gradle.in" "${ANDROID_BUILD_BASE_DIR}/${__dir}/build.gradle" @ONLY)
+
+  file(APPEND "${ANDROID_BUILD_BASE_DIR}/settings.gradle" "
+include ':${__dir}'
+")
+
+  # build apk
+  set(APK_FILE "${ANDROID_BUILD_BASE_DIR}/${__dir}/build/outputs/apk/release/${__dir}-${ANDROID_ABI}-release-unsigned.apk")
+  ocv_update(OPENCV_GRADLE_VERBOSE_OPTIONS "-i")
+  add_custom_command(
+      OUTPUT "${APK_FILE}" "${OPENCV_DEPHELPER}/android_sample_${__dir}"
+      COMMAND ./gradlew ${OPENCV_GRADLE_VERBOSE_OPTIONS} "${__dir}:assemble"
+      COMMAND ${CMAKE_COMMAND} -E touch "${OPENCV_DEPHELPER}/android_sample_${__dir}"
+      WORKING_DIRECTORY "${ANDROID_BUILD_BASE_DIR}"
+      DEPENDS ${depends} opencv_java_android
+      COMMENT "Building OpenCV Android sample project: ${__dir}"
+  )
+  file(REMOVE "${OPENCV_DEPHELPER}/android_sample_${__dir}")  # force rebuild after CMake run
+
+  add_custom_target(android_sample_${__dir} ALL DEPENDS "${OPENCV_DEPHELPER}/android_sample_${__dir}" SOURCES "${ANDROID_SAMPLE_MANIFEST_PATH}")
+
+  #
+  # Install
+  #
+  set(ANDROID_SAMPLE_JNI_PATH "jni")
+  set(ANDROID_SAMPLE_JAVA_PATH "src")
+  set(ANDROID_SAMPLE_RES_PATH "res")
+  set(ANDROID_SAMPLE_MANIFEST_PATH "AndroidManifest.xml")
+
+  install(DIRECTORY "${path}/res" DESTINATION "${ANDROID_INSTALL_SAMPLES_DIR}/${__dir}" COMPONENT samples OPTIONAL)
+  install(DIRECTORY "${path}/src" DESTINATION "${ANDROID_INSTALL_SAMPLES_DIR}/${__dir}" COMPONENT samples)
+  install(DIRECTORY "${path}/jni" DESTINATION "${ANDROID_INSTALL_SAMPLES_DIR}/${__dir}" COMPONENT samples OPTIONAL)
+
+  install(FILES "${path}/gradle/AndroidManifest.xml" DESTINATION "${ANDROID_INSTALL_SAMPLES_DIR}/${__dir}" COMPONENT samples)
+
+  set(ANDROID_ABI_FILTER "${ANDROID_INSTALL_ABI_FILTER}")
+  set(ANDROID_PROJECT_JNI_PATH "native/jni")
+
+  string(REPLACE ";" "', '" ANDROID_SAMPLE_JAVA_PATH "['${ANDROID_SAMPLE_JAVA_PATH}']")
+  string(REPLACE ";" "', '" ANDROID_SAMPLE_RES_PATH "['${ANDROID_SAMPLE_RES_PATH}']")
+  configure_file("${path}/build.gradle.in" "${ANDROID_TMP_INSTALL_BASE_DIR}/${__dir}/build.gradle" @ONLY)
+  install(FILES "${ANDROID_TMP_INSTALL_BASE_DIR}/${__dir}/build.gradle" DESTINATION "${ANDROID_INSTALL_SAMPLES_DIR}/${__dir}" COMPONENT samples)
+
+  file(APPEND "${ANDROID_TMP_INSTALL_BASE_DIR}/settings.gradle" "
+include ':${__dir}'
+")
+
+endmacro()
+
+install(FILES "${ANDROID_TMP_INSTALL_BASE_DIR}/settings.gradle" DESTINATION "${ANDROID_INSTALL_SAMPLES_DIR}" COMPONENT samples)

cmake/checks/OpenCVDetectCudaArch.cu

@@ -1,14 +1,25 @@
-#include <stdio.h>
+#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;}
+    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;}
-        printf("%d.%d ", prop.major, prop.minor);
+        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

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

cmake/checks/cpu_avx2.cpp

@@ -6,6 +6,5 @@ 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_avx512cel.cpp

@@ -3,9 +3,9 @@
 void test()
 {
     __m512i a, b, c;
-    a = _mm512_dpwssd_epi32(a, b, c);            // VNNI
+    a = _mm512_dpwssd_epi32(a, b, c);
 }
 #else
-#error "AVX512-CLX is not supported"
+#error "AVX512-CEL is not supported"
 #endif
-int main() { return 0; }
+int main() { return 0; }

cmake/checks/cpu_avx512icl.cpp

@@ -3,10 +3,9 @@
 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
+    a = _mm512_popcnt_epi8(a);
+    a = _mm512_shrdv_epi64(a, b, c);
+    a = _mm512_popcnt_epi64(a);
 }
 #else
 #error "AVX512-ICL is not supported"

cmake/checks/cpu_msa.cpp

@@ -1,23 +0,0 @@
-#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/vfwtest.cpp

@@ -1,10 +0,0 @@
-
-#include <windows.h>
-#include <vfw.h>
-
-int main()
-{
-  AVIFileInit();
-  AVIFileExit();
-  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/platforms/OpenCV-Android.cmake

@@ -1 +0,0 @@
-# empty

cmake/platforms/OpenCV-Darwin.cmake

@@ -1 +0,0 @@
-# empty

cmake/platforms/OpenCV-Linux.cmake

@@ -1 +0,0 @@
-# empty

cmake/platforms/OpenCV-WinRT.cmake

@@ -1,31 +0,0 @@
-set(WINRT TRUE)
-
-add_definitions(-DWINRT -DNO_GETENV)
-
-# Making definitions available to other configurations and
-# to filter dependency restrictions at compile time.
-if(WINDOWS_PHONE)
-  set(WINRT_PHONE TRUE)
-  add_definitions(-DWINRT_PHONE)
-elseif(WINDOWS_STORE)
-  set(WINRT_STORE TRUE)
-  add_definitions(-DWINRT_STORE)
-endif()
-
-if(CMAKE_SYSTEM_VERSION MATCHES 10)
-  set(WINRT_10 TRUE)
-  add_definitions(-DWINRT_10)
-  add_definitions(/DWINVER=_WIN32_WINNT_WIN10 /DNTDDI_VERSION=NTDDI_WIN10 /D_WIN32_WINNT=_WIN32_WINNT_WIN10)
-elseif(CMAKE_SYSTEM_VERSION MATCHES 8.1)
-  set(WINRT_8_1 TRUE)
-  add_definitions(-DWINRT_8_1)
-  add_definitions(/DWINVER=_WIN32_WINNT_WINBLUE /DNTDDI_VERSION=NTDDI_WINBLUE /D_WIN32_WINNT=_WIN32_WINNT_WINBLUE)
-elseif(CMAKE_SYSTEM_VERSION MATCHES 8.0)
-  set(WINRT_8_0 TRUE)
-  add_definitions(-DWINRT_8_0)
-  add_definitions(/DWINVER=_WIN32_WINNT_WIN8 /DNTDDI_VERSION=NTDDI_WIN8 /D_WIN32_WINNT=_WIN32_WINNT_WIN8)
-else()
-  message(STATUS "Unsupported WINRT version (consider upgrading OpenCV): ${CMAKE_SYSTEM_VERSION}")
-endif()
-
-set(OPENCV_DEBUG_POSTFIX "")

cmake/platforms/OpenCV-Windows.cmake

@@ -1 +0,0 @@
-# empty

cmake/platforms/OpenCV-WindowsCE.cmake

@@ -1 +0,0 @@
-add_definitions(-DNO_GETENV)