Merge pull request #8455 from terfendail:ovxhal_skipsmall

3rdparty/openvx/hal/openvx_hal.cpp

@@ -81,6 +81,15 @@ inline bool dimTooBig(int size)
         return false;
 }
 
+//OpenVX calls have essential overhead so it make sense to skip them for small images
+template <int kernel_id> inline bool                  skipSmallImages(int w, int h) { return w*h < 7680 * 4320; }
+template <> inline bool           skipSmallImages<VX_KERNEL_MULTIPLY>(int w, int h) { return w*h <  640 *  480; }
+template <> inline bool      skipSmallImages<VX_KERNEL_COLOR_CONVERT>(int w, int h) { return w*h < 2048 * 1536; }
+template <> inline bool     skipSmallImages<VX_KERNEL_INTEGRAL_IMAGE>(int w, int h) { return w*h <  640 *  480; }
+template <> inline bool        skipSmallImages<VX_KERNEL_WARP_AFFINE>(int w, int h) { return w*h < 1280 *  720; }
+template <> inline bool   skipSmallImages<VX_KERNEL_WARP_PERSPECTIVE>(int w, int h) { return w*h <  320 *  240; }
+template <> inline bool skipSmallImages<VX_KERNEL_CUSTOM_CONVOLUTION>(int w, int h) { return w*h <  320 *  240; }
+
 inline void setConstantBorder(ivx::border_t &border, vx_uint8 val)
 {
     border.mode = VX_BORDER_CONSTANT;
@@ -122,10 +131,12 @@ public:
 // real code starts here
 // ...
 
-#define OVX_BINARY_OP(hal_func, ovx_call)                                                                           \
+#define OVX_BINARY_OP(hal_func, ovx_call, kernel_id)                                                                \
 template <typename T>                                                                                               \
 int ovx_hal_##hal_func(const T *a, size_t astep, const T *b, size_t bstep, T *c, size_t cstep, int w, int h)        \
 {                                                                                                                   \
+    if(skipSmallImages<kernel_id>(w, h))                                                                            \
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;                                                                        \
     if(dimTooBig(w) || dimTooBig(h))                                                                                \
         return CV_HAL_ERROR_NOT_IMPLEMENTED;                                                                        \
     refineStep(w, h, ivx::TypeToEnum<T>::imgType, astep);                                                           \
@@ -156,18 +167,22 @@ int ovx_hal_##hal_func(const T *a, size_t astep, const T *b, size_t bstep, T *c,
     return CV_HAL_ERROR_OK;                                                                                         \
 }
 
-OVX_BINARY_OP(add, { ivx::IVX_CHECK_STATUS(vxuAdd(ctx, ia, ib, VX_CONVERT_POLICY_SATURATE, ic)); })
+OVX_BINARY_OP(add, { ivx::IVX_CHECK_STATUS(vxuAdd(ctx, ia, ib, VX_CONVERT_POLICY_SATURATE, ic)); }, VX_KERNEL_ADD)
-OVX_BINARY_OP(sub, { ivx::IVX_CHECK_STATUS(vxuSubtract(ctx, ia, ib, VX_CONVERT_POLICY_SATURATE, ic)); })
+OVX_BINARY_OP(sub, { ivx::IVX_CHECK_STATUS(vxuSubtract(ctx, ia, ib, VX_CONVERT_POLICY_SATURATE, ic)); }, VX_KERNEL_SUBTRACT)
 
-OVX_BINARY_OP(absdiff, { ivx::IVX_CHECK_STATUS(vxuAbsDiff(ctx, ia, ib, ic)); })
+OVX_BINARY_OP(absdiff, { ivx::IVX_CHECK_STATUS(vxuAbsDiff(ctx, ia, ib, ic)); }, VX_KERNEL_ABSDIFF)
 
-OVX_BINARY_OP(and, { ivx::IVX_CHECK_STATUS(vxuAnd(ctx, ia, ib, ic)); })
+OVX_BINARY_OP(and, { ivx::IVX_CHECK_STATUS(vxuAnd(ctx, ia, ib, ic)); }, VX_KERNEL_AND)
-OVX_BINARY_OP(or , { ivx::IVX_CHECK_STATUS(vxuOr(ctx, ia, ib, ic)); })
+OVX_BINARY_OP(or , { ivx::IVX_CHECK_STATUS(vxuOr(ctx, ia, ib, ic)); }, VX_KERNEL_OR)
-OVX_BINARY_OP(xor, { ivx::IVX_CHECK_STATUS(vxuXor(ctx, ia, ib, ic)); })
+OVX_BINARY_OP(xor, { ivx::IVX_CHECK_STATUS(vxuXor(ctx, ia, ib, ic)); }, VX_KERNEL_XOR)
 
 template <typename T>
 int ovx_hal_mul(const T *a, size_t astep, const T *b, size_t bstep, T *c, size_t cstep, int w, int h, double scale)
 {
+    if(scale == 1.0 || sizeof(T) > 1 ?
+       skipSmallImages<VX_KERNEL_ADD>(w, h) : /*actually it could be any kernel with generic minimum size*/
+       skipSmallImages<VX_KERNEL_MULTIPLY>(w, h) )
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (dimTooBig(w) || dimTooBig(h))
         return CV_HAL_ERROR_NOT_IMPLEMENTED;
     refineStep(w, h, ivx::TypeToEnum<T>::imgType, astep);
@@ -234,6 +249,8 @@ template int ovx_hal_mul<short>(const short *a, size_t astep, const short *b, si
 
 int ovx_hal_not(const uchar *a, size_t astep, uchar *c, size_t cstep, int w, int h)
 {
+    if (skipSmallImages<VX_KERNEL_NOT>(w, h))
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (dimTooBig(w) || dimTooBig(h))
         return CV_HAL_ERROR_NOT_IMPLEMENTED;
     refineStep(w, h, VX_DF_IMAGE_U8, astep);
@@ -263,6 +280,8 @@ int ovx_hal_not(const uchar *a, size_t astep, uchar *c, size_t cstep, int w, int
 
 int ovx_hal_merge8u(const uchar **src_data, uchar *dst_data, int len, int cn)
 {
+    if (skipSmallImages<VX_KERNEL_CHANNEL_COMBINE>(len, 1))
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (dimTooBig(len))
         return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (cn != 3 && cn != 4)
@@ -299,6 +318,8 @@ 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)
 {
+    if (skipSmallImages<VX_KERNEL_SCALE_IMAGE>(aw, ah))
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (dimTooBig(aw) || dimTooBig(ah) || dimTooBig(bw) || dimTooBig(bh))
         return CV_HAL_ERROR_NOT_IMPLEMENTED;
     refineStep(aw, ah, VX_DF_IMAGE_U8, astep);
@@ -350,6 +371,8 @@ int ovx_hal_resize(int atype, const uchar *a, size_t astep, int aw, int ah, ucha
 
 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])
 {
+    if (skipSmallImages<VX_KERNEL_WARP_AFFINE>(aw, ah))
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (dimTooBig(aw) || dimTooBig(ah) || dimTooBig(bw) || dimTooBig(bh))
         return CV_HAL_ERROR_NOT_IMPLEMENTED;
     refineStep(aw, ah, VX_DF_IMAGE_U8, astep);
@@ -410,6 +433,8 @@ int ovx_hal_warpAffine(int atype, const uchar *a, size_t astep, int aw, int ah,
 
 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])
 {
+    if (skipSmallImages<VX_KERNEL_WARP_PERSPECTIVE>(aw, ah))
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (dimTooBig(aw) || dimTooBig(ah) || dimTooBig(bw) || dimTooBig(bh))
         return CV_HAL_ERROR_NOT_IMPLEMENTED;
     refineStep(aw, ah, VX_DF_IMAGE_U8, astep);
@@ -531,6 +556,7 @@ int ovx_hal_filterInit(cvhalFilter2D **filter_context, uchar *kernel_data, size_
             for (int i = 0; i < kernel_width; ++i)
                 data.push_back(row[i]);
         }
+        break;
     default:
         return CV_HAL_ERROR_NOT_IMPLEMENTED;
     }
@@ -558,6 +584,8 @@ int ovx_hal_filterFree(cvhalFilter2D *filter_context)
 
 int ovx_hal_filter(cvhalFilter2D *filter_context, uchar *a, size_t astep, uchar *b, size_t bstep, int w, int h, int, int, int, int)
 {
+    if (skipSmallImages<VX_KERNEL_CUSTOM_CONVOLUTION>(w, h))
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (dimTooBig(w) || dimTooBig(h))
         return CV_HAL_ERROR_NOT_IMPLEMENTED;
     try
@@ -782,6 +810,8 @@ int ovx_hal_morphFree(cvhalFilter2D *filter_context)
 
 int ovx_hal_morph(cvhalFilter2D *filter_context, uchar *a, size_t astep, uchar *b, size_t bstep, int w, int h, int, int, int, int, int, int, int, int)
 {
+    if (skipSmallImages<VX_KERNEL_DILATE_3x3>(w, h))//Actually it make sense to separate checks if implementations of dilation and erosion have different performance gain
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (dimTooBig(w) || dimTooBig(h))
         return CV_HAL_ERROR_NOT_IMPLEMENTED;
     refineStep(w, h, VX_DF_IMAGE_U8, astep);
@@ -823,6 +853,8 @@ int ovx_hal_morph(cvhalFilter2D *filter_context, uchar *a, size_t astep, uchar *
 
 int ovx_hal_cvtBGRtoBGR(const uchar * a, size_t astep, uchar * b, size_t bstep, int w, int h, int depth, int acn, int bcn, bool swapBlue)
 {
+    if (skipSmallImages<VX_KERNEL_COLOR_CONVERT>(w, h))
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (dimTooBig(w) || dimTooBig(h))
         return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (depth != CV_8U || swapBlue || acn == bcn || (acn != 3 && acn != 4) || (bcn != 3 && bcn != 4))
@@ -857,6 +889,8 @@ int ovx_hal_cvtBGRtoBGR(const uchar * a, size_t astep, uchar * b, size_t bstep,
 
 int ovx_hal_cvtGraytoBGR(const uchar * a, size_t astep, uchar * b, size_t bstep, int w, int h, int depth, int bcn)
 {
+    if (skipSmallImages<VX_KERNEL_CHANNEL_COMBINE>(w, h))
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (dimTooBig(w) || dimTooBig(h))
         return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (depth != CV_8U || (bcn != 3 && bcn != 4))
@@ -890,6 +924,8 @@ int ovx_hal_cvtGraytoBGR(const uchar * a, size_t astep, uchar * b, size_t bstep,
 
 int ovx_hal_cvtTwoPlaneYUVtoBGR(const uchar * a, size_t astep, uchar * b, size_t bstep, int w, int h, int bcn, bool swapBlue, int uIdx)
 {
+    if (skipSmallImages<VX_KERNEL_COLOR_CONVERT>(w, h))
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (dimTooBig(w) || dimTooBig(h))
         return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (!swapBlue || (bcn != 3 && bcn != 4))
@@ -934,6 +970,8 @@ int ovx_hal_cvtTwoPlaneYUVtoBGR(const uchar * a, size_t astep, uchar * b, size_t
 
 int ovx_hal_cvtThreePlaneYUVtoBGR(const uchar * a, size_t astep, uchar * b, size_t bstep, int w, int h, int bcn, bool swapBlue, int uIdx)
 {
+    if (skipSmallImages<VX_KERNEL_COLOR_CONVERT>(w, h))
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (dimTooBig(w) || dimTooBig(h))
         return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (!swapBlue || (bcn != 3 && bcn != 4) || uIdx || (size_t)w / 2 != astep - (size_t)w / 2)
@@ -982,6 +1020,8 @@ int ovx_hal_cvtThreePlaneYUVtoBGR(const uchar * a, size_t astep, uchar * b, size
 
 int ovx_hal_cvtBGRtoThreePlaneYUV(const uchar * a, size_t astep, uchar * b, size_t bstep, int w, int h, int acn, bool swapBlue, int uIdx)
 {
+    if (skipSmallImages<VX_KERNEL_COLOR_CONVERT>(w, h))
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (dimTooBig(w) || dimTooBig(h))
         return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (!swapBlue || (acn != 3 && acn != 4) || uIdx || (size_t)w / 2 != bstep - (size_t)w / 2)
@@ -1028,6 +1068,8 @@ int ovx_hal_cvtBGRtoThreePlaneYUV(const uchar * a, size_t astep, uchar * b, size
 
 int ovx_hal_cvtOnePlaneYUVtoBGR(const uchar * a, size_t astep, uchar * b, size_t bstep, int w, int h, int bcn, bool swapBlue, int uIdx, int ycn)
 {
+    if (skipSmallImages<VX_KERNEL_COLOR_CONVERT>(w, h))
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (dimTooBig(w) || dimTooBig(h))
         return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (!swapBlue || (bcn != 3 && bcn != 4) || uIdx)
@@ -1065,6 +1107,8 @@ int ovx_hal_cvtOnePlaneYUVtoBGR(const uchar * a, size_t astep, uchar * b, size_t
 
 int ovx_hal_integral(int depth, int sdepth, int, const uchar * a, size_t astep, uchar * b, size_t bstep, uchar * c, size_t, uchar * d, size_t, int w, int h, int cn)
 {
+    if (skipSmallImages<VX_KERNEL_INTEGRAL_IMAGE>(w, h))
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
     if (depth != CV_8U || sdepth != CV_32S || c != NULL || d != NULL || cn != 1)
         return CV_HAL_ERROR_NOT_IMPLEMENTED;
     refineStep(w, h, VX_DF_IMAGE_U8, astep);

3rdparty/openvx/hal/openvx_hal.hpp

@@ -106,12 +106,12 @@ int ovx_hal_integral(int depth, int sdepth, int, const uchar * a, size_t astep,
 #undef cv_hal_filterFree
 #define cv_hal_filterFree ovx_hal_filterFree
 
-#undef cv_hal_sepFilterInit
+//#undef cv_hal_sepFilterInit
-#define cv_hal_sepFilterInit ovx_hal_sepFilterInit
+//#define cv_hal_sepFilterInit ovx_hal_sepFilterInit
-#undef cv_hal_sepFilter
+//#undef cv_hal_sepFilter
-#define cv_hal_sepFilter ovx_hal_filter
+//#define cv_hal_sepFilter ovx_hal_filter
-#undef cv_hal_sepFilterFree
+//#undef cv_hal_sepFilterFree
-#define cv_hal_sepFilterFree ovx_hal_filterFree
+//#define cv_hal_sepFilterFree ovx_hal_filterFree
 
 #if VX_VERSION > VX_VERSION_1_0
 

modules/core/include/opencv2/core/openvx/ovx_defs.hpp

@@ -24,6 +24,8 @@ namespace cv{
 namespace ovx{
 // Get common thread local OpenVX context
 CV_EXPORTS_W ivx::Context& getOpenVXContext();
+
+template <int kernel_id> inline bool skipSmallImages(int w, int h)     { return w*h < 3840 * 2160; }
 }}
 
 #define CV_OVX_RUN(condition, func, ...)          \

modules/core/src/convert.cpp

@@ -4862,6 +4862,9 @@ static bool _openvx_cvt(const T* src, size_t sstep,
 
     int srcType = DataType<T>::type, dstType = DataType<DT>::type;
 
+    if (ovx::skipSmallImages<VX_KERNEL_CONVERTDEPTH>(imgSize.width, imgSize.height))
+        return false;
+
     try
     {
         Context context = ovx::getOpenVXContext();
@@ -5964,7 +5967,7 @@ void cv::LUT( InputArray _src, InputArray _lut, OutputArray _dst )
     _dst.create(src.dims, src.size, CV_MAKETYPE(_lut.depth(), cn));
     Mat dst = _dst.getMat();
 
-    CV_OVX_RUN(true,
+    CV_OVX_RUN(!ovx::skipSmallImages<VX_KERNEL_TABLE_LOOKUP>(src.cols, src.rows),
                openvx_LUT(src, dst, lut))
 
 #if !IPP_DISABLE_PERF_LUT

modules/core/src/stat.cpp

@@ -1865,7 +1865,7 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input
     Mat src = _src.getMat(), mask = _mask.getMat();
     CV_Assert( mask.empty() || mask.type() == CV_8UC1 );
 
-    CV_OVX_RUN(true,
+    CV_OVX_RUN(!ovx::skipSmallImages<VX_KERNEL_MEAN_STDDEV>(src.cols, src.rows),
                openvx_meanStdDev(src, _mean, _sdv, mask))
 
     CV_IPP_RUN(IPP_VERSION_X100 >= 700, ipp_meanStdDev(src, _mean, _sdv, mask));
@@ -2322,6 +2322,9 @@ static bool ocl_minMaxIdx( InputArray _src, double* minVal, double* maxVal, int*
 #endif
 
 #ifdef HAVE_OPENVX
+namespace ovx {
+    template <> inline bool skipSmallImages<VX_KERNEL_MINMAXLOC>(int w, int h) { return w*h < 3840 * 2160; }
+}
 static bool openvx_minMaxIdx(Mat &src, double* minVal, double* maxVal, int* minIdx, int* maxIdx, Mat &mask)
 {
     int stype = src.type();
@@ -2682,7 +2685,7 @@ void cv::minMaxIdx(InputArray _src, double* minVal,
 
     Mat src = _src.getMat(), mask = _mask.getMat();
 
-    CV_OVX_RUN(true,
+    CV_OVX_RUN(!ovx::skipSmallImages<VX_KERNEL_MINMAXLOC>(src.cols, src.rows),
                openvx_minMaxIdx(src, minVal, maxVal, minIdx, maxIdx, mask))
 
     CV_IPP_RUN_FAST(ipp_minMaxIdx(src, minVal, maxVal, minIdx, maxIdx, mask))

modules/features2d/src/fast.cpp

@@ -338,6 +338,9 @@ static bool ocl_FAST( InputArray _img, std::vector<KeyPoint>& keypoints,
 
 
 #ifdef HAVE_OPENVX
+namespace ovx {
+    template <> inline bool skipSmallImages<VX_KERNEL_FAST_CORNERS>(int w, int h) { return w*h < 800 * 600; }
+}
 static bool openvx_FAST(InputArray _img, std::vector<KeyPoint>& keypoints,
                         int _threshold, bool nonmaxSuppression, int type)
 {
@@ -352,6 +355,9 @@ static bool openvx_FAST(InputArray _img, std::vector<KeyPoint>& keypoints,
     if(imgMat.empty() || imgMat.type() != CV_8UC1)
         return false;
 
+    if (ovx::skipSmallImages<VX_KERNEL_FAST_CORNERS>(imgMat.cols, imgMat.rows))
+        return false;
+
     try
     {
         Context context = ovx::getOpenVXContext();

modules/imgproc/src/accum.cpp

@@ -1942,9 +1942,14 @@ enum
     VX_ACCUMULATE_WEIGHTED_OP = 2
 };
 
+namespace ovx {
+    template <> inline bool skipSmallImages<VX_KERNEL_ACCUMULATE>(int w, int h) { return w*h < 120 * 60; }
+}
 static bool openvx_accumulate(InputArray _src, InputOutputArray _dst, InputArray _mask, double _weight, int opType)
 {
     Mat srcMat = _src.getMat(), dstMat = _dst.getMat();
+    if (ovx::skipSmallImages<VX_KERNEL_ACCUMULATE>(srcMat.cols, srcMat.rows))
+        return false;
     if(!_mask.empty() ||
        (opType == VX_ACCUMULATE_WEIGHTED_OP && dstMat.type() != CV_8UC1  ) ||
        (opType != VX_ACCUMULATE_WEIGHTED_OP && dstMat.type() != CV_16SC1 ) ||

modules/imgproc/src/canny.cpp

@@ -899,6 +899,9 @@ private:
 };
 
 #ifdef HAVE_OPENVX
+namespace ovx {
+    template <> inline bool skipSmallImages<VX_KERNEL_CANNY_EDGE_DETECTOR>(int w, int h) { return w*h < 640 * 480; }
+}
 static bool openvx_canny(const Mat& src, Mat& dst, int loVal, int hiVal, int kSize, bool useL2)
 {
     using namespace ivx;
@@ -989,7 +992,8 @@ void Canny( InputArray _src, OutputArray _dst,
             src.type() == CV_8UC1 &&
             !src.isSubmatrix() &&
             src.cols >= aperture_size &&
-            src.rows >= aperture_size,
+            src.rows >= aperture_size &&
+            !ovx::skipSmallImages<VX_KERNEL_CANNY_EDGE_DETECTOR>(src.cols, src.rows),
         openvx_canny(
             src,
             dst,

modules/imgproc/src/deriv.cpp

@@ -184,41 +184,24 @@ cv::Ptr<cv::FilterEngine> cv::createDerivFilter(int srcType, int dstType,
 #ifdef HAVE_OPENVX
 namespace cv
 {
+    namespace ovx {
+        template <> inline bool skipSmallImages<VX_KERNEL_SOBEL_3x3>(int w, int h) { return w*h < 320 * 240; }
+    }
     static bool openvx_sobel(InputArray _src, OutputArray _dst,
                              int dx, int dy, int ksize,
                              double scale, double delta, int borderType)
     {
-        int stype = _src.type();
+        if (_src.type() != CV_8UC1 || _dst.type() != CV_16SC1 ||
-        int dtype = _dst.type();
+            ksize != 3 || scale != 1.0 || delta != 0.0 ||
-        if (stype != CV_8UC1 || (dtype != CV_16SC1 && dtype != CV_8UC1) ||
+            (dx | dy) != 1 || (dx + dy) != 1 ||
-            ksize < 3 || ksize % 2 != 1 || delta != 0.0)
+            _src.cols() < ksize || _src.rows() < ksize ||
+            ovx::skipSmallImages<VX_KERNEL_SOBEL_3x3>(_src.cols(), _src.rows())
+            )
             return false;
 
         Mat src = _src.getMat();
         Mat dst = _dst.getMat();
 
-        if (src.cols < ksize || src.rows < ksize)
-            return false;
-
-        int iscale = 1;
-        vx_uint32 cscale = 1;
-        if(scale != 1.0)
-        {
-            iscale = static_cast<int>(scale);
-            if (std::abs(scale - iscale) >= DBL_EPSILON)
-            {
-                int exp = 0;
-                float significand = frexp(scale, &exp);
-                if ((significand == 0.5f) && (exp <= 0))
-                {
-                    iscale = 1;
-                    cscale = 1 << (exp = -exp + 1);
-                }
-                else
-                    return false;
-            }
-        }
-
         if ((borderType & BORDER_ISOLATED) == 0 && src.isSubmatrix())
             return false; //Process isolated borders only
         vx_enum border;
@@ -228,8 +211,8 @@ namespace cv
             border = VX_BORDER_CONSTANT;
             break;
         case BORDER_REPLICATE:
-            border = VX_BORDER_REPLICATE;
+//            border = VX_BORDER_REPLICATE;
-            break;
+//            break;
         default:
             return false;
         }
@@ -237,8 +220,8 @@ namespace cv
         try
         {
             ivx::Context ctx = ovx::getOpenVXContext();
-            if ((vx_size)ksize > ctx.convolutionMaxDimension())
+            //if ((vx_size)ksize > ctx.convolutionMaxDimension())
-                return false;
+            //    return false;
 
             Mat a;
             if (dst.data != src.data)
@@ -249,40 +232,17 @@ namespace cv
             ivx::Image
                 ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8,
                     ivx::Image::createAddressing(a.cols, a.rows, 1, (vx_int32)(a.step)), a.data),
-                ib = ivx::Image::createFromHandle(ctx, dtype == CV_16SC1 ? VX_DF_IMAGE_S16 : VX_DF_IMAGE_U8,
+                ib = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_S16,
-                    ivx::Image::createAddressing(dst.cols, dst.rows, dtype == CV_16SC1 ? 2 : 1, (vx_int32)(dst.step)), dst.data);
+                    ivx::Image::createAddressing(dst.cols, dst.rows, 2, (vx_int32)(dst.step)), dst.data);
 
             //ATTENTION: VX_CONTEXT_IMMEDIATE_BORDER attribute change could lead to strange issues in multi-threaded environments
             //since OpenVX standart says nothing about thread-safety for now
             ivx::border_t prevBorder = ctx.immediateBorder();
             ctx.setImmediateBorder(border, (vx_uint8)(0));
-            if (dtype == CV_16SC1 && ksize == 3 && ((dx | dy) == 1) && (dx + dy) == 1)
+            if(dx)
-            {
+                ivx::IVX_CHECK_STATUS(vxuSobel3x3(ctx, ia, ib, NULL));
-                if(dx)
-                    ivx::IVX_CHECK_STATUS(vxuSobel3x3(ctx, ia, ib, NULL));
-                else
-                    ivx::IVX_CHECK_STATUS(vxuSobel3x3(ctx, ia, NULL, ib));
-            }
             else
-            {
+                ivx::IVX_CHECK_STATUS(vxuSobel3x3(ctx, ia, NULL, ib));
-#if VX_VERSION <= VX_VERSION_1_0
-                if (ctx.vendorID() == VX_ID_KHRONOS && ((vx_size)(src.cols) <= ctx.convolutionMaxDimension() || (vx_size)(src.rows) <= ctx.convolutionMaxDimension()))
-                {
-                    ctx.setImmediateBorder(prevBorder);
-                    return false;
-                }
-#endif
-                Mat kx, ky;
-                getDerivKernels(kx, ky, dx, dy, ksize, false);
-                flip(kx, kx, 0);
-                flip(ky, ky, 0);
-                Mat convData;
-                cv::Mat(ky*kx.t()).convertTo(convData, CV_16SC1, iscale);
-                ivx::Convolution cnv = ivx::Convolution::create(ctx, convData.cols, convData.rows);
-                cnv.copyFrom(convData);
-                cnv.setScale(cscale);
-                ivx::IVX_CHECK_STATUS(vxuConvolve(ctx, ia, cnv, ib));
-            }
             ctx.setImmediateBorder(prevBorder);
         }
         catch (ivx::RuntimeError & e)

modules/imgproc/src/featureselect.cpp

@@ -377,7 +377,8 @@ void cv::goodFeaturesToTrack( InputArray _image, OutputArray _corners,
     }
 
     // Disabled due to bad accuracy
-    CV_OVX_RUN(false && useHarrisDetector && _mask.empty(),
+    CV_OVX_RUN(false && useHarrisDetector && _mask.empty() &&
+               !ovx::skipSmallImages<VX_KERNEL_HARRIS_CORNERS>(image.cols, image.rows),
                openvx_harris(image, _corners, maxCorners, qualityLevel, minDistance, blockSize, harrisK))
 
     if( useHarrisDetector )

modules/imgproc/src/histogram.cpp

@@ -1331,6 +1331,9 @@ private:
 #ifdef HAVE_OPENVX
 namespace cv
 {
+    namespace ovx {
+        template <> inline bool skipSmallImages<VX_KERNEL_HISTOGRAM>(int w, int h) { return w*h < 2048 * 1536; }
+    }
     static bool openvx_calchist(const Mat& image, OutputArray _hist, const int histSize,
         const float* _range)
     {
@@ -1440,7 +1443,8 @@ void cv::calcHist( const Mat* images, int nimages, const int* channels,
         images && histSize &&
         nimages == 1 && images[0].type() == CV_8UC1 && dims == 1 && _mask.getMat().empty() &&
         (!channels || channels[0] == 0) && !accumulate && uniform &&
-        ranges && ranges[0],
+        ranges && ranges[0] &&
+        !ovx::skipSmallImages<VX_KERNEL_HISTOGRAM>(images[0].cols, images[0].rows),
         openvx_calchist(images[0], _hist, histSize[0], ranges[0]))
 
     Mat mask = _mask.getMat();
@@ -3882,7 +3886,7 @@ void cv::equalizeHist( InputArray _src, OutputArray _dst )
     _dst.create( src.size(), src.type() );
     Mat dst = _dst.getMat();
 
-    CV_OVX_RUN(true,
+    CV_OVX_RUN(!ovx::skipSmallImages<VX_KERNEL_EQUALIZE_HISTOGRAM>(src.cols, src.rows),
                openvx_equalize_hist(src, dst))
 
     Mutex histogramLockInstance;

modules/imgproc/src/imgwarp.cpp

@@ -4946,6 +4946,7 @@ void cv::remap( InputArray _src, OutputArray _dst,
 
     CV_OVX_RUN(
         src.type() == CV_8UC1 && dst.type() == CV_8UC1 &&
+        !ovx::skipSmallImages<VX_KERNEL_REMAP>(src.cols, src.rows) &&
         (borderType& ~BORDER_ISOLATED) == BORDER_CONSTANT &&
         ((map1.type() == CV_32FC2 && map2.empty() && map1.size == dst.size) ||
          (map1.type() == CV_32FC1 && map2.type() == CV_32FC1 && map1.size == dst.size && map2.size == dst.size) ||

modules/imgproc/src/pyramids.cpp

@@ -1265,6 +1265,9 @@ static bool openvx_pyrDown( InputArray _src, OutputArray _dst, const Size& _dsz,
 
     Mat srcMat = _src.getMat();
 
+    if (ovx::skipSmallImages<VX_KERNEL_HALFSCALE_GAUSSIAN>(srcMat.cols, srcMat.rows))
+        return false;
+
     CV_Assert(!srcMat.empty());
 
     Size ssize = _src.size();

modules/imgproc/src/smooth.cpp

@@ -1650,26 +1650,24 @@ cv::Ptr<cv::FilterEngine> cv::createBoxFilter( int srcType, int dstType, Size ks
 #ifdef HAVE_OPENVX
 namespace cv
 {
+    namespace ovx {
+        template <> inline bool skipSmallImages<VX_KERNEL_BOX_3x3>(int w, int h) { return w*h < 640 * 480; }
+    }
     static bool openvx_boxfilter(InputArray _src, OutputArray _dst, int ddepth,
                                  Size ksize, Point anchor,
                                  bool normalize, int borderType)
     {
-        int stype = _src.type();
         if (ddepth < 0)
             ddepth = CV_8UC1;
-        if (stype != CV_8UC1 || (ddepth != CV_8U && ddepth != CV_16S) ||
+        if (_src.type() != CV_8UC1 || ddepth != CV_8U || !normalize ||
-            (anchor.x >= 0 && anchor.x != ksize.width / 2) ||
+            _src.cols() < 3 || _src.rows() < 3 ||
-            (anchor.y >= 0 && anchor.y != ksize.height / 2) ||
+            ksize.width != 3 || ksize.height != 3 ||
-            ksize.width % 2 != 1 || ksize.height % 2 != 1 ||
+            (anchor.x >= 0 && anchor.x != 1) ||
-            ksize.width < 3 || ksize.height < 3)
+            (anchor.y >= 0 && anchor.y != 1) ||
+            ovx::skipSmallImages<VX_KERNEL_BOX_3x3>(_src.cols(), _src.rows()))
             return false;
 
         Mat src = _src.getMat();
-        _dst.create(src.size(), CV_MAKETYPE(ddepth, 1));
-        Mat dst = _dst.getMat();
-
-        if (src.cols < ksize.width || src.rows < ksize.height)
-            return false;
 
         if ((borderType & BORDER_ISOLATED) == 0 && src.isSubmatrix())
             return false; //Process isolated borders only
@@ -1686,11 +1684,12 @@ namespace cv
             return false;
         }
 
+        _dst.create(src.size(), CV_8UC1);
+        Mat dst = _dst.getMat();
+
         try
         {
             ivx::Context ctx = ovx::getOpenVXContext();
-            if ((vx_size)(ksize.width) > ctx.convolutionMaxDimension() || (vx_size)(ksize.height) > ctx.convolutionMaxDimension())
-                return false;
 
             Mat a;
             if (dst.data != src.data)
@@ -1701,34 +1700,14 @@ namespace cv
             ivx::Image
                 ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8,
                                                   ivx::Image::createAddressing(a.cols, a.rows, 1, (vx_int32)(a.step)), a.data),
-                ib = ivx::Image::createFromHandle(ctx, ddepth == CV_16S ? VX_DF_IMAGE_S16 : VX_DF_IMAGE_U8,
+                ib = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8,
-                                                  ivx::Image::createAddressing(dst.cols, dst.rows, ddepth == CV_16S ? 2 : 1, (vx_int32)(dst.step)), dst.data);
+                                                  ivx::Image::createAddressing(dst.cols, dst.rows, 1, (vx_int32)(dst.step)), dst.data);
 
             //ATTENTION: VX_CONTEXT_IMMEDIATE_BORDER attribute change could lead to strange issues in multi-threaded environments
             //since OpenVX standart says nothing about thread-safety for now
             ivx::border_t prevBorder = ctx.immediateBorder();
             ctx.setImmediateBorder(border, (vx_uint8)(0));
-            if (ddepth == CV_8U && ksize.width == 3 && ksize.height == 3 && normalize)
+            ivx::IVX_CHECK_STATUS(vxuBox3x3(ctx, ia, ib));
-            {
-                ivx::IVX_CHECK_STATUS(vxuBox3x3(ctx, ia, ib));
-            }
-            else
-            {
-#if VX_VERSION <= VX_VERSION_1_0
-                if (ctx.vendorID() == VX_ID_KHRONOS && ((vx_size)(src.cols) <= ctx.convolutionMaxDimension() || (vx_size)(src.rows) <= ctx.convolutionMaxDimension()))
-                {
-                    ctx.setImmediateBorder(prevBorder);
-                    return false;
-                }
-#endif
-                Mat convData(ksize, CV_16SC1);
-                convData = normalize ? (1 << 15) / (ksize.width * ksize.height) : 1;
-                ivx::Convolution cnv = ivx::Convolution::create(ctx, convData.cols, convData.rows);
-                cnv.copyFrom(convData);
-                if (normalize)
-                    cnv.setScale(1 << 15);
-                ivx::IVX_CHECK_STATUS(vxuConvolve(ctx, ia, cnv, ib));
-            }
             ctx.setImmediateBorder(prevBorder);
         }
         catch (ivx::RuntimeError & e)
@@ -2181,10 +2160,12 @@ static bool ocl_GaussianBlur_8UC1(InputArray _src, OutputArray _dst, Size ksize,
 
 #ifdef HAVE_OPENVX
 
+namespace ovx {
+    template <> inline bool skipSmallImages<VX_KERNEL_GAUSSIAN_3x3>(int w, int h) { return w*h < 320 * 240; }
+}
 static bool openvx_gaussianBlur(InputArray _src, OutputArray _dst, Size ksize,
                                 double sigma1, double sigma2, int borderType)
 {
-    int stype = _src.type();
     if (sigma2 <= 0)
         sigma2 = sigma1;
     // automatic detection of kernel size from sigma
@@ -2193,20 +2174,21 @@ static bool openvx_gaussianBlur(InputArray _src, OutputArray _dst, Size ksize,
     if (ksize.height <= 0 && sigma2 > 0)
         ksize.height = cvRound(sigma2*6 + 1) | 1;
 
-    if (stype != CV_8UC1 ||
+    if (_src.type() != CV_8UC1 ||
-        ksize.width < 3 || ksize.height < 3 ||
+        _src.cols() < 3 || _src.rows() < 3 ||
-        ksize.width % 2 != 1 || ksize.height % 2 != 1)
+        ksize.width != 3 || ksize.height != 3)
         return false;
 
     sigma1 = std::max(sigma1, 0.);
     sigma2 = std::max(sigma2, 0.);
 
+    if (!(sigma1 == 0.0 || (sigma1 - 0.8) < DBL_EPSILON) || !(sigma2 == 0.0 || (sigma2 - 0.8) < DBL_EPSILON) ||
+        ovx::skipSmallImages<VX_KERNEL_GAUSSIAN_3x3>(_src.cols(), _src.rows()))
+        return false;
+
     Mat src = _src.getMat();
     Mat dst = _dst.getMat();
 
-    if (src.cols < ksize.width || src.rows < ksize.height)
-        return false;
-
     if ((borderType & BORDER_ISOLATED) == 0 && src.isSubmatrix())
         return false; //Process isolated borders only
     vx_enum border;
@@ -2225,8 +2207,6 @@ static bool openvx_gaussianBlur(InputArray _src, OutputArray _dst, Size ksize,
     try
     {
         ivx::Context ctx = ovx::getOpenVXContext();
-        if ((vx_size)(ksize.width) > ctx.convolutionMaxDimension() || (vx_size)(ksize.height) > ctx.convolutionMaxDimension())
-            return false;
 
         Mat a;
         if (dst.data != src.data)
@@ -2244,26 +2224,7 @@ static bool openvx_gaussianBlur(InputArray _src, OutputArray _dst, Size ksize,
         //since OpenVX standart says nothing about thread-safety for now
         ivx::border_t prevBorder = ctx.immediateBorder();
         ctx.setImmediateBorder(border, (vx_uint8)(0));
-        if (ksize.width == 3 && ksize.height == 3 && (sigma1 == 0.0 || (sigma1 - 0.8) < DBL_EPSILON) && (sigma2 == 0.0 || (sigma2 - 0.8) < DBL_EPSILON))
+        ivx::IVX_CHECK_STATUS(vxuGaussian3x3(ctx, ia, ib));
-        {
-            ivx::IVX_CHECK_STATUS(vxuGaussian3x3(ctx, ia, ib));
-        }
-        else
-        {
-#if VX_VERSION <= VX_VERSION_1_0
-            if (ctx.vendorID() == VX_ID_KHRONOS && ((vx_size)(a.cols) <= ctx.convolutionMaxDimension() || (vx_size)(a.rows) <= ctx.convolutionMaxDimension()))
-            {
-                ctx.setImmediateBorder(prevBorder);
-                return false;
-            }
-#endif
-            Mat convData;
-            cv::Mat(cv::getGaussianKernel(ksize.height, sigma2)*cv::getGaussianKernel(ksize.width, sigma1).t()).convertTo(convData, CV_16SC1, (1 << 15));
-            ivx::Convolution cnv = ivx::Convolution::create(ctx, convData.cols, convData.rows);
-            cnv.copyFrom(convData);
-            cnv.setScale(1 << 15);
-            ivx::IVX_CHECK_STATUS(vxuConvolve(ctx, ia, cnv, ib));
-        }
         ctx.setImmediateBorder(prevBorder);
     }
     catch (ivx::RuntimeError & e)
@@ -3286,6 +3247,9 @@ static bool ocl_medianFilter(InputArray _src, OutputArray _dst, int m)
 #ifdef HAVE_OPENVX
 namespace cv
 {
+    namespace ovx {
+        template <> inline bool skipSmallImages<VX_KERNEL_MEDIAN_3x3>(int w, int h) { return w*h < 1280 * 720; }
+    }
     static bool openvx_medianFilter(InputArray _src, OutputArray _dst, int ksize)
     {
         if (_src.type() != CV_8UC1 || _dst.type() != CV_8U
@@ -3298,6 +3262,14 @@ namespace cv
         Mat src = _src.getMat();
         Mat dst = _dst.getMat();
 
+        if (
+#ifdef VX_VERSION_1_1
+             ksize != 3 ? ovx::skipSmallImages<VX_KERNEL_NON_LINEAR_FILTER>(src.cols, src.rows) :
+#endif
+             ovx::skipSmallImages<VX_KERNEL_MEDIAN_3x3>(src.cols, src.rows)
+           )
+            return false;
+
         try
         {
             ivx::Context ctx = ovx::getOpenVXContext();

modules/imgproc/src/thresh.cpp

@@ -1390,7 +1390,7 @@ double cv::threshold( InputArray _src, OutputArray _dst, double thresh, double m
             return thresh;
         }
 
-       CV_OVX_RUN(true,
+       CV_OVX_RUN(!ovx::skipSmallImages<VX_KERNEL_THRESHOLD>(src.cols, src.rows),
                   openvx_threshold(src, dst, ithresh, imaxval, type), (double)ithresh)
 
         thresh = ithresh;

modules/video/src/lkpyramid.cpp

@@ -1077,6 +1077,9 @@ namespace
         if(prevImgMat.type() != CV_8UC1 || nextImgMat.type() != CV_8UC1)
             return false;
 
+        if (ovx::skipSmallImages<VX_KERNEL_OPTICAL_FLOW_PYR_LK>(prevImgMat.cols, prevImgMat.rows))
+            return false;
+
         CV_Assert(prevImgMat.size() == nextImgMat.size());
         Mat prevPtsMat = _prevPts.getMat();
         int checkPrev = prevPtsMat.checkVector(2, CV_32F, false);