Merge branch 4.x

hal/ipp/CMakeLists.txt

@@ -5,6 +5,7 @@ set(IPP_HAL_LIBRARIES "ipphal" CACHE INTERNAL "")
 set(IPP_HAL_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/include" CACHE INTERNAL "")
 set(IPP_HAL_HEADERS
   "${CMAKE_CURRENT_SOURCE_DIR}/include/ipp_hal_core.hpp"
+  "${CMAKE_CURRENT_SOURCE_DIR}/include/ipp_hal_imgproc.hpp"
   CACHE INTERNAL "")
 
 add_library(ipphal STATIC
@@ -13,6 +14,7 @@ add_library(ipphal STATIC
     "${CMAKE_CURRENT_SOURCE_DIR}/src/norm_ipp.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/cart_polar_ipp.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/transforms_ipp.cpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/warp_ipp.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/sum_ipp.cpp"
 )
 
@@ -34,6 +36,7 @@ ocv_warnings_disable(CMAKE_CXX_FLAGS -Wno-suggest-override)
 target_include_directories(ipphal PRIVATE
   "${CMAKE_CURRENT_SOURCE_DIR}/src"
   ${CMAKE_SOURCE_DIR}/modules/core/include
+  ${CMAKE_SOURCE_DIR}/modules/imgproc/include
   ${IPP_INCLUDE_DIRS}
 )
 

hal/ipp/include/ipp_hal_core.hpp

@@ -21,7 +21,17 @@ int ipp_hal_minMaxIdxMaskStep(const uchar* src_data, size_t src_step, int width,
 #undef cv_hal_minMaxIdxMaskStep
 #define cv_hal_minMaxIdxMaskStep ipp_hal_minMaxIdxMaskStep
 
-#define IPP_DISABLE_NORM_8U             1 // accuracy difference in perf test sanity check
+#if (IPP_VERSION_X100 == 202200)
+# define IPP_DISABLE_NORM_8U             1 // accuracy difference in perf test sanity check
+# else
+# define IPP_DISABLE_NORM_8U             0
+#endif
+
+#if (IPP_VERSION_X100 >= 202200 && IPP_VERSION_X100 < 202220)
+# define IPP_DISABLE_NORM_INF_16U_C1MR   1 // segmentation fault in accuracy test
+# else
+# define IPP_DISABLE_NORM_INF_16U_C1MR   0
+#endif
 
 int ipp_hal_norm(const uchar* src, size_t src_step, const uchar* mask, size_t mask_step,
                  int width, int height, int type, int norm_type, double* result);
@@ -29,7 +39,6 @@ int ipp_hal_norm(const uchar* src, size_t src_step, const uchar* mask, size_t ma
 #undef cv_hal_norm
 #define cv_hal_norm ipp_hal_norm
 
-
 int ipp_hal_normDiff(const uchar* src1, size_t src1_step, const uchar* src2, size_t src2_step, const uchar* mask,
                      size_t mask_step, int width, int height, int type, int norm_type, double* result);
 

hal/ipp/include/ipp_hal_imgproc.hpp

@@ -0,0 +1,39 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#ifndef __IPP_HAL_IMGPROC_HPP__
+#define __IPP_HAL_IMGPROC_HPP__
+
+#include <opencv2/core/base.hpp>
+#include "ipp_utils.hpp"
+
+#ifdef HAVE_IPP_IW
+
+int ipp_hal_warpAffine(int src_type, const uchar *src_data, size_t src_step, int src_width, int src_height, uchar *dst_data, size_t dst_step, int dst_width,
+                       int dst_height, const double M[6], int interpolation, int borderType, const double borderValue[4]);
+
+// Does not pass tests in 5.x branch
+//#undef cv_hal_warpAffine
+//#define cv_hal_warpAffine ipp_hal_warpAffine
+#endif
+
+#if IPP_VERSION_X100 >= 810
+int ipp_hal_warpPerspective(int src_type, const uchar *src_data, size_t src_step, int src_width, int src_height, uchar *dst_data, size_t dst_step, int dst_width,
+                            int dst_height, const double M[9], int interpolation, int borderType, const double borderValue[4]);
+
+// Does not pass tests in 5.x branch
+//#undef cv_hal_warpPerspective
+//#define cv_hal_warpPerspective ipp_hal_warpPerspective
+#endif
+
+
+int ipp_hal_remap32f(int src_type, const uchar *src_data, size_t src_step, int src_width, int src_height,
+    uchar *dst_data, size_t dst_step, int dst_width, int dst_height,
+    float* mapx, size_t mapx_step, float* mapy, size_t mapy_step,
+    int interpolation, int border_type, const double border_value[4]);
+#undef cv_hal_remap32f
+#define cv_hal_remap32f ipp_hal_remap32f
+
+
+#endif //__IPP_HAL_IMGPROC_HPP__

hal/ipp/src/norm_ipp.cpp

@@ -20,7 +20,9 @@ int ipp_hal_norm(const uchar* src, size_t src_step, const uchar* mask, size_t ma
         ippiMaskNormFuncC1 ippiNorm_C1MR =
         norm_type == cv::NORM_INF ?
         (type == CV_8UC1 ? (ippiMaskNormFuncC1)ippiNorm_Inf_8u_C1MR :
+        #if (!IPP_DISABLE_NORM_INF_16U_C1MR)
         type == CV_16UC1 ? (ippiMaskNormFuncC1)ippiNorm_Inf_16u_C1MR :
+        #endif
         type == CV_32FC1 ? (ippiMaskNormFuncC1)ippiNorm_Inf_32f_C1MR :
         0) :
         norm_type == cv::NORM_L1 ?
@@ -141,7 +143,9 @@ int ipp_hal_normDiff(const uchar* src1, size_t src1_step, const uchar* src2, siz
             ippiMaskNormDiffFuncC1 ippiNormRel_C1MR =
             norm_type == cv::NORM_INF ?
             (type == CV_8UC1 ? (ippiMaskNormDiffFuncC1)ippiNormRel_Inf_8u_C1MR :
+            #if (!IPP_DISABLE_NORM_INF_16U_C1MR)
             type == CV_16UC1 ? (ippiMaskNormDiffFuncC1)ippiNormRel_Inf_16u_C1MR :
+            #endif
             type == CV_32FC1 ? (ippiMaskNormDiffFuncC1)ippiNormRel_Inf_32f_C1MR :
             0) :
             norm_type == cv::NORM_L1 ?
@@ -230,7 +234,9 @@ int ipp_hal_normDiff(const uchar* src1, size_t src1_step, const uchar* src2, siz
         ippiMaskNormDiffFuncC1 ippiNormDiff_C1MR =
         norm_type == cv::NORM_INF ?
         (type == CV_8UC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_Inf_8u_C1MR :
+        #if (!IPP_DISABLE_NORM_INF_16U_C1MR)
         type == CV_16UC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_Inf_16u_C1MR :
+        #endif
         type == CV_32FC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_Inf_32f_C1MR :
         0) :
         norm_type == cv::NORM_L1 ?

hal/ipp/src/precomp_ipp.hpp

@@ -0,0 +1,83 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#ifndef __PRECOMP_IPP_HPP__
+#define __PRECOMP_IPP_HPP__
+
+#include <opencv2/imgproc.hpp>
+
+#ifdef HAVE_IPP_IW
+#include "iw++/iw.hpp"
+#endif
+
+static inline IppiSize ippiSize(size_t width, size_t height)
+{
+    IppiSize size = { (int)width, (int)height };
+    return size;
+}
+
+static inline IppiSize ippiSize(const cv::Size & _size)
+{
+    IppiSize size = { _size.width, _size.height };
+    return size;
+}
+
+static inline IppDataType ippiGetDataType(int depth)
+{
+    depth = CV_MAT_DEPTH(depth);
+    return depth == CV_8U ? ipp8u :
+    depth == CV_8S ? ipp8s :
+    depth == CV_16U ? ipp16u :
+    depth == CV_16S ? ipp16s :
+    depth == CV_32S ? ipp32s :
+    depth == CV_32F ? ipp32f :
+    depth == CV_64F ? ipp64f :
+    (IppDataType)-1;
+}
+
+static inline IppiInterpolationType ippiGetInterpolation(int inter)
+{
+    inter &= cv::InterpolationFlags::INTER_MAX;
+    return inter == cv::InterpolationFlags::INTER_NEAREST ? ippNearest :
+        inter == cv::InterpolationFlags::INTER_LINEAR ? ippLinear :
+        inter == cv::InterpolationFlags::INTER_CUBIC ? ippCubic :
+        inter == cv::InterpolationFlags::INTER_LANCZOS4 ? ippLanczos :
+        inter == cv::InterpolationFlags::INTER_AREA ? ippSuper :
+        (IppiInterpolationType)-1;
+}
+
+static inline IppiBorderType ippiGetBorderType(int borderTypeNI)
+{
+    return borderTypeNI == cv::BorderTypes::BORDER_CONSTANT    ? ippBorderConst   :
+           borderTypeNI == cv::BorderTypes::BORDER_TRANSPARENT ? ippBorderTransp  :
+           borderTypeNI == cv::BorderTypes::BORDER_REPLICATE   ? ippBorderRepl    :
+           (IppiBorderType)-1;
+}
+
+static inline int ippiSuggestThreadsNum(size_t width, size_t height, size_t elemSize, double multiplier)
+{
+    int threads = cv::getNumThreads();
+    if(threads > 1 && height >= 64)
+    {
+        size_t opMemory = (int)(width*height*elemSize*multiplier);
+        int l2cache = 0;
+#if IPP_VERSION_X100 >= 201700
+        ippGetL2CacheSize(&l2cache);
+#endif
+        if(!l2cache)
+            l2cache = 1 << 18;
+
+        return IPP_MAX(1, (IPP_MIN((int)(opMemory/l2cache), threads)));
+    }
+    return 1;
+}
+
+#ifdef HAVE_IPP_IW
+static inline int ippiSuggestThreadsNum(const ::ipp::IwiImage &image, double multiplier)
+{
+    return ippiSuggestThreadsNum(image.m_size.width, image.m_size.height, image.m_typeSize*image.m_channels, multiplier);
+}
+#endif
+
+#endif //__PRECOMP_IPP_HPP__

hal/ipp/src/transforms_ipp.cpp

@@ -3,6 +3,7 @@
 // of this distribution and at http://opencv.org/license.html
 
 #include "ipp_hal_core.hpp"
+#include "precomp_ipp.hpp"
 
 #include <opencv2/core.hpp>
 #include <opencv2/core/base.hpp>
@@ -72,19 +73,6 @@ int ipp_hal_transpose2d(const uchar* src_data, size_t src_step, uchar* dst_data,
 
 #ifdef HAVE_IPP_IW
 
-static inline IppDataType ippiGetDataType(int depth)
-{
-    depth = CV_MAT_DEPTH(depth);
-    return depth == CV_8U ? ipp8u :
-    depth == CV_8S ? ipp8s :
-    depth == CV_16U ? ipp16u :
-    depth == CV_16S ? ipp16s :
-    depth == CV_32S ? ipp32s :
-    depth == CV_32F ? ipp32f :
-    depth == CV_64F ? ipp64f :
-    (IppDataType)-1;
-}
-
 static inline ::ipp::IwiImage ippiGetImage(int src_type, const uchar* src_data, size_t src_step, int src_width, int src_height)
 {
     ::ipp::IwiImage dst;

hal/ipp/src/warp_ipp.cpp

@@ -0,0 +1,488 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "ipp_hal_imgproc.hpp"
+
+#include <opencv2/core.hpp>
+#include <opencv2/core/base.hpp>
+#include "precomp_ipp.hpp"
+
+#ifdef HAVE_IPP_IW
+#include "iw++/iw.hpp"
+#endif
+
+#define IPP_WARPAFFINE_PARALLEL 1
+#define CV_TYPE(src_type) (src_type & (CV_DEPTH_MAX - 1))
+#ifdef HAVE_IPP_IW
+
+class ipp_warpAffineParallel: public cv::ParallelLoopBody
+{
+public:
+    ipp_warpAffineParallel(::ipp::IwiImage &src, ::ipp::IwiImage &dst, IppiInterpolationType _inter, double (&_coeffs)[2][3], ::ipp::IwiBorderType _borderType, IwTransDirection _iwTransDirection, bool *_ok):m_src(src), m_dst(dst)
+    {
+        pOk = _ok;
+
+        inter          = _inter;
+        borderType     = _borderType;
+        iwTransDirection = _iwTransDirection;
+
+        for( int i = 0; i < 2; i++ )
+            for( int j = 0; j < 3; j++ )
+                coeffs[i][j] = _coeffs[i][j];
+
+        *pOk = true;
+    }
+    ~ipp_warpAffineParallel() {}
+
+    virtual void operator() (const cv::Range& range) const CV_OVERRIDE
+    {
+        //CV_INSTRUMENT_REGION_IPP();
+
+        if(*pOk == false)
+            return;
+
+        try
+        {
+            ::ipp::IwiTile tile = ::ipp::IwiRoi(0, range.start, m_dst.m_size.width, range.end - range.start);
+            CV_INSTRUMENT_FUN_IPP(::ipp::iwiWarpAffine, m_src, m_dst, coeffs, iwTransDirection, inter, ::ipp::IwiWarpAffineParams(), borderType, tile);
+        }
+        catch(const ::ipp::IwException &)
+        {
+            *pOk = false;
+            return;
+        }
+    }
+private:
+    ::ipp::IwiImage &m_src;
+    ::ipp::IwiImage &m_dst;
+
+    IppiInterpolationType inter;
+    double coeffs[2][3];
+    ::ipp::IwiBorderType borderType;
+    IwTransDirection iwTransDirection;
+
+    bool  *pOk;
+    const ipp_warpAffineParallel& operator= (const ipp_warpAffineParallel&);
+};
+
+#if (IPP_VERSION_X100 >= 700)
+int ipp_hal_warpAffine(int src_type, const uchar *src_data, size_t src_step, int src_width, int src_height, uchar *dst_data, size_t dst_step, int dst_width,
+                              int dst_height, const double M[6], int interpolation, int borderType, const double borderValue[4])
+{
+    //CV_INSTRUMENT_REGION_IPP();
+
+    IppiInterpolationType ippInter    = ippiGetInterpolation(interpolation);
+    if((int)ippInter < 0 || interpolation > 2)
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
+
+                                     /* C1         C2         C3         C4 */
+    char impl[CV_DEPTH_MAX][4][3]={{{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}},   //8U
+                                   {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}},   //8S
+                                   {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {1, 0, 0}},   //16U
+                                   {{1, 0, 0}, {0, 0, 0}, {1, 0, 0}, {1, 0, 0}},   //16S
+                                   {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}},   //32S
+                                   {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}},   //32F
+                                   {{1, 0, 0}, {0, 0, 0}, {1, 0, 0}, {1, 0, 0}}};  //64F
+
+    if(impl[CV_TYPE(src_type)][CV_MAT_CN(src_type)-1][interpolation] == 0)
+    {
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
+    }
+
+    // Acquire data and begin processing
+    try
+    {
+        ::ipp::IwiImage        iwSrc;
+        iwSrc.Init({src_width, src_height}, ippiGetDataType(src_type), CV_MAT_CN(src_type), NULL, src_data, IwSize(src_step));
+        ::ipp::IwiImage        iwDst({dst_width, dst_height}, ippiGetDataType(src_type), CV_MAT_CN(src_type), NULL, dst_data, dst_step);
+        ::ipp::IwiBorderType   ippBorder(ippiGetBorderType(borderType), {borderValue[0], borderValue[1], borderValue[2], borderValue[3]});
+        IwTransDirection       iwTransDirection = iwTransForward;
+
+        if((int)ippBorder == -1)
+            return CV_HAL_ERROR_NOT_IMPLEMENTED;
+
+        double coeffs[2][3];
+        for( int i = 0; i < 2; i++ )
+            for( int j = 0; j < 3; j++ )
+                coeffs[i][j] = M[i*3 + j];
+
+        const int threads = ippiSuggestThreadsNum(iwDst, 2);
+
+        if(IPP_WARPAFFINE_PARALLEL && threads > 1)
+        {
+            bool  ok      = true;
+            cv::Range range(0, (int)iwDst.m_size.height);
+            ipp_warpAffineParallel invoker(iwSrc, iwDst, ippInter, coeffs, ippBorder, iwTransDirection, &ok);
+            if(!ok)
+                return CV_HAL_ERROR_NOT_IMPLEMENTED;
+
+            parallel_for_(range, invoker, threads*4);
+
+            if(!ok)
+                return CV_HAL_ERROR_NOT_IMPLEMENTED;
+        } else {
+            CV_INSTRUMENT_FUN_IPP(::ipp::iwiWarpAffine, iwSrc, iwDst, coeffs, iwTransDirection, ippInter, ::ipp::IwiWarpAffineParams(), ippBorder);
+        }
+    }
+    catch (const ::ipp::IwException &)
+    {
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
+    }
+
+    return CV_HAL_ERROR_OK;
+}
+#endif
+#endif
+
+typedef IppStatus (CV_STDCALL* ippiSetFunc)(const void*, void *, int, IppiSize);
+
+template <int channels, typename Type>
+bool IPPSetSimple(const double value[4], void *dataPointer, int step, IppiSize &size, ippiSetFunc func)
+{
+    //CV_INSTRUMENT_REGION_IPP();
+
+    Type values[channels];
+    for( int i = 0; i < channels; i++ )
+        values[i] = cv::saturate_cast<Type>(value[i]);
+    return CV_INSTRUMENT_FUN_IPP(func, values, dataPointer, step, size) >= 0;
+}
+
+static bool IPPSet(const double value[4], void *dataPointer, int step, IppiSize &size, int channels, int depth)
+{
+    //CV_INSTRUMENT_REGION_IPP();
+
+    if( channels == 1 )
+    {
+        switch( depth )
+        {
+        case CV_8U:
+            return CV_INSTRUMENT_FUN_IPP(ippiSet_8u_C1R, cv::saturate_cast<Ipp8u>(value[0]), (Ipp8u *)dataPointer, step, size) >= 0;
+        case CV_16U:
+            return CV_INSTRUMENT_FUN_IPP(ippiSet_16u_C1R, cv::saturate_cast<Ipp16u>(value[0]), (Ipp16u *)dataPointer, step, size) >= 0;
+        case CV_32F:
+            return CV_INSTRUMENT_FUN_IPP(ippiSet_32f_C1R, cv::saturate_cast<Ipp32f>(value[0]), (Ipp32f *)dataPointer, step, size) >= 0;
+        }
+    }
+    else
+    {
+        if( channels == 3 )
+        {
+            switch( depth )
+            {
+            case CV_8U:
+                return IPPSetSimple<3, Ipp8u>(value, dataPointer, step, size, (ippiSetFunc)ippiSet_8u_C3R);
+            case CV_16U:
+                return IPPSetSimple<3, Ipp16u>(value, dataPointer, step, size, (ippiSetFunc)ippiSet_16u_C3R);
+            case CV_32F:
+                return IPPSetSimple<3, Ipp32f>(value, dataPointer, step, size, (ippiSetFunc)ippiSet_32f_C3R);
+            }
+        }
+        else if( channels == 4 )
+        {
+            switch( depth )
+            {
+            case CV_8U:
+                return IPPSetSimple<4, Ipp8u>(value, dataPointer, step, size, (ippiSetFunc)ippiSet_8u_C4R);
+            case CV_16U:
+                return IPPSetSimple<4, Ipp16u>(value, dataPointer, step, size, (ippiSetFunc)ippiSet_16u_C4R);
+            case CV_32F:
+                return IPPSetSimple<4, Ipp32f>(value, dataPointer, step, size, (ippiSetFunc)ippiSet_32f_C4R);
+            }
+        }
+    }
+    return false;
+}
+
+#if (IPP_VERSION_X100 >= 810)
+typedef IppStatus (CV_STDCALL* ippiWarpPerspectiveFunc)(const Ipp8u*, int, Ipp8u*, int,IppiPoint, IppiSize, const IppiWarpSpec*,Ipp8u*);
+
+class IPPWarpPerspectiveInvoker :
+    public cv::ParallelLoopBody
+{
+public:
+    IPPWarpPerspectiveInvoker(int _src_type, cv::Mat &_src, size_t _src_step, cv::Mat &_dst, size_t _dst_step, IppiInterpolationType _interpolation,
+                              double (&_coeffs)[3][3], int &_borderType, const double _borderValue[4], ippiWarpPerspectiveFunc _func,
+                              bool *_ok) :
+        ParallelLoopBody(), src_type(_src_type), src(_src), src_step(_src_step), dst(_dst), dst_step(_dst_step), inter(_interpolation), coeffs(_coeffs),
+        borderType(_borderType), func(_func), ok(_ok)
+    {
+        memcpy(this->borderValue, _borderValue, sizeof(this->borderValue));
+        *ok = true;
+    }
+
+    virtual void operator() (const cv::Range& range) const CV_OVERRIDE
+    {
+        //CV_INSTRUMENT_REGION_IPP();
+        IppiWarpSpec* pSpec = 0;
+        int specSize = 0, initSize = 0, bufSize = 0; Ipp8u* pBuffer  = 0;
+        IppiPoint dstRoiOffset = {0, 0};
+        IppiWarpDirection direction = ippWarpBackward;  //fixed for IPP
+        const Ipp32u numChannels = CV_MAT_CN(src_type);
+
+        IppiSize srcsize = {src.cols, src.rows};
+        IppiSize dstsize = {dst.cols, dst.rows};
+        IppiRect srcroi = {0, 0, src.cols, src.rows};
+
+        /* Spec and init buffer sizes */
+        IppStatus status = ippiWarpPerspectiveGetSize(srcsize, srcroi, dstsize, ippiGetDataType(src_type), coeffs, inter, ippWarpBackward, ippiGetBorderType(borderType), &specSize, &initSize);
+
+        pSpec = (IppiWarpSpec*)ippMalloc_L(specSize);
+
+        if (inter == ippLinear)
+        {
+            status = ippiWarpPerspectiveLinearInit(srcsize, srcroi, dstsize, ippiGetDataType(src_type), coeffs, direction, numChannels, ippiGetBorderType(borderType),
+                                            borderValue, 0, pSpec);
+        } else
+        {
+            status = ippiWarpPerspectiveNearestInit(srcsize, srcroi, dstsize, ippiGetDataType(src_type), coeffs, direction, numChannels, ippiGetBorderType(borderType),
+                                            borderValue, 0, pSpec);
+        }
+
+        status = ippiWarpGetBufferSize(pSpec, dstsize, &bufSize);
+        pBuffer = (Ipp8u*)ippMalloc_L(bufSize);
+        IppiSize dstRoiSize = dstsize;
+
+        int cnn = src.channels();
+
+        if( borderType == cv::BorderTypes::BORDER_CONSTANT )
+        {
+            IppiSize setSize = {dst.cols, range.end - range.start};
+            void *dataPointer = dst.ptr(range.start);
+            if( !IPPSet( borderValue, dataPointer, (int)dst.step[0], setSize, cnn, src.depth() ) )
+            {
+                *ok = false;
+                ippsFree(pBuffer);
+                ippsFree(pSpec);
+                return;
+            }
+        }
+
+        status = CV_INSTRUMENT_FUN_IPP(func, src.ptr(), (int)src_step, dst.ptr(), (int)dst_step, dstRoiOffset, dstRoiSize, pSpec, pBuffer);
+        if (status != ippStsNoErr)
+            *ok = false;
+        else
+        {
+            CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
+        }
+        ippsFree(pBuffer);
+        ippsFree(pSpec);
+    }
+private:
+    int src_type;
+    cv::Mat &src;
+    size_t src_step;
+    cv::Mat &dst;
+    size_t dst_step;
+    IppiInterpolationType inter;
+    double (&coeffs)[3][3];
+    int borderType;
+    double borderValue[4];
+    ippiWarpPerspectiveFunc func;
+    bool *ok;
+
+    const IPPWarpPerspectiveInvoker& operator= (const IPPWarpPerspectiveInvoker&);
+};
+
+int ipp_hal_warpPerspective(int src_type, const uchar *src_data, size_t src_step, int src_width, int src_height, uchar * dst_data, size_t dst_step,
+                            int dst_width, int dst_height, const double M[9], int interpolation, int borderType, const double borderValue[4])
+{
+    //CV_INSTRUMENT_REGION_IPP();
+    ippiWarpPerspectiveFunc ippFunc = 0;
+    if (interpolation == cv::InterpolationFlags::INTER_NEAREST)
+    {
+        ippFunc = src_type == CV_8UC1 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveNearest_8u_C1R :
+        src_type == CV_8UC3 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveNearest_8u_C3R :
+        src_type == CV_8UC4 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveNearest_8u_C4R :
+        src_type == CV_16UC1 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveNearest_16u_C1R :
+        src_type == CV_16UC3 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveNearest_16u_C3R :
+        src_type == CV_16UC4 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveNearest_16u_C4R :
+        src_type == CV_16SC1 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveNearest_16s_C1R :
+        src_type == CV_16SC3 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveNearest_16s_C3R :
+        src_type == CV_16SC4 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveNearest_16s_C4R :
+        src_type == CV_32FC1 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveNearest_32f_C1R :
+        src_type == CV_32FC3 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveNearest_32f_C3R :
+        src_type == CV_32FC4 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveNearest_32f_C4R : 0;
+    }
+    else if (interpolation == cv::InterpolationFlags::INTER_LINEAR)
+    {
+        ippFunc = src_type == CV_8UC1 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveLinear_8u_C1R :
+        src_type == CV_8UC3 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveLinear_8u_C3R :
+        src_type == CV_8UC4 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveLinear_8u_C4R :
+        src_type == CV_16UC1 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveLinear_16u_C1R :
+        src_type == CV_16UC3 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveLinear_16u_C3R :
+        src_type == CV_16UC4 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveLinear_16u_C4R :
+        src_type == CV_16SC1 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveLinear_16s_C1R :
+        src_type == CV_16SC3 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveLinear_16s_C3R :
+        src_type == CV_16SC4 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveLinear_16s_C4R :
+        src_type == CV_32FC1 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveLinear_32f_C1R :
+        src_type == CV_32FC3 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveLinear_32f_C3R :
+        src_type == CV_32FC4 ? (ippiWarpPerspectiveFunc)ippiWarpPerspectiveLinear_32f_C4R : 0;
+    }
+    else
+    {
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
+    }
+
+    if(src_height == 1 || src_width == 1) return CV_HAL_ERROR_NOT_IMPLEMENTED;
+
+    int mode =
+    interpolation == cv::InterpolationFlags::INTER_NEAREST ? IPPI_INTER_NN :
+    interpolation == cv::InterpolationFlags::INTER_LINEAR ? IPPI_INTER_LINEAR : 0;
+
+    if (mode == 0 || ippFunc == 0)
+    {
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
+    }
+
+                                    /* C1      C2      C3      C4 */
+    char impl[CV_DEPTH_MAX][4][2]={{{0, 0}, {1, 1}, {0, 0}, {0, 0}},   //8U
+                                   {{1, 1}, {1, 1}, {1, 1}, {1, 1}},   //8S
+                                   {{0, 0}, {1, 1}, {0, 1}, {0, 1}},   //16U
+                                   {{1, 1}, {1, 1}, {1, 1}, {1, 1}},   //16S
+                                   {{1, 1}, {1, 1}, {1, 0}, {1, 1}},   //32S
+                                   {{1, 0}, {1, 0}, {0, 0}, {1, 0}},   //32F
+                                   {{1, 1}, {1, 1}, {1, 1}, {1, 1}}};  //64F
+
+    if(impl[CV_TYPE(src_type)][CV_MAT_CN(src_type)-1][interpolation] == 0)
+    {
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
+    }
+
+    double coeffs[3][3];
+    for( int i = 0; i < 3; i++ )
+        for( int j = 0; j < 3; j++ )
+            coeffs[i][j] = M[i*3 + j];
+
+    bool ok;
+    cv::Range range(0, dst_height);
+    cv::Mat src(cv::Size(src_width, src_height), src_type, const_cast<uchar*>(src_data), src_step);
+    cv::Mat dst(cv::Size(dst_width, dst_height), src_type, dst_data, dst_step);
+    IppiInterpolationType ippInter    = ippiGetInterpolation(interpolation);
+    IPPWarpPerspectiveInvoker invoker(src_type, src, src_step, dst, dst_step, ippInter, coeffs, borderType, borderValue, ippFunc, &ok);
+    parallel_for_(range, invoker, dst.total()/(double)(1<<16));
+
+    if( ok )
+    {
+        CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
+    }
+    return CV_HAL_ERROR_OK;
+}
+#endif
+
+typedef IppStatus(CV_STDCALL *ippiRemap)(const void *pSrc, IppiSize srcSize, int srcStep, IppiRect srcRoi,
+                                         const Ipp32f *pxMap, int xMapStep, const Ipp32f *pyMap, int yMapStep,
+                                         void *pDst, int dstStep, IppiSize dstRoiSize, int interpolation);
+
+class IPPRemapInvoker : public cv::ParallelLoopBody
+{
+public:
+    IPPRemapInvoker(int _src_type, const uchar *_src_data, size_t _src_step, int _src_width, int _src_height,
+                    uchar *_dst_data, size_t _dst_step, int _dst_width, float *_mapx, size_t _mapx_step, float *_mapy,
+                    size_t _mapy_step, ippiRemap _ippFunc, int _ippInterpolation, int _borderType, const double _borderValue[4], bool *_ok) :
+        ParallelLoopBody(),
+        src_type(_src_type), src(_src_data), src_step(_src_step), src_width(_src_width), src_height(_src_height),
+        dst(_dst_data), dst_step(_dst_step), dst_width(_dst_width), mapx(_mapx), mapx_step(_mapx_step), mapy(_mapy),
+        mapy_step(_mapy_step), ippFunc(_ippFunc), ippInterpolation(_ippInterpolation), borderType(_borderType), ok(_ok)
+    {
+        memcpy(this->borderValue, _borderValue, sizeof(this->borderValue));
+        *ok = true;
+    }
+
+    virtual void operator()(const cv::Range &range) const
+    {
+        IppiRect srcRoiRect = {0, 0, src_width, src_height};
+        uchar *dst_roi_data = dst + range.start * dst_step;
+        IppiSize dstRoiSize = ippiSize(dst_width, range.size());
+        int depth = CV_MAT_DEPTH(src_type), cn = CV_MAT_CN(src_type);
+
+        if (borderType == cv::BORDER_CONSTANT &&
+            !IPPSet(borderValue, dst_roi_data, (int)dst_step, dstRoiSize, cn, depth))
+        {
+            *ok = false;
+            return;
+        }
+
+        if (CV_INSTRUMENT_FUN_IPP(ippFunc, src, {src_width, src_height}, (int)src_step, srcRoiRect,
+                                  mapx, (int)mapx_step, mapy, (int)mapy_step,
+                                  dst_roi_data, (int)dst_step, dstRoiSize, ippInterpolation) < 0)
+            *ok = false;
+        else
+        {
+            CV_IMPL_ADD(CV_IMPL_IPP | CV_IMPL_MT);
+        }
+    }
+
+private:
+    int src_type;
+    const uchar *src;
+    size_t src_step;
+    int src_width, src_height;
+    uchar *dst;
+    size_t dst_step;
+    int dst_width;
+    float *mapx;
+    size_t mapx_step;
+    float *mapy;
+    size_t mapy_step;
+    ippiRemap ippFunc;
+    int ippInterpolation, borderType;
+    double borderValue[4];
+    bool *ok;
+};
+
+int ipp_hal_remap32f(int src_type, const uchar *src_data, size_t src_step, int src_width, int src_height,
+                     uchar *dst_data, size_t dst_step, int dst_width, int dst_height,
+                     float *mapx, size_t mapx_step, float *mapy, size_t mapy_step,
+                     int interpolation, int border_type, const double border_value[4])
+{
+    if ((interpolation == cv::INTER_LINEAR || interpolation == cv::INTER_CUBIC || interpolation == cv::INTER_NEAREST) &&
+        (border_type == cv::BORDER_CONSTANT || border_type == cv::BORDER_TRANSPARENT))
+    {
+        int ippInterpolation =
+            interpolation == cv::INTER_NEAREST ? IPPI_INTER_NN : interpolation == cv::INTER_LINEAR ? IPPI_INTER_LINEAR
+                                                                                                   : IPPI_INTER_CUBIC;
+
+                                         /* C1         C2         C3         C4 */
+        char impl[CV_DEPTH_MAX][4][3]={{{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}},   //8U
+                                       {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}},   //8S
+                                       {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}},   //16U
+                                       {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}},   //16S
+                                       {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}},   //32S
+                                       {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}},   //32F
+                                       {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}}};  //64F
+
+        if (impl[CV_TYPE(src_type)][CV_MAT_CN(src_type) - 1][interpolation] == 0)
+        {
+            return CV_HAL_ERROR_NOT_IMPLEMENTED;
+        }
+
+        ippiRemap ippFunc =
+            src_type == CV_8UC1 ? (ippiRemap)ippiRemap_8u_C1R : src_type == CV_8UC3 ? (ippiRemap)ippiRemap_8u_C3R
+                                                            : src_type == CV_8UC4   ? (ippiRemap)ippiRemap_8u_C4R
+                                                            : src_type == CV_16UC1  ? (ippiRemap)ippiRemap_16u_C1R
+                                                            : src_type == CV_16UC3  ? (ippiRemap)ippiRemap_16u_C3R
+                                                            : src_type == CV_16UC4  ? (ippiRemap)ippiRemap_16u_C4R
+                                                            : src_type == CV_32FC1  ? (ippiRemap)ippiRemap_32f_C1R
+                                                            : src_type == CV_32FC3  ? (ippiRemap)ippiRemap_32f_C3R
+                                                            : src_type == CV_32FC4  ? (ippiRemap)ippiRemap_32f_C4R
+                                                                                    : 0;
+
+        if (ippFunc)
+        {
+            bool ok;
+
+            IPPRemapInvoker invoker(src_type, src_data, src_step, src_width, src_height, dst_data, dst_step, dst_width,
+                                    mapx, mapx_step, mapy, mapy_step, ippFunc, ippInterpolation, border_type, border_value, &ok);
+            cv::Range range(0, dst_height);
+            cv::parallel_for_(range, invoker, dst_width * dst_height / (double)(1 << 16));
+
+            if (ok)
+            {
+                CV_IMPL_ADD(CV_IMPL_IPP | CV_IMPL_MT);
+                return CV_HAL_ERROR_OK;
+            }
+        }
+    }
+    return CV_HAL_ERROR_NOT_IMPLEMENTED;
+}

