Merge branch 4.x

modules/core/src/directx.cpp

@@ -1385,6 +1385,7 @@ void convertFromD3D11Texture2D(ID3D11Texture2D* pD3D11Texture2D, OutputArray dst
     OpenCL_D3D11_NV* impl_nv = ctx.getUserContext<OpenCL_D3D11_NV>().get();
     if (impl_nv) {
         __convertFromD3D11Texture2DNV(pD3D11Texture2D,dst);
+        return;
     }
 #endif
     OpenCL_D3D11* impl = ctx.getUserContext<OpenCL_D3D11>().get();

modules/core/src/mathfuncs.cpp

@@ -270,6 +270,9 @@ void cartToPolar( InputArray src1, InputArray src2,
 {
     CV_INSTRUMENT_REGION();
 
+    CV_Assert(src1.getObj() != dst1.getObj() && src1.getObj() != dst2.getObj() &&
+              src2.getObj() != dst1.getObj() && src2.getObj() != dst2.getObj());
+
     CV_OCL_RUN(dst1.isUMat() && dst2.isUMat(),
             ocl_cartToPolar(src1, src2, dst1, dst2, angleInDegrees))
 
@@ -564,6 +567,9 @@ void polarToCart( InputArray src1, InputArray src2,
 {
     CV_INSTRUMENT_REGION();
 
+    CV_Assert(src1.getObj() != dst1.getObj() && src1.getObj() != dst2.getObj() &&
+              src2.getObj() != dst1.getObj() && src2.getObj() != dst2.getObj());
+
     int type = src2.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
     CV_Assert((depth == CV_32F || depth == CV_64F) && (src1.empty() || src1.type() == type));
 

modules/core/src/matrix.cpp

@@ -664,6 +664,8 @@ void Mat::create(int d, const int* _sizes, int _type)
 
     if( data && (d == dims || (d == 1 && dims <= 2)) && _type == type() )
     {
+        if ( dims == 1 && (d == 1 && _sizes[0] == size[0]) )
+            return;
         if( d == 2 && rows == _sizes[0] && cols == _sizes[1] )
             return;
         for( i = 0; i < d; i++ )

modules/core/src/matrix_transform.cpp

@@ -4,6 +4,7 @@
 
 #include "precomp.hpp"
 #include "opencl_kernels_core.hpp"
+#include "opencv2/core/detail/dispatch_helper.impl.hpp"
 
 namespace cv {
 
@@ -282,6 +283,72 @@ void transpose( InputArray _src, OutputArray _dst )
 }
 
 
+void transposeND(InputArray src_, const std::vector<int>& order, OutputArray dst_)
+{
+    Mat inp = src_.getMat();
+    CV_Assert(inp.isContinuous());
+    CV_CheckEQ(inp.channels(), 1, "Input array should be single-channel");
+    CV_CheckEQ(order.size(), static_cast<size_t>(inp.dims), "Number of dimensions shouldn't change");
+
+    auto order_ = order;
+    std::sort(order_.begin(), order_.end());
+    for (size_t i = 0; i < order_.size(); ++i)
+    {
+        CV_CheckEQ(static_cast<size_t>(order_[i]), i, "New order should be a valid permutation of the old one");
+    }
+
+    std::vector<int> newShape(order.size());
+    for (size_t i = 0; i < order.size(); ++i)
+    {
+        newShape[i] = inp.size[order[i]];
+    }
+
+    dst_.create(static_cast<int>(newShape.size()), newShape.data(), inp.type());
+    Mat out = dst_.getMat();
+    CV_Assert(out.isContinuous());
+    CV_Assert(inp.data != out.data);
+
+    int continuous_idx = 0;
+    for (int i = static_cast<int>(order.size()) - 1; i >= 0; --i)
+    {
+        if (order[i] != i)
+        {
+            continuous_idx = i + 1;
+            break;
+        }
+    }
+
+    size_t continuous_size = continuous_idx == 0 ? out.total() : out.step1(continuous_idx - 1);
+    size_t outer_size = out.total() / continuous_size;
+
+    std::vector<size_t> steps(order.size());
+    for (int i = 0; i < static_cast<int>(steps.size()); ++i)
+    {
+        steps[i] = inp.step1(order[i]);
+    }
+
+    auto* src = inp.ptr<const unsigned char>();
+    auto* dst = out.ptr<unsigned char>();
+
+    size_t src_offset = 0;
+    size_t es = out.elemSize();
+    for (size_t i = 0; i < outer_size; ++i)
+    {
+        std::memcpy(dst, src + es * src_offset, es * continuous_size);
+        dst += es * continuous_size;
+        for (int j = continuous_idx - 1; j >= 0; --j)
+        {
+            src_offset += steps[j];
+            if ((src_offset / steps[j]) % out.size[j] != 0)
+            {
+                break;
+            }
+            src_offset -= steps[j] * out.size[j];
+        }
+    }
+}
+
+
 #if CV_SIMD128
 template<typename V> CV_ALWAYS_INLINE void flipHoriz_single( const uchar* src, size_t sstep, uchar* dst, size_t dstep, Size size, size_t esz )
 {

modules/core/src/persistence.cpp

@@ -817,7 +817,7 @@ char *FileStorage::Impl::gets(size_t maxCount) {
         int delta = (int) strlen(ptr);
         ofs += delta;
         maxCount -= delta;
-        if (ptr[delta - 1] == '\n' || maxCount == 0)
+        if (delta == 0 || ptr[delta - 1] == '\n' || maxCount == 0)
             break;
         if (delta == count)
             buffer.resize((size_t) (buffer.size() * 1.5));

modules/core/src/system.cpp

@@ -615,6 +615,9 @@ struct HWFeatures
     #if defined _ARM_ && (defined(_WIN32_WCE) && _WIN32_WCE >= 0x800)
         have[CV_CPU_NEON] = true;
     #endif
+    #if defined _M_ARM64
+        have[CV_CPU_NEON] = true;
+    #endif
     #ifdef __riscv_vector
         have[CV_CPU_RISCVV] = true;
     #endif

modules/core/src/va_wrapper.impl.hpp

@@ -15,18 +15,33 @@ typedef VAStatus (*FN_vaDestroyImage)(VADisplay dpy, VAImageID image);
 typedef VAStatus (*FN_vaMapBuffer)(VADisplay dpy, VABufferID buf_id, void **pbuf);
 typedef VAStatus (*FN_vaSyncSurface)(VADisplay dpy, VASurfaceID render_target);
 typedef VAStatus (*FN_vaUnmapBuffer)(VADisplay dpy, VABufferID buf_id);
+typedef int (*FN_vaMaxNumImageFormats)(VADisplay dpy);
+typedef VAStatus (*FN_vaQueryImageFormats)(VADisplay dpy, VAImageFormat *format_list, int *num_formats);
+typedef VAStatus (*FN_vaCreateImage)(VADisplay dpy, VAImageFormat *format, int width, int height, VAImage *image);
+typedef VAStatus (*FN_vaPutImage)(VADisplay dpy, VASurfaceID surface, VAImageID image, int src_x, int src_y, unsigned int src_width, unsigned int src_height, int dest_x, int dest_y, unsigned int dest_width, unsigned int dest_height);
+typedef VAStatus (*FN_vaGetImage)(VADisplay dpy, VASurfaceID surface, int x, int y, unsigned int width, unsigned int height, VAImageID image);
 
 static FN_vaDeriveImage fn_vaDeriveImage = NULL;
 static FN_vaDestroyImage fn_vaDestroyImage = NULL;
 static FN_vaMapBuffer fn_vaMapBuffer = NULL;
 static FN_vaSyncSurface fn_vaSyncSurface = NULL;
 static FN_vaUnmapBuffer fn_vaUnmapBuffer = NULL;
+static FN_vaMaxNumImageFormats fn_vaMaxNumImageFormats = NULL;
+static FN_vaQueryImageFormats fn_vaQueryImageFormats = NULL;
+static FN_vaCreateImage fn_vaCreateImage = NULL;
+static FN_vaPutImage fn_vaPutImage = NULL;
+static FN_vaGetImage fn_vaGetImage = NULL;
 
 #define vaDeriveImage fn_vaDeriveImage
 #define vaDestroyImage fn_vaDestroyImage
 #define vaMapBuffer fn_vaMapBuffer
 #define vaSyncSurface fn_vaSyncSurface
 #define vaUnmapBuffer fn_vaUnmapBuffer
+#define vaMaxNumImageFormats fn_vaMaxNumImageFormats
+#define vaQueryImageFormats fn_vaQueryImageFormats
+#define vaCreateImage fn_vaCreateImage
+#define vaPutImage fn_vaPutImage
+#define vaGetImage fn_vaGetImage
 
 
 static std::shared_ptr<cv::plugin::impl::DynamicLib> loadLibVA()
@@ -76,6 +91,11 @@ static void init_libva()
         VA_LOAD_SYMBOL(vaMapBuffer);
         VA_LOAD_SYMBOL(vaSyncSurface);
         VA_LOAD_SYMBOL(vaUnmapBuffer);
+        VA_LOAD_SYMBOL(vaMaxNumImageFormats);
+        VA_LOAD_SYMBOL(vaQueryImageFormats);
+        VA_LOAD_SYMBOL(vaCreateImage);
+        VA_LOAD_SYMBOL(vaPutImage);
+        VA_LOAD_SYMBOL(vaGetImage);
         initialized = true;
     }
     if (!library)