hal/kleidicv/kleidicv.cmake

@@ -1,8 +1,8 @@
 function(download_kleidicv root_var)
   set(${root_var} "" PARENT_SCOPE)
 
-  ocv_update(KLEIDICV_SRC_COMMIT "0.3.0")
-  ocv_update(KLEIDICV_SRC_HASH "51a77b0185c2bac2a968a2163869b1ed")
+  ocv_update(KLEIDICV_SRC_COMMIT "0.5.0")
+  ocv_update(KLEIDICV_SRC_HASH "ba5648f8df678548f337d19d8ac607d6")
 
   set(THE_ROOT "${OpenCV_BINARY_DIR}/3rdparty/kleidicv")
   ocv_download(FILENAME "kleidicv-${KLEIDICV_SRC_COMMIT}.tar.gz"

hal/riscv-rvv/include/imgproc.hpp

@@ -238,8 +238,10 @@ int integral(int depth, int sdepth, int sqdepth,
              uchar* tilted_data, [[maybe_unused]] size_t tilted_step,
              int width, int height, int cn);
 
-#undef cv_hal_integral
-#define cv_hal_integral cv::rvv_hal::imgproc::integral
+// Diasbled due to accuracy issue.
+// Details see https://github.com/opencv/opencv/issues/27407.
+//#undef cv_hal_integral
+//#define cv_hal_integral cv::rvv_hal::imgproc::integral
 
 #endif // CV_HAL_RVV_1P0_ENABLED