Merge branch 4.x

modules/3d/include/opencv2/3d.hpp

@@ -2384,7 +2384,7 @@ to compute the optimal new camera matrix.
  */
 CV_EXPORTS void getUndistortRectangles(InputArray cameraMatrix, InputArray distCoeffs,
                                        InputArray R, InputArray newCameraMatrix, Size imgSize,
-                                       Rect_<float>& inner, Rect_<float>& outer );
+                                       Rect_<double>& inner, Rect_<double>& outer );
 
 /** @brief Returns the new camera intrinsic matrix based on the free scaling parameter.
 

modules/3d/src/calibration_base.cpp

@@ -1363,27 +1363,27 @@ void cv::projectPoints( InputArray _opoints,
 
 void cv::getUndistortRectangles(InputArray _cameraMatrix, InputArray _distCoeffs,
               InputArray R, InputArray newCameraMatrix, Size imgSize,
-              Rect_<float>& inner, Rect_<float>& outer )
+              Rect_<double>& inner, Rect_<double>& outer )
 {
     const int N = 9;
     int x, y, k;
-    Mat _pts(1, N*N, CV_32FC2);
-    Point2f* pts = _pts.ptr<Point2f>();
+    Mat _pts(1, N*N, CV_64FC2);
+    Point2d* pts = _pts.ptr<Point2d>();
 
     for( y = k = 0; y < N; y++ )
         for( x = 0; x < N; x++ )
-            pts[k++] = Point2f((float)x*imgSize.width/(N-1), (float)y*imgSize.height/(N-1));
+            pts[k++] = Point2d((double)x*(imgSize.width-1)/(N-1), (double)y*(imgSize.height-1)/(N-1));
 
     undistortPoints(_pts, _pts, _cameraMatrix, _distCoeffs, R, newCameraMatrix);
 
-    float iX0=-FLT_MAX, iX1=FLT_MAX, iY0=-FLT_MAX, iY1=FLT_MAX;
-    float oX0=FLT_MAX, oX1=-FLT_MAX, oY0=FLT_MAX, oY1=-FLT_MAX;
+    double iX0=-FLT_MAX, iX1=FLT_MAX, iY0=-FLT_MAX, iY1=FLT_MAX;
+    double oX0=FLT_MAX, oX1=-FLT_MAX, oY0=FLT_MAX, oY1=-FLT_MAX;
     // find the inscribed rectangle.
     // the code will likely not work with extreme rotation matrices (R) (>45%)
     for( y = k = 0; y < N; y++ )
         for( x = 0; x < N; x++ )
         {
-            Point2f p = pts[k++];
+            Point2d p = pts[k++];
             oX0 = MIN(oX0, p.x);
             oX1 = MAX(oX1, p.x);
             oY0 = MIN(oY0, p.y);
@@ -1398,15 +1398,15 @@ void cv::getUndistortRectangles(InputArray _cameraMatrix, InputArray _distCoeffs
             if( y == N-1 )
                 iY1 = MIN(iY1, p.y);
         }
-    inner = Rect_<float>(iX0, iY0, iX1-iX0, iY1-iY0);
-    outer = Rect_<float>(oX0, oY0, oX1-oX0, oY1-oY0);
+    inner = Rect_<double>(iX0, iY0, iX1-iX0, iY1-iY0);
+    outer = Rect_<double>(oX0, oY0, oX1-oX0, oY1-oY0);
 }
 
 cv::Mat cv::getOptimalNewCameraMatrix( InputArray _cameraMatrix, InputArray _distCoeffs,
                                   Size imgSize, double alpha, Size newImgSize,
                                   Rect* validPixROI, bool centerPrincipalPoint )
 {
-    Rect_<float> inner, outer;
+    Rect_<double> inner, outer;
     newImgSize = newImgSize.width*newImgSize.height != 0 ? newImgSize : imgSize;
 
     Mat cameraMatrix = _cameraMatrix.getMat(), M;
@@ -1436,10 +1436,10 @@ cv::Mat cv::getOptimalNewCameraMatrix( InputArray _cameraMatrix, InputArray _dis
 
         if( validPixROI )
         {
-            inner = cv::Rect_<float>((float)((inner.x - cx0)*s + cx),
-                                     (float)((inner.y - cy0)*s + cy),
-                                     (float)(inner.width*s),
-                                     (float)(inner.height*s));
+            inner = cv::Rect_<double>((double)((inner.x - cx0)*s + cx),
+                                      (double)((inner.y - cy0)*s + cy),
+                                      (double)(inner.width*s),
+                                      (double)(inner.height*s));
             Rect r(cvCeil(inner.x), cvCeil(inner.y), cvFloor(inner.width), cvFloor(inner.height));
             r &= Rect(0, 0, newImgSize.width, newImgSize.height);
             *validPixROI = r;

modules/3d/test/test_undistort.cpp

@@ -157,6 +157,104 @@ void CV_DefaultNewCameraMatrixTest::prepare_to_validation( int /*test_case_idx*/
 
 //---------
 
+class CV_GetOptimalNewCameraMatrixNoDistortionTest : public cvtest::ArrayTest
+{
+public:
+    CV_GetOptimalNewCameraMatrixNoDistortionTest();
+protected:
+    int prepare_test_case (int test_case_idx);
+    void prepare_to_validation(int test_case_idx);
+    void get_test_array_types_and_sizes(int test_case_idx, vector<vector<Size> >& sizes, vector<vector<int> >& types);
+    void run_func();
+
+private:
+    cv::Mat camera_mat;
+    cv::Mat distortion_coeffs;
+    cv::Mat new_camera_mat;
+
+    cv::Size img_size;
+    double alpha;
+    bool center_principal_point;
+
+    int matrix_type;
+
+    static const int MAX_X = 2048;
+    static const int MAX_Y = 2048;
+};
+
+CV_GetOptimalNewCameraMatrixNoDistortionTest::CV_GetOptimalNewCameraMatrixNoDistortionTest()
+{
+    test_array[INPUT].push_back(NULL); // camera_mat
+    test_array[INPUT].push_back(NULL); // distortion_coeffs
+    test_array[OUTPUT].push_back(NULL); // new_camera_mat
+    test_array[REF_OUTPUT].push_back(NULL);
+
+    alpha = 0.0;
+    center_principal_point = false;
+    matrix_type = 0;
+}
+
+void CV_GetOptimalNewCameraMatrixNoDistortionTest::get_test_array_types_and_sizes(int test_case_idx, vector<vector<Size> >& sizes, vector<vector<int> >& types)
+{
+    cvtest::ArrayTest::get_test_array_types_and_sizes(test_case_idx, sizes, types);
+    RNG& rng = ts->get_rng();
+    matrix_type = types[INPUT][0] = types[INPUT][1] = types[OUTPUT][0] = types[REF_OUTPUT][0] = cvtest::randInt(rng)%2 ? CV_64F : CV_32F;
+    sizes[INPUT][0] = sizes[OUTPUT][0] = sizes[REF_OUTPUT][0] = cvSize(3,3);
+    sizes[INPUT][1] = cvSize(1,4);
+}
+
+int CV_GetOptimalNewCameraMatrixNoDistortionTest::prepare_test_case(int test_case_idx)
+{
+    int code = cvtest::ArrayTest::prepare_test_case( test_case_idx );
+
+    if (code <= 0)
+        return code;
+
+    RNG& rng = ts->get_rng();
+
+    alpha = cvtest::randReal(rng);
+    center_principal_point = ((cvtest::randInt(rng) % 2)!=0);
+
+    // Generate random camera matrix. Use floating point precision for source to avoid precision loss
+    img_size.width = cvtest::randInt(rng) % MAX_X + 1;
+    img_size.height = cvtest::randInt(rng) % MAX_Y + 1;
+    const float aspect_ratio = static_cast<float>(img_size.width) / img_size.height;
+    float cam_array[9] = {0,0,0,0,0,0,0,0,1};
+    cam_array[2] = static_cast<float>((img_size.width - 1)*0.5);  // center
+    cam_array[5] = static_cast<float>((img_size.height - 1)*0.5); // center
+    cam_array[0] = static_cast<float>(MAX(img_size.width, img_size.height)/(0.9 - cvtest::randReal(rng)*0.6));
+    cam_array[4] = aspect_ratio*cam_array[0];
+
+    Mat& input_camera_mat = test_mat[INPUT][0];
+    cvtest::convert(Mat(3, 3, CV_32F, cam_array), input_camera_mat, input_camera_mat.type());
+    camera_mat = input_camera_mat;
+
+    // Generate zero distortion matrix
+    const Mat zero_dist_coeffs = Mat::zeros(1, 4, CV_32F);
+    Mat& input_dist_coeffs = test_mat[INPUT][1];
+    cvtest::convert(zero_dist_coeffs, input_dist_coeffs, input_dist_coeffs.type());
+    distortion_coeffs = input_dist_coeffs;
+
+    return code;
+}
+
+void CV_GetOptimalNewCameraMatrixNoDistortionTest::run_func()
+{
+    new_camera_mat = cv::getOptimalNewCameraMatrix(camera_mat, distortion_coeffs, img_size, alpha, img_size, NULL, center_principal_point);
+}
+
+void CV_GetOptimalNewCameraMatrixNoDistortionTest::prepare_to_validation(int /*test_case_idx*/)
+{
+    const Mat& src = test_mat[INPUT][0];
+    Mat& dst = test_mat[REF_OUTPUT][0];
+    cvtest::copy(src, dst);
+
+    Mat& output = test_mat[OUTPUT][0];
+    cvtest::convert(new_camera_mat, output, output.type());
+}
+
+//---------
+
 class CV_UndistortPointsTest : public cvtest::ArrayTest
 {
 public:
@@ -991,6 +1089,7 @@ double CV_InitInverseRectificationMapTest::get_success_error_level( int /*test_c
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 
 TEST(Calib3d_DefaultNewCameraMatrix, accuracy) { CV_DefaultNewCameraMatrixTest test; test.safe_run(); }
+TEST(Calib3d_GetOptimalNewCameraMatrixNoDistortion, accuracy) { CV_GetOptimalNewCameraMatrixNoDistortionTest test; test.safe_run(); }
 TEST(Calib3d_UndistortPoints, accuracy) { CV_UndistortPointsTest test; test.safe_run(); }
 TEST(Calib3d_InitUndistortRectifyMap, accuracy) { CV_InitUndistortRectifyMapTest test; test.safe_run(); }
 TEST(DISABLED_Calib3d_InitInverseRectificationMap, accuracy) { CV_InitInverseRectificationMapTest test; test.safe_run(); }

modules/calib/src/fisheye.cpp

@@ -462,7 +462,7 @@ void cv::fisheye::undistortPoints( InputArray distorted, OutputArray undistorted
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/// cv::fisheye::undistortPoints
+/// cv::fisheye::initUndistortRectifyMap
 
 void cv::fisheye::initUndistortRectifyMap( InputArray K, InputArray D, InputArray R, InputArray P,
     const cv::Size& size, int m1type, OutputArray map1, OutputArray map2 )

modules/core/CMakeLists.txt

@@ -179,7 +179,7 @@ ocv_install_3rdparty_licenses(SoftFloat "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/So
 
 
 # generate data (samples data) config file
-set(OPENCV_DATA_CONFIG_FILE "${CMAKE_BINARY_DIR}/opencv_data_config.hpp")
+set(OPENCV_DATA_CONFIG_FILE "${OPENCV_CONFIG_FILE_INCLUDE_DIR}/opencv_data_config.hpp")
 set(OPENCV_DATA_CONFIG_STR "")
 
 if(CMAKE_INSTALL_PREFIX)

modules/core/include/opencv2/core.hpp

@@ -230,7 +230,8 @@ enum KmeansFlags {
 enum ReduceTypes { REDUCE_SUM = 0, //!< the output is the sum of all rows/columns of the matrix.
                    REDUCE_AVG = 1, //!< the output is the mean vector of all rows/columns of the matrix.
                    REDUCE_MAX = 2, //!< the output is the maximum (column/row-wise) of all rows/columns of the matrix.
-                   REDUCE_MIN = 3  //!< the output is the minimum (column/row-wise) of all rows/columns of the matrix.
+                   REDUCE_MIN = 3,  //!< the output is the minimum (column/row-wise) of all rows/columns of the matrix.
+                   REDUCE_SUM2 = 4  //!< the output is the sum of all squared rows/columns of the matrix.
                  };
 
 //! @} core_array
@@ -903,7 +904,7 @@ The function #reduce reduces the matrix to a vector by treating the matrix rows/
 1D vectors and performing the specified operation on the vectors until a single row/column is
 obtained. For example, the function can be used to compute horizontal and vertical projections of a
 raster image. In case of #REDUCE_MAX and #REDUCE_MIN , the output image should have the same type as the source one.
-In case of #REDUCE_SUM and #REDUCE_AVG , the output may have a larger element bit-depth to preserve accuracy.
+In case of #REDUCE_SUM, #REDUCE_SUM2 and #REDUCE_AVG , the output may have a larger element bit-depth to preserve accuracy.
 And multi-channel arrays are also supported in these two reduction modes.
 
 The following code demonstrates its usage for a single channel matrix.

modules/core/include/opencv2/core/cuda.hpp

@@ -567,6 +567,29 @@ The function does not reallocate memory if the matrix has proper attributes alre
  */
 CV_EXPORTS_W void ensureSizeIsEnough(int rows, int cols, int type, OutputArray arr);
 
+/** @brief Bindings overload to create a GpuMat from existing GPU memory.
+@param rows Row count.
+@param cols Column count.
+@param type Type of the matrix.
+@param cudaMemoryAddress Address of the allocated GPU memory on the device. This does not allocate matrix data. Instead, it just initializes the matrix header that points to the specified \a cudaMemoryAddress, which means that no data is copied. This operation is very efficient and can be used to process external data using OpenCV functions. The external data is not automatically deallocated, so you should take care of it.
+@param step Number of bytes each matrix row occupies. The value should include the padding bytes at the end of each row, if any. If the parameter is missing (set to Mat::AUTO_STEP ), no padding is assumed and the actual step is calculated as cols*elemSize(). See GpuMat::elemSize.
+@note Overload for generation of bindings only, not exported or intended for use internally from C++.
+ */
+CV_EXPORTS_W GpuMat inline createGpuMatFromCudaMemory(int rows, int cols, int type, size_t cudaMemoryAddress, size_t step = Mat::AUTO_STEP) {
+    return GpuMat(rows, cols, type, reinterpret_cast<void*>(cudaMemoryAddress), step);
+};
+
+ /** @overload
+@param size 2D array size: Size(cols, rows). In the Size() constructor, the number of rows and the number of columns go in the reverse order.
+@param type Type of the matrix.
+@param cudaMemoryAddress Address of the allocated GPU memory on the device. This does not allocate matrix data. Instead, it just initializes the matrix header that points to the specified \a cudaMemoryAddress, which means that no data is copied. This operation is very efficient and can be used to process external data using OpenCV functions. The external data is not automatically deallocated, so you should take care of it.
+@param step Number of bytes each matrix row occupies. The value should include the padding bytes at the end of each row, if any. If the parameter is missing (set to Mat::AUTO_STEP ), no padding is assumed and the actual step is calculated as cols*elemSize(). See GpuMat::elemSize.
+@note Overload for generation of bindings only, not exported or intended for use internally from C++.
+ */
+CV_EXPORTS_W inline GpuMat createGpuMatFromCudaMemory(Size size, int type, size_t cudaMemoryAddress, size_t step = Mat::AUTO_STEP) {
+    return GpuMat(size, type, reinterpret_cast<void*>(cudaMemoryAddress), step);
+};
+
 /** @brief BufferPool for use with CUDA streams
 
 BufferPool utilizes Stream's allocator to create new buffers for GpuMat's. It is
@@ -921,6 +944,13 @@ private:
     friend class DefaultDeviceInitializer;
 };
 
+
+/** @brief Bindings overload to create a Stream object from the address stored in an existing CUDA Runtime API stream pointer (cudaStream_t).
+@param cudaStreamMemoryAddress Memory address stored in a CUDA Runtime API stream pointer (cudaStream_t). The created Stream object does not perform any allocation or deallocation and simply wraps existing raw CUDA Runtime API stream pointer.
+@note Overload for generation of bindings only, not exported or intended for use internally from C++.
+ */
+CV_EXPORTS_W Stream wrapStream(size_t cudaStreamMemoryAddress);
+
 class CV_EXPORTS_W Event
 {
 public:

modules/core/include/opencv2/core/eigen.hpp

@@ -52,7 +52,9 @@
 #include "opencv2/core.hpp"
 
 #if defined _MSC_VER && _MSC_VER >= 1200
+#ifndef NOMINMAX
 #define NOMINMAX // fix https://github.com/opencv/opencv/issues/17548
+#endif
 #pragma warning( disable: 4714 ) //__forceinline is not inlined
 #pragma warning( disable: 4127 ) //conditional expression is constant
 #pragma warning( disable: 4244 ) //conversion from '__int64' to 'int', possible loss of data

modules/core/include/opencv2/core/hal/intrin.hpp

@@ -758,6 +758,36 @@ namespace CV__SIMD_NAMESPACE {
     #if CV_SIMD_64F
     OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_float64)
     #endif
+    #if CV_SIMD_WIDTH != 16/*128*/ && CV_SIMD128
+    // when we use CV_SIMD128 with 256/512 bit SIMD (e.g. AVX2 or AVX512)
+        OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_uint8x16)
+        OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_uint16x8)
+        OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_uint32x4)
+        OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_uint64x2)
+        OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_int8x16)
+        OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_int16x8)
+        OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_int32x4)
+        OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_int64x2)
+        OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_float32x4)
+        #if CV_SIMD_64F
+        OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_float64x2)
+        #endif
+    #endif
+    #if CV_SIMD_WIDTH != 32/*256*/ && CV_SIMD256
+    // when we use CV_SIMD256 with 512 bit SIMD (e.g. AVX512)
+        OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_uint8x32)
+        OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_uint16x16)
+        OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_uint32x8)
+        OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_uint64x4)
+        OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_int8x32)
+        OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_int16x16)
+        OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_int32x8)
+        OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_int64x4)
+        OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_float32x8)
+        #if CV_SIMD_64F
+        OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_float64x4)
+        #endif
+    #endif
 
     #define OPENCV_HAL_WRAP_BIN_OP_LOGIC(_Tpvec) \
     inline _Tpvec v_and(const _Tpvec& a, const _Tpvec& b) \
@@ -785,6 +815,26 @@ namespace CV__SIMD_NAMESPACE {
     OPENCV_HAL_WRAP_BIN_OP_LOGIC(v_int16)
     OPENCV_HAL_WRAP_BIN_OP_LOGIC(v_int32)
     OPENCV_HAL_WRAP_BIN_OP_LOGIC(v_int64)
+    #if CV_SIMD_WIDTH != 16/*128*/ && CV_SIMD128
+        OPENCV_HAL_WRAP_BIN_OP_LOGIC(v_uint8x16)
+        OPENCV_HAL_WRAP_BIN_OP_LOGIC(v_uint16x8)
+        OPENCV_HAL_WRAP_BIN_OP_LOGIC(v_uint32x4)
+        OPENCV_HAL_WRAP_BIN_OP_LOGIC(v_uint64x2)
+        OPENCV_HAL_WRAP_BIN_OP_LOGIC(v_int8x16)
+        OPENCV_HAL_WRAP_BIN_OP_LOGIC(v_int16x8)
+        OPENCV_HAL_WRAP_BIN_OP_LOGIC(v_int32x4)
+        OPENCV_HAL_WRAP_BIN_OP_LOGIC(v_int64x2)
+    #endif
+    #if CV_SIMD_WIDTH != 32/*256*/ && CV_SIMD256
+        OPENCV_HAL_WRAP_BIN_OP_LOGIC(v_uint8x32)
+        OPENCV_HAL_WRAP_BIN_OP_LOGIC(v_uint16x16)
+        OPENCV_HAL_WRAP_BIN_OP_LOGIC(v_uint32x8)
+        OPENCV_HAL_WRAP_BIN_OP_LOGIC(v_uint64x4)
+        OPENCV_HAL_WRAP_BIN_OP_LOGIC(v_int8x32)
+        OPENCV_HAL_WRAP_BIN_OP_LOGIC(v_int16x16)
+        OPENCV_HAL_WRAP_BIN_OP_LOGIC(v_int32x8)
+        OPENCV_HAL_WRAP_BIN_OP_LOGIC(v_int64x4)
+    #endif
 
     #define OPENCV_HAL_WRAP_BIN_OP_MUL(_Tpvec) \
     inline _Tpvec v_mul(const _Tpvec& a, const _Tpvec& b) \
@@ -805,17 +855,51 @@ namespace CV__SIMD_NAMESPACE {
     #if CV_SIMD_64F
     OPENCV_HAL_WRAP_BIN_OP_MUL(v_float64)
     #endif
+    #if CV_SIMD_WIDTH != 16/*128*/ && CV_SIMD128
+        OPENCV_HAL_WRAP_BIN_OP_MUL(v_uint8x16)
+        OPENCV_HAL_WRAP_BIN_OP_MUL(v_uint16x8)
+        OPENCV_HAL_WRAP_BIN_OP_MUL(v_uint32x4)
+        OPENCV_HAL_WRAP_BIN_OP_MUL(v_int8x16)
+        OPENCV_HAL_WRAP_BIN_OP_MUL(v_int16x8)
+        OPENCV_HAL_WRAP_BIN_OP_MUL(v_int32x4)
+        OPENCV_HAL_WRAP_BIN_OP_MUL(v_float32x4)
+        #if CV_SIMD_64F
+        OPENCV_HAL_WRAP_BIN_OP_MUL(v_float64x2)
+        #endif
+    #endif
+    #if CV_SIMD_WIDTH != 32/*256*/ && CV_SIMD256
+        OPENCV_HAL_WRAP_BIN_OP_MUL(v_uint8x32)
+        OPENCV_HAL_WRAP_BIN_OP_MUL(v_uint16x16)
+        OPENCV_HAL_WRAP_BIN_OP_MUL(v_uint32x8)
+        OPENCV_HAL_WRAP_BIN_OP_MUL(v_int8x32)
+        OPENCV_HAL_WRAP_BIN_OP_MUL(v_int16x16)
+        OPENCV_HAL_WRAP_BIN_OP_MUL(v_int32x8)
+        OPENCV_HAL_WRAP_BIN_OP_MUL(v_float32x8)
+        #if CV_SIMD_64F
+        OPENCV_HAL_WRAP_BIN_OP_MUL(v_float64x4)
+        #endif
+    #endif
 
-
-    inline v_float32 v_div(const v_float32& a, const v_float32& b) \
+    #define OPENCV_HAL_WRAP_BIN_OP_DIV(_Tpvec) \
+    inline _Tpvec v_div(const _Tpvec& a, const _Tpvec& b) \
     { \
         return a / b; \
     }
+    OPENCV_HAL_WRAP_BIN_OP_DIV(v_float32)
     #if CV_SIMD_64F
-    inline v_float64 v_div(const v_float64& a, const v_float64& b) \
-    { \
-        return a / b; \
-    }
+    OPENCV_HAL_WRAP_BIN_OP_DIV(v_float64)
+    #endif
+    #if CV_SIMD_WIDTH != 16/*128*/ && CV_SIMD128
+        OPENCV_HAL_WRAP_BIN_OP_DIV(v_float32x4)
+        #if CV_SIMD_64F
+        OPENCV_HAL_WRAP_BIN_OP_DIV(v_float64x2)
+        #endif
+    #endif
+    #if CV_SIMD_WIDTH != 32/*256*/ && CV_SIMD256
+        OPENCV_HAL_WRAP_BIN_OP_DIV(v_float32x8)
+        #if CV_SIMD_64F
+        OPENCV_HAL_WRAP_BIN_OP_DIV(v_float64x4)
+        #endif
     #endif
 
     #define OPENCV_HAL_WRAP_CMP_OP(_Tpvec, intrin, op) \
@@ -844,44 +928,124 @@ namespace CV__SIMD_NAMESPACE {
     #if CV_SIMD_64F
     OPENCV_HAL_WRAP_CMP(v_float64)
     #endif
+    #if CV_SIMD_WIDTH != 16/*128*/ && CV_SIMD128
+        OPENCV_HAL_WRAP_CMP(v_uint8x16)
+        OPENCV_HAL_WRAP_CMP(v_uint16x8)
+        OPENCV_HAL_WRAP_CMP(v_uint32x4)
+        OPENCV_HAL_WRAP_CMP(v_int8x16)
+        OPENCV_HAL_WRAP_CMP(v_int16x8)
+        OPENCV_HAL_WRAP_CMP(v_int32x4)
+        OPENCV_HAL_WRAP_CMP(v_float32x4)
+        #if CV_SIMD_64F
+        OPENCV_HAL_WRAP_CMP(v_float64x2)
+        #endif
+    #endif
+    #if CV_SIMD_WIDTH != 32/*256*/ && CV_SIMD256
+        OPENCV_HAL_WRAP_CMP(v_uint8x32)
+        OPENCV_HAL_WRAP_CMP(v_uint16x16)
+        OPENCV_HAL_WRAP_CMP(v_uint32x8)
+        OPENCV_HAL_WRAP_CMP(v_int8x32)
+        OPENCV_HAL_WRAP_CMP(v_int16x16)
+        OPENCV_HAL_WRAP_CMP(v_int32x8)
+        OPENCV_HAL_WRAP_CMP(v_float32x8)
+        #if CV_SIMD_64F
+        OPENCV_HAL_WRAP_CMP(v_float64x4)
+        #endif
+    #endif
 
     //////////// get0 ////////////
-    #define OPENCV_HAL_WRAP_GRT0_INT(_Tpvec, _Tp) \
-    inline _Tp v_get0(const v_##_Tpvec& v) \
+    #define OPENCV_HAL_WRAP_GRT0(_Tpvec) \
+    inline typename VTraits<_Tpvec>::lane_type v_get0(const _Tpvec& v) \
     { \
         return v.get0(); \
     }
 
-    OPENCV_HAL_WRAP_GRT0_INT(uint8, uchar)
-    OPENCV_HAL_WRAP_GRT0_INT(int8, schar)
-    OPENCV_HAL_WRAP_GRT0_INT(uint16, ushort)
-    OPENCV_HAL_WRAP_GRT0_INT(int16, short)
-    OPENCV_HAL_WRAP_GRT0_INT(uint32, unsigned)
-    OPENCV_HAL_WRAP_GRT0_INT(int32, int)
-    OPENCV_HAL_WRAP_GRT0_INT(uint64, uint64)
-    OPENCV_HAL_WRAP_GRT0_INT(int64, int64)
-    OPENCV_HAL_WRAP_GRT0_INT(float32, float)
+    OPENCV_HAL_WRAP_GRT0(v_uint8)
+    OPENCV_HAL_WRAP_GRT0(v_int8)
+    OPENCV_HAL_WRAP_GRT0(v_uint16)
+    OPENCV_HAL_WRAP_GRT0(v_int16)
+    OPENCV_HAL_WRAP_GRT0(v_uint32)
+    OPENCV_HAL_WRAP_GRT0(v_int32)
+    OPENCV_HAL_WRAP_GRT0(v_uint64)
+    OPENCV_HAL_WRAP_GRT0(v_int64)
+    OPENCV_HAL_WRAP_GRT0(v_float32)
     #if CV_SIMD_64F
-    OPENCV_HAL_WRAP_GRT0_INT(float64, double)
+    OPENCV_HAL_WRAP_GRT0(v_float64)
+    #endif
+    #if CV_SIMD_WIDTH != 16/*128*/ && CV_SIMD128
+        OPENCV_HAL_WRAP_GRT0(v_uint8x16)
+        OPENCV_HAL_WRAP_GRT0(v_uint16x8)
+        OPENCV_HAL_WRAP_GRT0(v_uint32x4)
+        OPENCV_HAL_WRAP_GRT0(v_uint64x2)
+        OPENCV_HAL_WRAP_GRT0(v_int8x16)
+        OPENCV_HAL_WRAP_GRT0(v_int16x8)
+        OPENCV_HAL_WRAP_GRT0(v_int32x4)
+        OPENCV_HAL_WRAP_GRT0(v_int64x2)
+        OPENCV_HAL_WRAP_GRT0(v_float32x4)
+        #if CV_SIMD_64F
+        OPENCV_HAL_WRAP_GRT0(v_float64x2)
+        #endif
+    #endif
+    #if CV_SIMD_WIDTH != 32/*256*/ && CV_SIMD256
+        OPENCV_HAL_WRAP_GRT0(v_uint8x32)
+        OPENCV_HAL_WRAP_GRT0(v_uint16x16)
+        OPENCV_HAL_WRAP_GRT0(v_uint32x8)
+        OPENCV_HAL_WRAP_GRT0(v_uint64x4)
+        OPENCV_HAL_WRAP_GRT0(v_int8x32)
+        OPENCV_HAL_WRAP_GRT0(v_int16x16)
+        OPENCV_HAL_WRAP_GRT0(v_int32x8)
+        OPENCV_HAL_WRAP_GRT0(v_int64x4)
+        OPENCV_HAL_WRAP_GRT0(v_float32x8)
+        #if CV_SIMD_64F
+        OPENCV_HAL_WRAP_GRT0(v_float64x4)
+        #endif
     #endif
 
-    #define OPENCV_HAL_WRAP_EXTRACT(_Tpvec, _Tp, vl) \
-    inline _Tp v_extract_highest(const _Tpvec& v) \
+    #define OPENCV_HAL_WRAP_EXTRACT(_Tpvec) \
+    inline typename VTraits<_Tpvec>::lane_type v_extract_highest(const _Tpvec& v) \
     { \
-        return v_extract_n<vl-1>(v); \
+        return v_extract_n<VTraits<_Tpvec>::nlanes-1>(v); \
     }
 
-    OPENCV_HAL_WRAP_EXTRACT(v_uint8, uchar, VTraits<v_uint8>::nlanes)
-    OPENCV_HAL_WRAP_EXTRACT(v_int8, schar, VTraits<v_int8>::nlanes)
-    OPENCV_HAL_WRAP_EXTRACT(v_uint16, ushort, VTraits<v_uint16>::nlanes)
-    OPENCV_HAL_WRAP_EXTRACT(v_int16, short, VTraits<v_int16>::nlanes)
-    OPENCV_HAL_WRAP_EXTRACT(v_uint32, unsigned int, VTraits<v_uint32>::nlanes)
-    OPENCV_HAL_WRAP_EXTRACT(v_int32, int, VTraits<v_int32>::nlanes)
-    OPENCV_HAL_WRAP_EXTRACT(v_uint64, uint64, VTraits<v_uint64>::nlanes)
-    OPENCV_HAL_WRAP_EXTRACT(v_int64, int64, VTraits<v_int64>::nlanes)
-    OPENCV_HAL_WRAP_EXTRACT(v_float32, float, VTraits<v_float32>::nlanes)
+    OPENCV_HAL_WRAP_EXTRACT(v_uint8)
+    OPENCV_HAL_WRAP_EXTRACT(v_int8)
+    OPENCV_HAL_WRAP_EXTRACT(v_uint16)
+    OPENCV_HAL_WRAP_EXTRACT(v_int16)
+    OPENCV_HAL_WRAP_EXTRACT(v_uint32)
+    OPENCV_HAL_WRAP_EXTRACT(v_int32)
+    OPENCV_HAL_WRAP_EXTRACT(v_uint64)
+    OPENCV_HAL_WRAP_EXTRACT(v_int64)
+    OPENCV_HAL_WRAP_EXTRACT(v_float32)
     #if CV_SIMD_64F
-    OPENCV_HAL_WRAP_EXTRACT(v_float64, double, VTraits<v_float64>::nlanes)
+    OPENCV_HAL_WRAP_EXTRACT(v_float64)
+    #endif
+    #if CV_SIMD_WIDTH != 16/*128*/ && CV_SIMD128
+        OPENCV_HAL_WRAP_EXTRACT(v_uint8x16)
+        OPENCV_HAL_WRAP_EXTRACT(v_uint16x8)
+        OPENCV_HAL_WRAP_EXTRACT(v_uint32x4)
+        OPENCV_HAL_WRAP_EXTRACT(v_uint64x2)
+        OPENCV_HAL_WRAP_EXTRACT(v_int8x16)
+        OPENCV_HAL_WRAP_EXTRACT(v_int16x8)
+        OPENCV_HAL_WRAP_EXTRACT(v_int32x4)
+        OPENCV_HAL_WRAP_EXTRACT(v_int64x2)
+        OPENCV_HAL_WRAP_EXTRACT(v_float32x4)
+        #if CV_SIMD_64F
+        OPENCV_HAL_WRAP_EXTRACT(v_float64x2)
+        #endif
+    #endif
+    #if CV_SIMD_WIDTH != 32/*256*/ && CV_SIMD256
+        OPENCV_HAL_WRAP_EXTRACT(v_uint8x32)
+        OPENCV_HAL_WRAP_EXTRACT(v_uint16x16)
+        OPENCV_HAL_WRAP_EXTRACT(v_uint32x8)
+        OPENCV_HAL_WRAP_EXTRACT(v_uint64x4)
+        OPENCV_HAL_WRAP_EXTRACT(v_int8x32)
+        OPENCV_HAL_WRAP_EXTRACT(v_int16x16)
+        OPENCV_HAL_WRAP_EXTRACT(v_int32x8)
+        OPENCV_HAL_WRAP_EXTRACT(v_int64x4)
+        OPENCV_HAL_WRAP_EXTRACT(v_float32x8)
+        #if CV_SIMD_64F
+        OPENCV_HAL_WRAP_EXTRACT(v_float64x4)
+        #endif
     #endif
 
     #define OPENCV_HAL_WRAP_BROADCAST(_Tpvec) \
@@ -893,7 +1057,16 @@ namespace CV__SIMD_NAMESPACE {
     OPENCV_HAL_WRAP_BROADCAST(v_uint32)
     OPENCV_HAL_WRAP_BROADCAST(v_int32)
     OPENCV_HAL_WRAP_BROADCAST(v_float32)
-
+    #if CV_SIMD_WIDTH != 16/*128*/ && CV_SIMD128
+        OPENCV_HAL_WRAP_BROADCAST(v_uint32x4)
+        OPENCV_HAL_WRAP_BROADCAST(v_int32x4)
+        OPENCV_HAL_WRAP_BROADCAST(v_float32x4)
+    #endif
+    #if CV_SIMD_WIDTH != 32/*256*/ && CV_SIMD256
+        OPENCV_HAL_WRAP_BROADCAST(v_uint32x8)
+        OPENCV_HAL_WRAP_BROADCAST(v_int32x8)
+        OPENCV_HAL_WRAP_BROADCAST(v_float32x8)
+    #endif
 
 #endif //!CV_SIMD_SCALABLE
 

modules/core/include/opencv2/core/hal/intrin_cpp.hpp

@@ -880,14 +880,10 @@ OPENCV_HAL_IMPL_CMP_OP(<=)
 For all types except 64-bit integer values. */
 OPENCV_HAL_IMPL_CMP_OP(>=)
 
-/** @brief Equal comparison
-
-For all types except 64-bit integer values. */
+/** @brief Equal comparison */
 OPENCV_HAL_IMPL_CMP_OP(==)
 
-/** @brief Not equal comparison
-
-For all types except 64-bit integer values. */
+/** @brief Not equal comparison */
 OPENCV_HAL_IMPL_CMP_OP(!=)
 
 template<int n>

modules/core/include/opencv2/core/hal/intrin_neon.hpp

@@ -1036,18 +1036,6 @@ OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_float64x2, v_min, vminq_f64)
 OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_float64x2, v_max, vmaxq_f64)
 #endif
 
-#if CV_SIMD128_64F
-inline int64x2_t vmvnq_s64(int64x2_t a)
-{
-    int64x2_t vx = vreinterpretq_s64_u32(vdupq_n_u32(0xFFFFFFFF));
-    return veorq_s64(a, vx);
-}
-inline uint64x2_t vmvnq_u64(uint64x2_t a)
-{
-    uint64x2_t vx = vreinterpretq_u64_u32(vdupq_n_u32(0xFFFFFFFF));
-    return veorq_u64(a, vx);
-}
-#endif
 #define OPENCV_HAL_IMPL_NEON_INT_CMP_OP(_Tpvec, cast, suffix, not_suffix) \
 inline _Tpvec operator == (const _Tpvec& a, const _Tpvec& b) \
 { return _Tpvec(cast(vceqq_##suffix(a.val, b.val))); } \
@@ -1069,9 +1057,47 @@ OPENCV_HAL_IMPL_NEON_INT_CMP_OP(v_int16x8, vreinterpretq_s16_u16, s16, u16)
 OPENCV_HAL_IMPL_NEON_INT_CMP_OP(v_uint32x4, OPENCV_HAL_NOP, u32, u32)
 OPENCV_HAL_IMPL_NEON_INT_CMP_OP(v_int32x4, vreinterpretq_s32_u32, s32, u32)
 OPENCV_HAL_IMPL_NEON_INT_CMP_OP(v_float32x4, vreinterpretq_f32_u32, f32, u32)
+#if defined(__aarch64__) || defined(_M_ARM64)
+static inline uint64x2_t vmvnq_u64(uint64x2_t a)
+{
+    uint64x2_t vx = vreinterpretq_u64_u32(vdupq_n_u32(0xFFFFFFFF));
+    return veorq_u64(a, vx);
+}
+//OPENCV_HAL_IMPL_NEON_INT_CMP_OP(v_uint64x2, OPENCV_HAL_NOP, u64, u64)
+//OPENCV_HAL_IMPL_NEON_INT_CMP_OP(v_int64x2, vreinterpretq_s64_u64, s64, u64)
+static inline v_uint64x2 operator == (const v_uint64x2& a, const v_uint64x2& b)
+{ return v_uint64x2(vceqq_u64(a.val, b.val)); }
+static inline v_uint64x2 operator != (const v_uint64x2& a, const v_uint64x2& b)
+{ return v_uint64x2(vmvnq_u64(vceqq_u64(a.val, b.val))); }
+static inline v_int64x2 operator == (const v_int64x2& a, const v_int64x2& b)
+{ return v_int64x2(vreinterpretq_s64_u64(vceqq_s64(a.val, b.val))); }
+static inline v_int64x2 operator != (const v_int64x2& a, const v_int64x2& b)
+{ return v_int64x2(vreinterpretq_s64_u64(vmvnq_u64(vceqq_s64(a.val, b.val)))); }
+#else
+static inline v_uint64x2 operator == (const v_uint64x2& a, const v_uint64x2& b)
+{
+    uint32x4_t cmp = vceqq_u32(vreinterpretq_u32_u64(a.val), vreinterpretq_u32_u64(b.val));
+    uint32x4_t swapped = vrev64q_u32(cmp);
+    return v_uint64x2(vreinterpretq_u64_u32(vandq_u32(cmp, swapped)));
+}
+static inline v_uint64x2 operator != (const v_uint64x2& a, const v_uint64x2& b)
+{
+    uint32x4_t cmp = vceqq_u32(vreinterpretq_u32_u64(a.val), vreinterpretq_u32_u64(b.val));
+    uint32x4_t swapped = vrev64q_u32(cmp);
+    uint64x2_t v_eq = vreinterpretq_u64_u32(vandq_u32(cmp, swapped));
+    uint64x2_t vx = vreinterpretq_u64_u32(vdupq_n_u32(0xFFFFFFFF));
+    return v_uint64x2(veorq_u64(v_eq, vx));
+}
+static inline v_int64x2 operator == (const v_int64x2& a, const v_int64x2& b)
+{
+    return v_reinterpret_as_s64(v_reinterpret_as_u64(a) == v_reinterpret_as_u64(b));
+}
+static inline v_int64x2 operator != (const v_int64x2& a, const v_int64x2& b)
+{
+    return v_reinterpret_as_s64(v_reinterpret_as_u64(a) != v_reinterpret_as_u64(b));
+}
+#endif
 #if CV_SIMD128_64F
-OPENCV_HAL_IMPL_NEON_INT_CMP_OP(v_uint64x2, OPENCV_HAL_NOP, u64, u64)
-OPENCV_HAL_IMPL_NEON_INT_CMP_OP(v_int64x2, vreinterpretq_s64_u64, s64, u64)
 OPENCV_HAL_IMPL_NEON_INT_CMP_OP(v_float64x2, vreinterpretq_f64_u64, f64, u64)
 #endif
 

modules/core/include/opencv2/core/hal/intrin_rvv.hpp

@@ -10,13 +10,36 @@
 
 #include <algorithm>
 
+// RVV intrinsics have been renamed in version 0.11, so we need to include
+// compatibility headers:
+// https://github.com/riscv-non-isa/rvv-intrinsic-doc/tree/master/auto-generated/rvv-v0p10-compatible-headers
+#if defined(__riscv_v_intrinsic) &&  __riscv_v_intrinsic>10999
+#include "intrin_rvv_010_compat_non-policy.hpp"
+#include "intrin_rvv_010_compat_overloaded-non-policy.hpp"
+#endif
+
+
+// Building for T-Head C906 core with RVV 0.7.1 using toolchain
+// https://github.com/T-head-Semi/xuantie-gnu-toolchain
+// with option '-march=rv64gcv0p7'
+#ifdef __THEAD_VERSION__
+#   if __riscv_v == 7000
+#       include <fenv.h>
+#       define CV_RVV_THEAD_0_7
+#   endif
+#endif
+
 namespace cv
 {
 
 CV_CPU_OPTIMIZATION_HAL_NAMESPACE_BEGIN
 
 #define CV_SIMD128 1
-#define CV_SIMD128_64F 1
+#ifndef CV_RVV_THEAD_0_7
+#   define CV_SIMD128_64F 1
+#else
+#   define CV_SIMD128_64F 0
+#endif
 
 //////////// Unsupported native intrinsics in C++ ////////////
 // The following types have been defined in clang, but not in GCC yet.
@@ -1001,14 +1024,17 @@ OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint64x2, float32x4, u64, f32, u, f, 6
 OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(int8x16, float32x4, s8, f32, i, f, 8, 32)
 OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(int16x8, float32x4, s16, f32, i, f, 16, 32)
 OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(int64x2, float32x4, s64, f32, i, f, 64, 32)
+#if CV_SIMD128_64F
 OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint8x16, float64x2, u8, f64, u, f, 8, 64)
 OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint16x8, float64x2, u16, f64, u, f, 16, 64)
 OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint32x4, float64x2, u32, f64, u, f, 32, 64)
 OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(int8x16, float64x2, s8, f64, i, f, 8, 64)
 OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(int16x8, float64x2, s16, f64, i, f, 16, 64)
 OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(int32x4, float64x2, s32, f64, i, f, 32, 64)
+#endif
 
 // Three times reinterpret
+#if CV_SIMD128_64F
 inline v_float32x4 v_reinterpret_as_f32(const v_float64x2& v) \
 { \
     return v_float32x4(vreinterpret_v_u32m1_f32m1(vreinterpret_v_u64m1_u32m1(vreinterpret_v_f64m1_u64m1(v))));\
@@ -1017,6 +1043,7 @@ inline v_float64x2 v_reinterpret_as_f64(const v_float32x4& v) \
 { \
     return v_float64x2(vreinterpret_v_u64m1_f64m1(vreinterpret_v_u32m1_u64m1(vreinterpret_v_f32m1_u32m1(v))));\
 }
+#endif
 
 ////////////// Extract //////////////
 
@@ -1920,13 +1947,15 @@ inline v_float64x2 v_muladd(const v_float64x2& a, const v_float64x2& b, const v_
 #define OPENCV_HAL_IMPL_RVV_CHECK_ALLANY(_Tpvec, suffix, shift, vl) \
 inline bool v_check_all(const _Tpvec& a) \
 { \
-    v_uint64x2 v = v_uint64x2(vreinterpret_v_##suffix##m1_u64m1(vsrl_vx_##suffix##m1(vnot_v_##suffix##m1(a, vl), shift, vl))); \
-    return (v.val[0] | v.val[1]) == 0; \
+    auto v0 = vsrl_vx_##suffix##m1(vnot_v_##suffix##m1(a, vl), shift, vl); \
+    v_uint32x4 v = v_uint32x4(v_reinterpret_as_u32(_Tpvec(v0))); \
+    return (v.val[0] | v.val[1] | v.val[2] | v.val[3]) == 0; \
 } \
 inline bool v_check_any(const _Tpvec& a) \
 { \
-    v_uint64x2 v = v_uint64x2(vreinterpret_v_##suffix##m1_u64m1(vsrl_vx_##suffix##m1(a, shift, vl))); \
-    return (v.val[0] | v.val[1]) != 0; \
+    auto v0 = vsrl_vx_##suffix##m1(a, shift, vl); \
+    v_uint32x4 v = v_uint32x4(v_reinterpret_as_u32(_Tpvec(v0))); \
+    return (v.val[0] | v.val[1] | v.val[2] | v.val[3]) != 0; \
 }
 
 OPENCV_HAL_IMPL_RVV_CHECK_ALLANY(v_uint8x16, u8, 7, 16)
@@ -2042,28 +2071,18 @@ OPENCV_HAL_IMPL_RVV_ABSDIFF(v_float64x2, absdiff)
 OPENCV_HAL_IMPL_RVV_ABSDIFF(v_int8x16, absdiffs)
 OPENCV_HAL_IMPL_RVV_ABSDIFF(v_int16x8, absdiffs)
 
-// use reinterpret instead of c-style casting.
-#ifndef __clang__
-#define OPENCV_HAL_IMPL_RVV_ABSDIFF_S(_Tpvec, _rTpvec, _nwTpvec, sub, rshr, width, vl) \
-inline _rTpvec v_absdiff(const _Tpvec& a, const _Tpvec& b) \
+#define OPENCV_HAL_IMPL_RVV_ABSDIFF_S(ivec, uvec, itype, utype, isuf, usuf, vlen) \
+inline uvec v_absdiff(const ivec& a, const ivec& b) \
 { \
-    return _rTpvec(rshr(vreinterpret_v_i##width##m2_u##width##m2(sub(v_max(a, b), v_min(a, b), vl)), 0, vl)); \
+    itype max = vmax_vv_##isuf(a, b, vlen); \
+    itype min = vmin_vv_##isuf(a, b, vlen); \
+    return uvec(vreinterpret_v_##isuf##_##usuf(vsub_vv_##isuf(max, min, vlen))); \
 }
 
-OPENCV_HAL_IMPL_RVV_ABSDIFF_S(v_int8x16, v_uint8x16, vuint16m2_t, vwsub_vv_i16m2, vnclipu_wx_u8m1, 16, 16)
-OPENCV_HAL_IMPL_RVV_ABSDIFF_S(v_int16x8, v_uint16x8, vuint32m2_t, vwsub_vv_i32m2, vnclipu_wx_u16m1, 32, 8)
-OPENCV_HAL_IMPL_RVV_ABSDIFF_S(v_int32x4, v_uint32x4, vuint64m2_t, vwsub_vv_i64m2, vnclipu_wx_u32m1, 64, 4)
-#else
-#define OPENCV_HAL_IMPL_RVV_ABSDIFF_S(_Tpvec, _rTpvec, _nwTpvec, sub, rshr, width, vl) \
-inline _rTpvec v_absdiff(const _Tpvec& a, const _Tpvec& b) \
-{ \
-    return _rTpvec(rshr(vreinterpret_u##width##m2(sub(v_max(a, b), v_min(a, b), vl)), 0, vl)); \
-}
+OPENCV_HAL_IMPL_RVV_ABSDIFF_S(v_int8x16, v_uint8x16, vint8m1_t, vuint8m1_t, i8m1, u8m1, 16)
+OPENCV_HAL_IMPL_RVV_ABSDIFF_S(v_int16x8, v_uint16x8, vint16m1_t, vuint16m1_t, i16m1, u16m1, 8)
+OPENCV_HAL_IMPL_RVV_ABSDIFF_S(v_int32x4, v_uint32x4, vint32m1_t, vuint32m1_t, i32m1, u32m1, 4)
 
-OPENCV_HAL_IMPL_RVV_ABSDIFF_S(v_int8x16, v_uint8x16, vuint16m2_t, vwsub_vv_i16m2, vnclipu_wx_u8m1, 16, 16)
-OPENCV_HAL_IMPL_RVV_ABSDIFF_S(v_int16x8, v_uint16x8, vuint32m2_t, vwsub_vv_i32m2, vnclipu_wx_u16m1, 32, 8)
-OPENCV_HAL_IMPL_RVV_ABSDIFF_S(v_int32x4, v_uint32x4, vuint64m2_t, vwsub_vv_i64m2, vnclipu_wx_u32m1, 64, 4)
-#endif
 #define OPENCV_HAL_IMPL_RVV_ABS(_Tprvec, _Tpvec, suffix) \
 inline _Tprvec v_abs(const _Tpvec& a) \
 { \
@@ -2902,7 +2921,14 @@ inline v_int32x4 v_ceil(const v_float32x4& a)
 
 inline v_int32x4 v_trunc(const v_float32x4& a)
 {
+#ifndef CV_RVV_THEAD_0_7
     return v_int32x4(vfcvt_rtz_x_f_v_i32m1(a, 4));
+#else
+    const int old_round = fesetround(FE_TOWARDZERO);
+    vint32m1_t val = vfcvt_x_f_v_i32m1(a, 4);
+    fesetround(old_round);
+    return v_int32x4(val);
+#endif
 }
 #if CV_SIMD128_64F
 #ifndef __clang__
@@ -2938,7 +2964,14 @@ inline v_int32x4 v_trunc(const v_float64x2& a)
 {
     double arr[4] = {a.val[0], a.val[1], 0, 0};
     vfloat64m2_t tmp = vle64_v_f64m2(arr, 4);
+#ifndef CV_RVV_THEAD_0_7
     return v_int32x4(vfncvt_rtz_x_f_w_i32m1(tmp, 4));
+#else
+    const int old_round = fesetround(FE_TOWARDZERO);
+    vint32m1_t val = vfncvt_x_f_w_i32m1(tmp, 4);
+    fesetround(old_round);
+    return v_int32x4(val);
+#endif
 }
 
 #else

modules/core/include/opencv2/core/hal/intrin_rvv071.hpp

@@ -19,7 +19,7 @@ namespace cv
 CV_CPU_OPTIMIZATION_HAL_NAMESPACE_BEGIN
 
 #define CV_SIMD128 1
-#define CV_SIMD128_64F 1
+#define CV_SIMD128_64F 0
 //////////// Types ////////////
 struct v_uint8x16
 {
@@ -291,14 +291,14 @@ OPENCV_HAL_IMPL_RISCVV_BIN_OPN(+, v_uint16x8, vsaddu_vv_u16m1, 8)
 OPENCV_HAL_IMPL_RISCVV_BIN_OPN(-, v_uint16x8, vssubu_vv_u16m1, 8)
 OPENCV_HAL_IMPL_RISCVV_BIN_OPN(+, v_int16x8, vsadd_vv_i16m1, 8)
 OPENCV_HAL_IMPL_RISCVV_BIN_OPN(-, v_int16x8, vssub_vv_i16m1, 8)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(+, v_int32x4, vsadd_vv_i32m1, 4)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(-, v_int32x4, vssub_vv_i32m1, 4)
+OPENCV_HAL_IMPL_RISCVV_BIN_OPN(+, v_int32x4, vadd_vv_i32m1, 4)
+OPENCV_HAL_IMPL_RISCVV_BIN_OPN(-, v_int32x4, vsub_vv_i32m1, 4)
 OPENCV_HAL_IMPL_RISCVV_BIN_OPN(*, v_int32x4, vmul_vv_i32m1, 4)
 OPENCV_HAL_IMPL_RISCVV_BIN_OPN(+, v_uint32x4, vadd_vv_u32m1, 4)
 OPENCV_HAL_IMPL_RISCVV_BIN_OPN(-, v_uint32x4, vsub_vv_u32m1, 4)
 OPENCV_HAL_IMPL_RISCVV_BIN_OPN(*, v_uint32x4, vmul_vv_u32m1, 4)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(+, v_int64x2, vsadd_vv_i64m1, 2)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(-, v_int64x2, vssub_vv_i64m1, 2)
+OPENCV_HAL_IMPL_RISCVV_BIN_OPN(+, v_int64x2, vadd_vv_i64m1, 2)
+OPENCV_HAL_IMPL_RISCVV_BIN_OPN(-, v_int64x2, vsub_vv_i64m1, 2)
 OPENCV_HAL_IMPL_RISCVV_BIN_OPN(+, v_uint64x2, vadd_vv_u64m1, 2)
 OPENCV_HAL_IMPL_RISCVV_BIN_OPN(-, v_uint64x2, vsub_vv_u64m1, 2)
 OPENCV_HAL_IMPL_RISCVV_BIN_OPN(+, v_float32x4, vfadd_vv_f32m1, 4)
@@ -1909,14 +1909,14 @@ else return trailingZeros32(val); }
 inline bool v_check_all(const v_##_Tpvec& a) \
 { \
     suffix##m1_t v0 = vsrl_vx_##_T(vnot_v_##_T(a.val, num), shift, num); \
-    vuint64m1_t v1 = vuint64m1_t(v0); \
-    return (v1[0] | v1[1]) == 0; \
+    vuint32m1_t v1 = vuint32m1_t(v0); \
+    return (v1[0] | v1[1] | v1[2] | v1[3]) == 0; \
 } \
 inline bool v_check_any(const v_##_Tpvec& a) \
 { \
     suffix##m1_t v0 = vsrl_vx_##_T(a.val, shift, num); \
-    vuint64m1_t v1 = vuint64m1_t(v0); \
-    return (v1[0] | v1[1]) != 0; \
+    vuint32m1_t v1 = vuint32m1_t(v0); \
+    return (v1[0] | v1[1] | v1[2] | v1[3]) != 0; \
 }
 
 OPENCV_HAL_IMPL_RISCVV_CHECK_ALLANY(uint8x16, vuint8,  u8m1, 7, 16)
@@ -2021,23 +2021,18 @@ inline v_int32x4 v_load_expand_q(const schar* ptr)
     c = vwadd_vv_i32m2(vget_i16m2_i16m1(b, 0), vmv_v_x_i16m1(0, 4), 4);    \
     return v_int32x4(vget_i32m2_i32m1(c, 0));
 }
-#define VITL_16 (vuint64m2_t){0x1303120211011000, 0x1707160615051404, 0x1B0B1A0A19091808, 0x1F0F1E0E1D0D1C0C}
-#define VITL_8 (vuint64m2_t){0x0009000100080000, 0x000B0003000A0002, 0x000D0005000C0004, 0x000F0007000E0006}
-#define VITL_4 (vuint64m2_t){0x0000000400000000, 0x0000000500000001, 0x0000000600000002, 0x0000000700000003}
-#define VITL_2 (vuint64m2_t){0, 2, 1, 3}
-#define LOW_4  0x0000000100000000, 0x0000000500000004
-#define LOW_8  0x0003000200010000, 0x000B000A00090008
-#define LOW_16 0x0706050403020100, 0x1716151413121110
-#define HIGH_4  0x0000000300000002, 0x0000000700000006
-#define HIGH_8  0x0007000600050004, 0x000F000E000D000C
-#define HIGH_16 0x0F0E0D0C0B0A0908,  0x1F1E1D1C1B1A1918
+#define VITL_16 (vuint32m2_t){0x11011000, 0x13031202, 0x15051404, 0x17071606, 0x19091808, 0x1B0B1A0A, 0x1D0D1C0C, 0x1F0F1E0E}
+#define VITL_8 (vuint32m2_t){0x00080000, 0x00090001, 0x000A0002, 0x000B0003, 0x000C0004, 0x000D0005, 0x000E0006, 0x000F0007}
+#define VITL_4 (vuint32m2_t){0x00000000, 0x00000004, 0x00000001, 0x00000005, 0x00000002, 0x00000006, 0x00000003, 0x00000007}
+#define VITL_2 (vuint32m2_t){0, 0, 2, 0, 1, 0, 3, 0}
+
 #define OPENCV_HAL_IMPL_RISCVV_UNPACKS(_Tpvec, _Tp, _T, _UTp, _UT, num, num2, len, numh) \
 inline void v_zip(const v_##_Tpvec& a0, const v_##_Tpvec& a1, v_##_Tpvec& b0, v_##_Tpvec& b1) \
 { \
     v##_Tp##m2_t tmp = vundefined_##_T##m2();\
     tmp = vset_##_T##m2(tmp, 0, a0.val); \
     tmp = vset_##_T##m2(tmp, 1, a1.val); \
-    vuint64m2_t mask = VITL_##num;    \
+    vuint32m2_t mask = VITL_##num;    \
     tmp = (v##_Tp##m2_t)vrgather_vv_##_T##m2((v##_Tp##m2_t)tmp, (v##_UTp##m2_t)mask, num2);    \
     b0.val = vget_##_T##m2_##_T##m1(tmp, 0); \
     b1.val = vget_##_T##m2_##_T##m1(tmp, 1); \

modules/core/include/opencv2/core/hal/intrin_rvv_010_compat_overloaded-non-policy.hpp

@@ -0,0 +1,768 @@
+// 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.
+
+// Copied from
+// https://github.com/riscv-non-isa/rvv-intrinsic-doc/tree/master/auto-generated/rvv-v0p10-compatible-headers
+
+#ifndef __RVV_0P10_COMPATIBLE_HEADERS_OVERLOADED_NON_POLICY_H
+#define __RVV_0P10_COMPATIBLE_HEADERS_OVERLOADED_NON_POLICY_H
+
+
+// The maximum number of parameters is 20, this is held by segment load
+// instructions with a NFIELD (NF) of 8. 20 is contributed by 8 vector register
+// pointers passed, 1 vector mask register, 8 passthrough register for
+// undisturbed policy, and 3 for address base, byte index, vl.
+#define _GET_OVERRIDE(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13,\
+_14, _15, _16, _17, _18, _19, _20, NAME, ...) NAME
+
+
+#if __has_include ("riscv_vector.h")
+#include <riscv_vector.h>
+#endif
+#ifndef __RISCV_VECTOR_H
+#include_next <riscv_vector.h>
+#endif
+
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+#define vmerge(mask, op1, op2, vl) __riscv_vmerge((op1), (op2), (mask), (vl))
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+#define vfmerge(mask, op1, op2, vl) __riscv_vfmerge((op1), (op2), (mask), (vl))
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+// masked functions
+#define vcompress(mask, dest, src, vl) __riscv_vcompress_tu((dest), (src), (mask), (vl))
+// Reinterpret between different type under the same SEW/LMUL
+// Reinterpret between different SEW under the same LMUL
+#define vse16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vse16, __riscv_vse16, 2, 1)(__VA_ARGS__)
+#define vse32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vse32, __riscv_vse32, 2, 1)(__VA_ARGS__)
+#define vse64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vse64, __riscv_vse64, 2, 1)(__VA_ARGS__)
+#define vse8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vse8, __riscv_vse8, 2, 1)(__VA_ARGS__)
+#define vsse16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsse16, __riscv_vsse16, 3, 2, 1)(__VA_ARGS__)
+#define vsse32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsse32, __riscv_vsse32, 3, 2, 1)(__VA_ARGS__)
+#define vsse64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsse64, __riscv_vsse64, 3, 2, 1)(__VA_ARGS__)
+#define vsse8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsse8, __riscv_vsse8, 3, 2, 1)(__VA_ARGS__)
+#define vloxei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vloxei8_tumu, 4, __riscv_vloxei8, 2, 1)(__VA_ARGS__)
+#define vloxei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vloxei16_tumu, 4, __riscv_vloxei16, 2, 1)(__VA_ARGS__)
+#define vloxei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vloxei32_tumu, 4, __riscv_vloxei32, 2, 1)(__VA_ARGS__)
+#define vloxei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vloxei64_tumu, 4, __riscv_vloxei64, 2, 1)(__VA_ARGS__)
+#define vluxei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vluxei8_tumu, 4, __riscv_vluxei8, 2, 1)(__VA_ARGS__)
+#define vluxei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vluxei16_tumu, 4, __riscv_vluxei16, 2, 1)(__VA_ARGS__)
+#define vluxei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vluxei32_tumu, 4, __riscv_vluxei32, 2, 1)(__VA_ARGS__)
+#define vluxei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vluxei64_tumu, 4, __riscv_vluxei64, 2, 1)(__VA_ARGS__)
+#define vsoxei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsoxei8, __riscv_vsoxei8, 3, 2, 1)(__VA_ARGS__)
+#define vsoxei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsoxei16, __riscv_vsoxei16, 3, 2, 1)(__VA_ARGS__)
+#define vsoxei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsoxei32, __riscv_vsoxei32, 3, 2, 1)(__VA_ARGS__)
+#define vsoxei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsoxei64, __riscv_vsoxei64, 3, 2, 1)(__VA_ARGS__)
+#define vsuxei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsuxei8, __riscv_vsuxei8, 3, 2, 1)(__VA_ARGS__)
+#define vsuxei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsuxei16, __riscv_vsuxei16, 3, 2, 1)(__VA_ARGS__)
+#define vsuxei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsuxei32, __riscv_vsuxei32, 3, 2, 1)(__VA_ARGS__)
+#define vsuxei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsuxei64, __riscv_vsuxei64, 3, 2, 1)(__VA_ARGS__)
+#define vsseg2e16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsseg2e16, __riscv_vsseg2e16, 3, 2, 1)(__VA_ARGS__)
+#define vsseg3e16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, __riscv_vsseg3e16, __riscv_vsseg3e16, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg4e16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, __riscv_vsseg4e16, __riscv_vsseg4e16, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg5e16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vsseg5e16, __riscv_vsseg5e16, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg6e16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, __riscv_vsseg6e16, __riscv_vsseg6e16, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg7e16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vsseg7e16, __riscv_vsseg7e16, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg8e16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vsseg8e16, __riscv_vsseg8e16, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg2e32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsseg2e32, __riscv_vsseg2e32, 3, 2, 1)(__VA_ARGS__)
+#define vsseg3e32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, __riscv_vsseg3e32, __riscv_vsseg3e32, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg4e32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, __riscv_vsseg4e32, __riscv_vsseg4e32, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg5e32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vsseg5e32, __riscv_vsseg5e32, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg6e32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, __riscv_vsseg6e32, __riscv_vsseg6e32, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg7e32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vsseg7e32, __riscv_vsseg7e32, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg8e32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vsseg8e32, __riscv_vsseg8e32, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg2e64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsseg2e64, __riscv_vsseg2e64, 3, 2, 1)(__VA_ARGS__)
+#define vsseg3e64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, __riscv_vsseg3e64, __riscv_vsseg3e64, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg4e64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, __riscv_vsseg4e64, __riscv_vsseg4e64, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg5e64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vsseg5e64, __riscv_vsseg5e64, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg6e64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, __riscv_vsseg6e64, __riscv_vsseg6e64, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg7e64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vsseg7e64, __riscv_vsseg7e64, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg8e64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vsseg8e64, __riscv_vsseg8e64, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg2e8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsseg2e8, __riscv_vsseg2e8, 3, 2, 1)(__VA_ARGS__)
+#define vsseg3e8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, __riscv_vsseg3e8, __riscv_vsseg3e8, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg4e8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, __riscv_vsseg4e8, __riscv_vsseg4e8, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg5e8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vsseg5e8, __riscv_vsseg5e8, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg6e8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, __riscv_vsseg6e8, __riscv_vsseg6e8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg7e8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vsseg7e8, __riscv_vsseg7e8, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsseg8e8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vsseg8e8, __riscv_vsseg8e8, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg2e16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, __riscv_vssseg2e16, __riscv_vssseg2e16, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg3e16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, __riscv_vssseg3e16, __riscv_vssseg3e16, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg4e16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vssseg4e16, __riscv_vssseg4e16, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg5e16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, __riscv_vssseg5e16, __riscv_vssseg5e16, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg6e16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vssseg6e16, __riscv_vssseg6e16, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg7e16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vssseg7e16, __riscv_vssseg7e16, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg8e16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, __riscv_vssseg8e16, __riscv_vssseg8e16, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg2e32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, __riscv_vssseg2e32, __riscv_vssseg2e32, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg3e32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, __riscv_vssseg3e32, __riscv_vssseg3e32, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg4e32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vssseg4e32, __riscv_vssseg4e32, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg5e32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, __riscv_vssseg5e32, __riscv_vssseg5e32, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg6e32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vssseg6e32, __riscv_vssseg6e32, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg7e32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vssseg7e32, __riscv_vssseg7e32, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg8e32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, __riscv_vssseg8e32, __riscv_vssseg8e32, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg2e64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, __riscv_vssseg2e64, __riscv_vssseg2e64, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg3e64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, __riscv_vssseg3e64, __riscv_vssseg3e64, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg4e64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vssseg4e64, __riscv_vssseg4e64, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg5e64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, __riscv_vssseg5e64, __riscv_vssseg5e64, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg6e64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vssseg6e64, __riscv_vssseg6e64, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg7e64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vssseg7e64, __riscv_vssseg7e64, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg8e64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, __riscv_vssseg8e64, __riscv_vssseg8e64, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg2e8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, __riscv_vssseg2e8, __riscv_vssseg2e8, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg3e8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, __riscv_vssseg3e8, __riscv_vssseg3e8, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg4e8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vssseg4e8, __riscv_vssseg4e8, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg5e8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, __riscv_vssseg5e8, __riscv_vssseg5e8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg6e8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vssseg6e8, __riscv_vssseg6e8, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg7e8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vssseg7e8, __riscv_vssseg7e8, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vssseg8e8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, __riscv_vssseg8e8, __riscv_vssseg8e8, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg2ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vloxseg2ei8_tumu, 7, 6, __riscv_vloxseg2ei8, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg3ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vloxseg3ei8_tumu, 9, 8, 7, __riscv_vloxseg3ei8, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg4ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, __riscv_vloxseg4ei8_tumu, 11, 10, 9, 8, __riscv_vloxseg4ei8, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg5ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, __riscv_vloxseg5ei8_tumu, 13, 12, 11, 10, 9, __riscv_vloxseg5ei8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg6ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, __riscv_vloxseg6ei8_tumu, 15, 14, 13, 12, 11, 10, __riscv_vloxseg6ei8, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg7ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, __riscv_vloxseg7ei8_tumu, 17, 16, 15, 14, 13, 12, 11, __riscv_vloxseg7ei8, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg8ei8(...) _GET_OVERRIDE(__VA_ARGS__, __riscv_vloxseg8ei8_tumu, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vloxseg8ei8, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg2ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vloxseg2ei16_tumu, 7, 6, __riscv_vloxseg2ei16, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg3ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vloxseg3ei16_tumu, 9, 8, 7, __riscv_vloxseg3ei16, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg4ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, __riscv_vloxseg4ei16_tumu, 11, 10, 9, 8, __riscv_vloxseg4ei16, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg5ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, __riscv_vloxseg5ei16_tumu, 13, 12, 11, 10, 9, __riscv_vloxseg5ei16, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg6ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, __riscv_vloxseg6ei16_tumu, 15, 14, 13, 12, 11, 10, __riscv_vloxseg6ei16, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg7ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, __riscv_vloxseg7ei16_tumu, 17, 16, 15, 14, 13, 12, 11, __riscv_vloxseg7ei16, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg8ei16(...) _GET_OVERRIDE(__VA_ARGS__, __riscv_vloxseg8ei16_tumu, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vloxseg8ei16, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg2ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vloxseg2ei32_tumu, 7, 6, __riscv_vloxseg2ei32, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg3ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vloxseg3ei32_tumu, 9, 8, 7, __riscv_vloxseg3ei32, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg4ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, __riscv_vloxseg4ei32_tumu, 11, 10, 9, 8, __riscv_vloxseg4ei32, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg5ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, __riscv_vloxseg5ei32_tumu, 13, 12, 11, 10, 9, __riscv_vloxseg5ei32, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg6ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, __riscv_vloxseg6ei32_tumu, 15, 14, 13, 12, 11, 10, __riscv_vloxseg6ei32, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg7ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, __riscv_vloxseg7ei32_tumu, 17, 16, 15, 14, 13, 12, 11, __riscv_vloxseg7ei32, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg8ei32(...) _GET_OVERRIDE(__VA_ARGS__, __riscv_vloxseg8ei32_tumu, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vloxseg8ei32, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg2ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vloxseg2ei64_tumu, 7, 6, __riscv_vloxseg2ei64, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg3ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vloxseg3ei64_tumu, 9, 8, 7, __riscv_vloxseg3ei64, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg4ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, __riscv_vloxseg4ei64_tumu, 11, 10, 9, 8, __riscv_vloxseg4ei64, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg5ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, __riscv_vloxseg5ei64_tumu, 13, 12, 11, 10, 9, __riscv_vloxseg5ei64, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg6ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, __riscv_vloxseg6ei64_tumu, 15, 14, 13, 12, 11, 10, __riscv_vloxseg6ei64, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg7ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, __riscv_vloxseg7ei64_tumu, 17, 16, 15, 14, 13, 12, 11, __riscv_vloxseg7ei64, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vloxseg8ei64(...) _GET_OVERRIDE(__VA_ARGS__, __riscv_vloxseg8ei64_tumu, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vloxseg8ei64, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg2ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vluxseg2ei8_tumu, 7, 6, __riscv_vluxseg2ei8, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg3ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vluxseg3ei8_tumu, 9, 8, 7, __riscv_vluxseg3ei8, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg4ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, __riscv_vluxseg4ei8_tumu, 11, 10, 9, 8, __riscv_vluxseg4ei8, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg5ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, __riscv_vluxseg5ei8_tumu, 13, 12, 11, 10, 9, __riscv_vluxseg5ei8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg6ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, __riscv_vluxseg6ei8_tumu, 15, 14, 13, 12, 11, 10, __riscv_vluxseg6ei8, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg7ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, __riscv_vluxseg7ei8_tumu, 17, 16, 15, 14, 13, 12, 11, __riscv_vluxseg7ei8, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg8ei8(...) _GET_OVERRIDE(__VA_ARGS__, __riscv_vluxseg8ei8_tumu, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vluxseg8ei8, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg2ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vluxseg2ei16_tumu, 7, 6, __riscv_vluxseg2ei16, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg3ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vluxseg3ei16_tumu, 9, 8, 7, __riscv_vluxseg3ei16, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg4ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, __riscv_vluxseg4ei16_tumu, 11, 10, 9, 8, __riscv_vluxseg4ei16, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg5ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, __riscv_vluxseg5ei16_tumu, 13, 12, 11, 10, 9, __riscv_vluxseg5ei16, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg6ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, __riscv_vluxseg6ei16_tumu, 15, 14, 13, 12, 11, 10, __riscv_vluxseg6ei16, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg7ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, __riscv_vluxseg7ei16_tumu, 17, 16, 15, 14, 13, 12, 11, __riscv_vluxseg7ei16, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg8ei16(...) _GET_OVERRIDE(__VA_ARGS__, __riscv_vluxseg8ei16_tumu, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vluxseg8ei16, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg2ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vluxseg2ei32_tumu, 7, 6, __riscv_vluxseg2ei32, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg3ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vluxseg3ei32_tumu, 9, 8, 7, __riscv_vluxseg3ei32, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg4ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, __riscv_vluxseg4ei32_tumu, 11, 10, 9, 8, __riscv_vluxseg4ei32, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg5ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, __riscv_vluxseg5ei32_tumu, 13, 12, 11, 10, 9, __riscv_vluxseg5ei32, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg6ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, __riscv_vluxseg6ei32_tumu, 15, 14, 13, 12, 11, 10, __riscv_vluxseg6ei32, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg7ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, __riscv_vluxseg7ei32_tumu, 17, 16, 15, 14, 13, 12, 11, __riscv_vluxseg7ei32, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg8ei32(...) _GET_OVERRIDE(__VA_ARGS__, __riscv_vluxseg8ei32_tumu, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vluxseg8ei32, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg2ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vluxseg2ei64_tumu, 7, 6, __riscv_vluxseg2ei64, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg3ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vluxseg3ei64_tumu, 9, 8, 7, __riscv_vluxseg3ei64, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg4ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, __riscv_vluxseg4ei64_tumu, 11, 10, 9, 8, __riscv_vluxseg4ei64, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg5ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, __riscv_vluxseg5ei64_tumu, 13, 12, 11, 10, 9, __riscv_vluxseg5ei64, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg6ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, __riscv_vluxseg6ei64_tumu, 15, 14, 13, 12, 11, 10, __riscv_vluxseg6ei64, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg7ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, __riscv_vluxseg7ei64_tumu, 17, 16, 15, 14, 13, 12, 11, __riscv_vluxseg7ei64, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vluxseg8ei64(...) _GET_OVERRIDE(__VA_ARGS__, __riscv_vluxseg8ei64_tumu, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vluxseg8ei64, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg2ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, __riscv_vsoxseg2ei8, __riscv_vsoxseg2ei8, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg3ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, __riscv_vsoxseg3ei8, __riscv_vsoxseg3ei8, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg4ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vsoxseg4ei8, __riscv_vsoxseg4ei8, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg5ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, __riscv_vsoxseg5ei8, __riscv_vsoxseg5ei8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg6ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vsoxseg6ei8, __riscv_vsoxseg6ei8, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg7ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vsoxseg7ei8, __riscv_vsoxseg7ei8, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg8ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, __riscv_vsoxseg8ei8, __riscv_vsoxseg8ei8, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg2ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, __riscv_vsoxseg2ei16, __riscv_vsoxseg2ei16, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg3ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, __riscv_vsoxseg3ei16, __riscv_vsoxseg3ei16, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg4ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vsoxseg4ei16, __riscv_vsoxseg4ei16, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg5ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, __riscv_vsoxseg5ei16, __riscv_vsoxseg5ei16, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg6ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vsoxseg6ei16, __riscv_vsoxseg6ei16, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg7ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vsoxseg7ei16, __riscv_vsoxseg7ei16, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg8ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, __riscv_vsoxseg8ei16, __riscv_vsoxseg8ei16, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg2ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, __riscv_vsoxseg2ei32, __riscv_vsoxseg2ei32, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg3ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, __riscv_vsoxseg3ei32, __riscv_vsoxseg3ei32, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg4ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vsoxseg4ei32, __riscv_vsoxseg4ei32, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg5ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, __riscv_vsoxseg5ei32, __riscv_vsoxseg5ei32, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg6ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vsoxseg6ei32, __riscv_vsoxseg6ei32, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg7ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vsoxseg7ei32, __riscv_vsoxseg7ei32, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg8ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, __riscv_vsoxseg8ei32, __riscv_vsoxseg8ei32, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg2ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, __riscv_vsoxseg2ei64, __riscv_vsoxseg2ei64, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg3ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, __riscv_vsoxseg3ei64, __riscv_vsoxseg3ei64, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg4ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vsoxseg4ei64, __riscv_vsoxseg4ei64, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg5ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, __riscv_vsoxseg5ei64, __riscv_vsoxseg5ei64, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg6ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vsoxseg6ei64, __riscv_vsoxseg6ei64, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg7ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vsoxseg7ei64, __riscv_vsoxseg7ei64, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsoxseg8ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, __riscv_vsoxseg8ei64, __riscv_vsoxseg8ei64, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg2ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, __riscv_vsuxseg2ei8, __riscv_vsuxseg2ei8, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg3ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, __riscv_vsuxseg3ei8, __riscv_vsuxseg3ei8, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg4ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vsuxseg4ei8, __riscv_vsuxseg4ei8, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg5ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, __riscv_vsuxseg5ei8, __riscv_vsuxseg5ei8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg6ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vsuxseg6ei8, __riscv_vsuxseg6ei8, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg7ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vsuxseg7ei8, __riscv_vsuxseg7ei8, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg8ei8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, __riscv_vsuxseg8ei8, __riscv_vsuxseg8ei8, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg2ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, __riscv_vsuxseg2ei16, __riscv_vsuxseg2ei16, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg3ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, __riscv_vsuxseg3ei16, __riscv_vsuxseg3ei16, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg4ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vsuxseg4ei16, __riscv_vsuxseg4ei16, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg5ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, __riscv_vsuxseg5ei16, __riscv_vsuxseg5ei16, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg6ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vsuxseg6ei16, __riscv_vsuxseg6ei16, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg7ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vsuxseg7ei16, __riscv_vsuxseg7ei16, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg8ei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, __riscv_vsuxseg8ei16, __riscv_vsuxseg8ei16, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg2ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, __riscv_vsuxseg2ei32, __riscv_vsuxseg2ei32, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg3ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, __riscv_vsuxseg3ei32, __riscv_vsuxseg3ei32, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg4ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vsuxseg4ei32, __riscv_vsuxseg4ei32, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg5ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, __riscv_vsuxseg5ei32, __riscv_vsuxseg5ei32, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg6ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vsuxseg6ei32, __riscv_vsuxseg6ei32, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg7ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vsuxseg7ei32, __riscv_vsuxseg7ei32, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg8ei32(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, __riscv_vsuxseg8ei32, __riscv_vsuxseg8ei32, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg2ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, __riscv_vsuxseg2ei64, __riscv_vsuxseg2ei64, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg3ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, __riscv_vsuxseg3ei64, __riscv_vsuxseg3ei64, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg4ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, __riscv_vsuxseg4ei64, __riscv_vsuxseg4ei64, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg5ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, __riscv_vsuxseg5ei64, __riscv_vsuxseg5ei64, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg6ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, __riscv_vsuxseg6ei64, __riscv_vsuxseg6ei64, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg7ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, __riscv_vsuxseg7ei64, __riscv_vsuxseg7ei64, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vsuxseg8ei64(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, __riscv_vsuxseg8ei64, __riscv_vsuxseg8ei64, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+#define vadd(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vadd_tumu, 4, __riscv_vadd, 2, 1)(__VA_ARGS__)
+#define vsub(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsub_tumu, 4, __riscv_vsub, 2, 1)(__VA_ARGS__)
+#define vrsub(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vrsub_tumu, 4, __riscv_vrsub, 2, 1)(__VA_ARGS__)
+#define vneg(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vneg_tumu, 3, __riscv_vneg, 1)(__VA_ARGS__)
+#define vwadd_vv(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwadd_vv_tumu, 4, __riscv_vwadd_vv, 2, 1)(__VA_ARGS__)
+#define vwadd_vx(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwadd_vx_tumu, 4, __riscv_vwadd_vx, 2, 1)(__VA_ARGS__)
+#define vwadd_wv(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwadd_wv_tumu, 4, __riscv_vwadd_wv, 2, 1)(__VA_ARGS__)
+#define vwadd_wx(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwadd_wx_tumu, 4, __riscv_vwadd_wx, 2, 1)(__VA_ARGS__)
+#define vwsub_vv(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwsub_vv_tumu, 4, __riscv_vwsub_vv, 2, 1)(__VA_ARGS__)
+#define vwsub_vx(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwsub_vx_tumu, 4, __riscv_vwsub_vx, 2, 1)(__VA_ARGS__)
+#define vwsub_wv(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwsub_wv_tumu, 4, __riscv_vwsub_wv, 2, 1)(__VA_ARGS__)
+#define vwsub_wx(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwsub_wx_tumu, 4, __riscv_vwsub_wx, 2, 1)(__VA_ARGS__)
+#define vwaddu_vv(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwaddu_vv_tumu, 4, __riscv_vwaddu_vv, 2, 1)(__VA_ARGS__)
+#define vwaddu_vx(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwaddu_vx_tumu, 4, __riscv_vwaddu_vx, 2, 1)(__VA_ARGS__)
+#define vwaddu_wv(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwaddu_wv_tumu, 4, __riscv_vwaddu_wv, 2, 1)(__VA_ARGS__)
+#define vwaddu_wx(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwaddu_wx_tumu, 4, __riscv_vwaddu_wx, 2, 1)(__VA_ARGS__)
+#define vwsubu_vv(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwsubu_vv_tumu, 4, __riscv_vwsubu_vv, 2, 1)(__VA_ARGS__)
+#define vwsubu_vx(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwsubu_vx_tumu, 4, __riscv_vwsubu_vx, 2, 1)(__VA_ARGS__)
+#define vwsubu_wv(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwsubu_wv_tumu, 4, __riscv_vwsubu_wv, 2, 1)(__VA_ARGS__)
+#define vwsubu_wx(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwsubu_wx_tumu, 4, __riscv_vwsubu_wx, 2, 1)(__VA_ARGS__)
+#define vsext_vf2(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vsext_vf2_tumu, 3, __riscv_vsext_vf2, 1)(__VA_ARGS__)
+#define vsext_vf4(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vsext_vf4_tumu, 3, __riscv_vsext_vf4, 1)(__VA_ARGS__)
+#define vsext_vf8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vsext_vf8_tumu, 3, __riscv_vsext_vf8, 1)(__VA_ARGS__)
+#define vzext_vf2(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vzext_vf2_tumu, 3, __riscv_vzext_vf2, 1)(__VA_ARGS__)
+#define vzext_vf4(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vzext_vf4_tumu, 3, __riscv_vzext_vf4, 1)(__VA_ARGS__)
+#define vzext_vf8(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vzext_vf8_tumu, 3, __riscv_vzext_vf8, 1)(__VA_ARGS__)
+#define vadc(...) __riscv_vadc(__VA_ARGS__)
+#define vsbc(...) __riscv_vsbc(__VA_ARGS__)
+#define vmadc(...) __riscv_vmadc(__VA_ARGS__)
+#define vmsbc(...) __riscv_vmsbc(__VA_ARGS__)
+#define vand(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vand_tumu, 4, __riscv_vand, 2, 1)(__VA_ARGS__)
+#define vor(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vor_tumu, 4, __riscv_vor, 2, 1)(__VA_ARGS__)
+#define vxor(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vxor_tumu, 4, __riscv_vxor, 2, 1)(__VA_ARGS__)
+#define vnot(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vnot_tumu, 3, __riscv_vnot, 1)(__VA_ARGS__)
+#define vsll(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsll_tumu, 4, __riscv_vsll, 2, 1)(__VA_ARGS__)
+#define vsra(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsra_tumu, 4, __riscv_vsra, 2, 1)(__VA_ARGS__)
+#define vsrl(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsrl_tumu, 4, __riscv_vsrl, 2, 1)(__VA_ARGS__)
+#define vnsra(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vnsra_tumu, 4, __riscv_vnsra, 2, 1)(__VA_ARGS__)
+#define vnsrl(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vnsrl_tumu, 4, __riscv_vnsrl, 2, 1)(__VA_ARGS__)
+#define vmseq(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmseq_mu, 4, __riscv_vmseq, 2, 1)(__VA_ARGS__)
+#define vmsne(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmsne_mu, 4, __riscv_vmsne, 2, 1)(__VA_ARGS__)
+#define vmslt(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmslt_mu, 4, __riscv_vmslt, 2, 1)(__VA_ARGS__)
+#define vmsle(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmsle_mu, 4, __riscv_vmsle, 2, 1)(__VA_ARGS__)
+#define vmsgt(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmsgt_mu, 4, __riscv_vmsgt, 2, 1)(__VA_ARGS__)
+#define vmsge(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmsge_mu, 4, __riscv_vmsge, 2, 1)(__VA_ARGS__)
+#define vmsltu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmsltu_mu, 4, __riscv_vmsltu, 2, 1)(__VA_ARGS__)
+#define vmsleu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmsleu_mu, 4, __riscv_vmsleu, 2, 1)(__VA_ARGS__)
+#define vmsgtu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmsgtu_mu, 4, __riscv_vmsgtu, 2, 1)(__VA_ARGS__)
+#define vmsgeu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmsgeu_mu, 4, __riscv_vmsgeu, 2, 1)(__VA_ARGS__)
+#define vmin(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmin_tumu, 4, __riscv_vmin, 2, 1)(__VA_ARGS__)
+#define vmax(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmax_tumu, 4, __riscv_vmax, 2, 1)(__VA_ARGS__)
+#define vminu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vminu_tumu, 4, __riscv_vminu, 2, 1)(__VA_ARGS__)
+#define vmaxu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmaxu_tumu, 4, __riscv_vmaxu, 2, 1)(__VA_ARGS__)
+#define vmul(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmul_tumu, 4, __riscv_vmul, 2, 1)(__VA_ARGS__)
+#define vmulh(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmulh_tumu, 4, __riscv_vmulh, 2, 1)(__VA_ARGS__)
+#define vmulhsu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmulhsu_tumu, 4, __riscv_vmulhsu, 2, 1)(__VA_ARGS__)
+#define vmulhu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmulhu_tumu, 4, __riscv_vmulhu, 2, 1)(__VA_ARGS__)
+#define vdiv(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vdiv_tumu, 4, __riscv_vdiv, 2, 1)(__VA_ARGS__)
+#define vrem(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vrem_tumu, 4, __riscv_vrem, 2, 1)(__VA_ARGS__)
+#define vdivu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vdivu_tumu, 4, __riscv_vdivu, 2, 1)(__VA_ARGS__)
+#define vremu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vremu_tumu, 4, __riscv_vremu, 2, 1)(__VA_ARGS__)
+#define vwmul(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwmul_tumu, 4, __riscv_vwmul, 2, 1)(__VA_ARGS__)
+#define vwmulsu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwmulsu_tumu, 4, __riscv_vwmulsu, 2, 1)(__VA_ARGS__)
+#define vwmulu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwmulu_tumu, 4, __riscv_vwmulu, 2, 1)(__VA_ARGS__)
+#define vmacc(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmacc_tumu, __riscv_vmacc_tu, 3, 2, 1)(__VA_ARGS__)
+#define vnmsac(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vnmsac_tumu, __riscv_vnmsac_tu, 3, 2, 1)(__VA_ARGS__)
+#define vmadd(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmadd_tumu, __riscv_vmadd_tu, 3, 2, 1)(__VA_ARGS__)
+#define vnmsub(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vnmsub_tumu, __riscv_vnmsub_tu, 3, 2, 1)(__VA_ARGS__)
+#define vwmacc(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwmacc_tumu, __riscv_vwmacc_tu, 3, 2, 1)(__VA_ARGS__)
+#define vwmaccsu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwmaccsu_tumu, __riscv_vwmaccsu_tu, 3, 2, 1)(__VA_ARGS__)
+#define vwmaccus(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwmaccus_tumu, __riscv_vwmaccus_tu, 3, 2, 1)(__VA_ARGS__)
+#define vwmaccu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwmaccu_tumu, __riscv_vwmaccu_tu, 3, 2, 1)(__VA_ARGS__)
+#define vmv_v(...) __riscv_vmv_v(__VA_ARGS__)
+#define vsadd(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsadd_tumu, 4, __riscv_vsadd, 2, 1)(__VA_ARGS__)
+#define vssub(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vssub_tumu, 4, __riscv_vssub, 2, 1)(__VA_ARGS__)
+#define vsaddu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsaddu_tumu, 4, __riscv_vsaddu, 2, 1)(__VA_ARGS__)
+#define vssubu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vssubu_tumu, 4, __riscv_vssubu, 2, 1)(__VA_ARGS__)
+#define vaadd(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vaadd_tumu, 4, __riscv_vaadd, 2, 1)(__VA_ARGS__)
+#define vasub(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vasub_tumu, 4, __riscv_vasub, 2, 1)(__VA_ARGS__)
+#define vaaddu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vaaddu_tumu, 4, __riscv_vaaddu, 2, 1)(__VA_ARGS__)
+#define vasubu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vasubu_tumu, 4, __riscv_vasubu, 2, 1)(__VA_ARGS__)
+#define vsmul(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vsmul_mu, 4, __riscv_vsmul, 2, 1)(__VA_ARGS__)
+#define vssra(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vssra_tumu, 4, __riscv_vssra, 2, 1)(__VA_ARGS__)
+#define vssrl(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vssrl_tumu, 4, __riscv_vssrl, 2, 1)(__VA_ARGS__)
+#define vnclip(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vnclip_tumu, 4, __riscv_vnclip, 2, 1)(__VA_ARGS__)
+#define vnclipu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vnclipu_tumu, 4, __riscv_vnclipu, 2, 1)(__VA_ARGS__)
+#define vfadd(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfadd_tumu, 4, __riscv_vfadd, 2, 1)(__VA_ARGS__)
+#define vfsub(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfsub_tumu, 4, __riscv_vfsub, 2, 1)(__VA_ARGS__)
+#define vfrsub(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfrsub_tumu, 4, __riscv_vfrsub, 2, 1)(__VA_ARGS__)
+#define vfneg(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfneg_tumu, 3, __riscv_vfneg, 1)(__VA_ARGS__)
+#define vfwadd_vv(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfwadd_vv_tumu, 4, __riscv_vfwadd_vv, 2, 1)(__VA_ARGS__)
+#define vfwadd_vf(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfwadd_vf_tumu, 4, __riscv_vfwadd_vf, 2, 1)(__VA_ARGS__)
+#define vfwadd_wv(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfwadd_wv_tumu, 4, __riscv_vfwadd_wv, 2, 1)(__VA_ARGS__)
+#define vfwadd_wf(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfwadd_wf_tumu, 4, __riscv_vfwadd_wf, 2, 1)(__VA_ARGS__)
+#define vfwsub_vv(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfwsub_vv_tumu, 4, __riscv_vfwsub_vv, 2, 1)(__VA_ARGS__)
+#define vfwsub_vf(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfwsub_vf_tumu, 4, __riscv_vfwsub_vf, 2, 1)(__VA_ARGS__)
+#define vfwsub_wv(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfwsub_wv_tumu, 4, __riscv_vfwsub_wv, 2, 1)(__VA_ARGS__)
+#define vfwsub_wf(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfwsub_wf_tumu, 4, __riscv_vfwsub_wf, 2, 1)(__VA_ARGS__)
+#define vfmul(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfmul_tumu, 4, __riscv_vfmul, 2, 1)(__VA_ARGS__)
+#define vfdiv(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfdiv_tumu, 4, __riscv_vfdiv, 2, 1)(__VA_ARGS__)
+#define vfrdiv(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfrdiv_tumu, 4, __riscv_vfrdiv, 2, 1)(__VA_ARGS__)
+#define vfwmul(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfwmul_tumu, 4, __riscv_vfwmul, 2, 1)(__VA_ARGS__)
+#define vfmacc(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfmacc_tumu, __riscv_vfmacc_tu, 3, 2, 1)(__VA_ARGS__)
+#define vfnmacc(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfnmacc_tumu, __riscv_vfnmacc_tu, 3, 2, 1)(__VA_ARGS__)
+#define vfmsac(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfmsac_tumu, __riscv_vfmsac_tu, 3, 2, 1)(__VA_ARGS__)
+#define vfnmsac(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfnmsac_tumu, __riscv_vfnmsac_tu, 3, 2, 1)(__VA_ARGS__)
+#define vfmadd(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfmadd_tumu, __riscv_vfmadd_tu, 3, 2, 1)(__VA_ARGS__)
+#define vfnmadd(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfnmadd_tumu, __riscv_vfnmadd_tu, 3, 2, 1)(__VA_ARGS__)
+#define vfmsub(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfmsub_tumu, __riscv_vfmsub_tu, 3, 2, 1)(__VA_ARGS__)
+#define vfnmsub(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfnmsub_tumu, __riscv_vfnmsub_tu, 3, 2, 1)(__VA_ARGS__)
+#define vfwmacc(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfwmacc_tumu, __riscv_vfwmacc_tu, 3, 2, 1)(__VA_ARGS__)
+#define vfwnmacc(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfwnmacc_tumu, __riscv_vfwnmacc_tu, 3, 2, 1)(__VA_ARGS__)
+#define vfwmsac(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfwmsac_tumu, __riscv_vfwmsac_tu, 3, 2, 1)(__VA_ARGS__)
+#define vfwnmsac(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfwnmsac_tumu, __riscv_vfwnmsac_tu, 3, 2, 1)(__VA_ARGS__)
+#define vfsqrt(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfsqrt_tumu, 3, __riscv_vfsqrt, 1)(__VA_ARGS__)
+#define vfrsqrt7(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfrsqrt7_tumu, 3, __riscv_vfrsqrt7, 1)(__VA_ARGS__)
+#define vfrec7(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfrec7_tumu, 3, __riscv_vfrec7, 1)(__VA_ARGS__)
+#define vfmin(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfmin_tumu, 4, __riscv_vfmin, 2, 1)(__VA_ARGS__)
+#define vfmax(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfmax_tumu, 4, __riscv_vfmax, 2, 1)(__VA_ARGS__)
+#define vfsgnj(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfsgnj_tumu, 4, __riscv_vfsgnj, 2, 1)(__VA_ARGS__)
+#define vfsgnjn(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfsgnjn_tumu, 4, __riscv_vfsgnjn, 2, 1)(__VA_ARGS__)
+#define vfsgnjx(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfsgnjx_tumu, 4, __riscv_vfsgnjx, 2, 1)(__VA_ARGS__)
+#define vfabs(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfabs_tumu, 3, __riscv_vfabs, 1)(__VA_ARGS__)
+#define vmfeq(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmfeq_mu, 4, __riscv_vmfeq, 2, 1)(__VA_ARGS__)
+#define vmfne(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmfne_mu, 4, __riscv_vmfne, 2, 1)(__VA_ARGS__)
+#define vmflt(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmflt_mu, 4, __riscv_vmflt, 2, 1)(__VA_ARGS__)
+#define vmfle(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmfle_mu, 4, __riscv_vmfle, 2, 1)(__VA_ARGS__)
+#define vmfgt(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmfgt_mu, 4, __riscv_vmfgt, 2, 1)(__VA_ARGS__)
+#define vmfge(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vmfge_mu, 4, __riscv_vmfge, 2, 1)(__VA_ARGS__)
+#define vfclass(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfclass_tumu, 3, __riscv_vfclass, 1)(__VA_ARGS__)
+#define vfcvt_x(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfcvt_x_tumu, 3, __riscv_vfcvt_x, 1)(__VA_ARGS__)
+#define vfcvt_rtz_x(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfcvt_rtz_x_tumu, 3, __riscv_vfcvt_rtz_x, 1)(__VA_ARGS__)
+#define vfcvt_xu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfcvt_xu_tumu, 3, __riscv_vfcvt_xu, 1)(__VA_ARGS__)
+#define vfcvt_rtz_xu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfcvt_rtz_xu_tumu, 3, __riscv_vfcvt_rtz_xu, 1)(__VA_ARGS__)
+#define vfcvt_f(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfcvt_f_tumu, 3, __riscv_vfcvt_f, 1)(__VA_ARGS__)
+#define vwcvt_x(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vwcvt_x_tumu, 3, __riscv_vwcvt_x, 1)(__VA_ARGS__)
+#define vwcvtu_x(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vwcvtu_x_tumu, 3, __riscv_vwcvtu_x, 1)(__VA_ARGS__)
+#define vfwcvt_f(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfwcvt_f_tumu, 3, __riscv_vfwcvt_f, 1)(__VA_ARGS__)
+#define vfwcvt_x(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfwcvt_x_tumu, 3, __riscv_vfwcvt_x, 1)(__VA_ARGS__)
+#define vfwcvt_rtz_x(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfwcvt_rtz_x_tumu, 3, __riscv_vfwcvt_rtz_x, 1)(__VA_ARGS__)
+#define vfwcvt_xu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfwcvt_xu_tumu, 3, __riscv_vfwcvt_xu, 1)(__VA_ARGS__)
+#define vfwcvt_rtz_xu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfwcvt_rtz_xu_tumu, 3, __riscv_vfwcvt_rtz_xu, 1)(__VA_ARGS__)
+#define vfncvt_x(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfncvt_x_tumu, 3, __riscv_vfncvt_x, 1)(__VA_ARGS__)
+#define vfncvt_rtz_x(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfncvt_rtz_x_tumu, 3, __riscv_vfncvt_rtz_x, 1)(__VA_ARGS__)
+#define vncvt_x(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vncvt_x_tumu, 3, __riscv_vncvt_x, 1)(__VA_ARGS__)
+#define vfncvt_xu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfncvt_xu_tumu, 3, __riscv_vfncvt_xu, 1)(__VA_ARGS__)
+#define vfncvt_rtz_xu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfncvt_rtz_xu_tumu, 3, __riscv_vfncvt_rtz_xu, 1)(__VA_ARGS__)
+#define vfncvt_f(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfncvt_f_tumu, 3, __riscv_vfncvt_f, 1)(__VA_ARGS__)
+#define vfncvt_rod_f(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vfncvt_rod_f_tumu, 3, __riscv_vfncvt_rod_f, 1)(__VA_ARGS__)
+#define vredsum(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vredsum_tum, __riscv_vredsum_tu, 3, 2, 1)(__VA_ARGS__)
+#define vredmax(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vredmax_tum, __riscv_vredmax_tu, 3, 2, 1)(__VA_ARGS__)
+#define vredmin(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vredmin_tum, __riscv_vredmin_tu, 3, 2, 1)(__VA_ARGS__)
+#define vredand(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vredand_tum, __riscv_vredand_tu, 3, 2, 1)(__VA_ARGS__)
+#define vredor(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vredor_tum, __riscv_vredor_tu, 3, 2, 1)(__VA_ARGS__)
+#define vredxor(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vredxor_tum, __riscv_vredxor_tu, 3, 2, 1)(__VA_ARGS__)
+#define vredmaxu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vredmaxu_tum, __riscv_vredmaxu_tu, 3, 2, 1)(__VA_ARGS__)
+#define vredminu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vredminu_tum, __riscv_vredminu_tu, 3, 2, 1)(__VA_ARGS__)
+#define vwredsum(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwredsum_tum, __riscv_vwredsum_tu, 3, 2, 1)(__VA_ARGS__)
+#define vwredsumu(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vwredsumu_tum, __riscv_vwredsumu_tu, 3, 2, 1)(__VA_ARGS__)
+#define vfredosum(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfredosum_tum, __riscv_vfredosum_tu, 3, 2, 1)(__VA_ARGS__)
+#define vfredusum(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfredusum_tum, __riscv_vfredusum_tu, 3, 2, 1)(__VA_ARGS__)
+#define vfredmax(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfredmax_tum, __riscv_vfredmax_tu, 3, 2, 1)(__VA_ARGS__)
+#define vfredmin(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfredmin_tum, __riscv_vfredmin_tu, 3, 2, 1)(__VA_ARGS__)
+#define vfwredosum(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfwredosum_tum, __riscv_vfwredosum_tu, 3, 2, 1)(__VA_ARGS__)
+#define vfwredusum(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfwredusum_tum, __riscv_vfwredusum_tu, 3, 2, 1)(__VA_ARGS__)
+#define vsm(...) __riscv_vsm(__VA_ARGS__)
+#define vmand(...) __riscv_vmand(__VA_ARGS__)
+#define vmnand(...) __riscv_vmnand(__VA_ARGS__)
+#define vmandn(...) __riscv_vmandn(__VA_ARGS__)
+#define vmxor(...) __riscv_vmxor(__VA_ARGS__)
+#define vmor(...) __riscv_vmor(__VA_ARGS__)
+#define vmnor(...) __riscv_vmnor(__VA_ARGS__)
+#define vmorn(...) __riscv_vmorn(__VA_ARGS__)
+#define vmxnor(...) __riscv_vmxnor(__VA_ARGS__)
+#define vmmv(...) __riscv_vmmv(__VA_ARGS__)
+#define vmnot(...) __riscv_vmnot(__VA_ARGS__)
+#define vcpop(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, __riscv_vcpop, __riscv_vcpop, 1)(__VA_ARGS__)
+#define vfirst(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, __riscv_vfirst, __riscv_vfirst, 1)(__VA_ARGS__)
+#define vmsbf(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vmsbf_mu, 3, __riscv_vmsbf, 1)(__VA_ARGS__)
+#define vmsif(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vmsif_mu, 3, __riscv_vmsif, 1)(__VA_ARGS__)
+#define vmsof(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, __riscv_vmsof_mu, 3, __riscv_vmsof, 1)(__VA_ARGS__)
+#define vfmv_f(...) __riscv_vfmv_f(__VA_ARGS__)
+#define vfmv_s(...) __riscv_vfmv_s_tu(__VA_ARGS__)
+#define vmv_x(...) __riscv_vmv_x(__VA_ARGS__)
+#define vmv_s(...) __riscv_vmv_s_tu(__VA_ARGS__)
+#define vslideup(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vslideup_tumu, __riscv_vslideup_tu, 3, 2, 1)(__VA_ARGS__)
+#define vslidedown(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vslidedown_tumu, __riscv_vslidedown_tu, 3, 2, 1)(__VA_ARGS__)
+#define vfslide1up(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfslide1up_tumu, 4, __riscv_vfslide1up, 2, 1)(__VA_ARGS__)
+#define vfslide1down(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vfslide1down_tumu, 4, __riscv_vfslide1down, 2, 1)(__VA_ARGS__)
+#define vslide1up(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vslide1up_tumu, 4, __riscv_vslide1up, 2, 1)(__VA_ARGS__)
+#define vslide1down(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vslide1down_tumu, 4, __riscv_vslide1down, 2, 1)(__VA_ARGS__)
+#define vrgather(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vrgather_tumu, 4, __riscv_vrgather, 2, 1)(__VA_ARGS__)
+#define vrgatherei16(...) _GET_OVERRIDE(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, __riscv_vrgatherei16_tumu, 4, __riscv_vrgatherei16, 2, 1)(__VA_ARGS__)
+#define vreinterpret_u8mf8(...) __riscv_vreinterpret_u8mf8(__VA_ARGS__)
+#define vreinterpret_u8mf4(...) __riscv_vreinterpret_u8mf4(__VA_ARGS__)
+#define vreinterpret_u8mf2(...) __riscv_vreinterpret_u8mf2(__VA_ARGS__)
+#define vreinterpret_u8m1(...) __riscv_vreinterpret_u8m1(__VA_ARGS__)
+#define vreinterpret_u8m2(...) __riscv_vreinterpret_u8m2(__VA_ARGS__)
+#define vreinterpret_u8m4(...) __riscv_vreinterpret_u8m4(__VA_ARGS__)
+#define vreinterpret_u8m8(...) __riscv_vreinterpret_u8m8(__VA_ARGS__)
+#define vreinterpret_i8mf8(...) __riscv_vreinterpret_i8mf8(__VA_ARGS__)
+#define vreinterpret_i8mf4(...) __riscv_vreinterpret_i8mf4(__VA_ARGS__)
+#define vreinterpret_i8mf2(...) __riscv_vreinterpret_i8mf2(__VA_ARGS__)
+#define vreinterpret_i8m1(...) __riscv_vreinterpret_i8m1(__VA_ARGS__)
+#define vreinterpret_i8m2(...) __riscv_vreinterpret_i8m2(__VA_ARGS__)
+#define vreinterpret_i8m4(...) __riscv_vreinterpret_i8m4(__VA_ARGS__)
+#define vreinterpret_i8m8(...) __riscv_vreinterpret_i8m8(__VA_ARGS__)
+#define vreinterpret_f16mf4(...) __riscv_vreinterpret_f16mf4(__VA_ARGS__)
+#define vreinterpret_f16mf2(...) __riscv_vreinterpret_f16mf2(__VA_ARGS__)
+#define vreinterpret_f16m1(...) __riscv_vreinterpret_f16m1(__VA_ARGS__)
+#define vreinterpret_f16m2(...) __riscv_vreinterpret_f16m2(__VA_ARGS__)
+#define vreinterpret_f16m4(...) __riscv_vreinterpret_f16m4(__VA_ARGS__)
+#define vreinterpret_f16m8(...) __riscv_vreinterpret_f16m8(__VA_ARGS__)
+#define vreinterpret_u16mf4(...) __riscv_vreinterpret_u16mf4(__VA_ARGS__)
+#define vreinterpret_u16mf2(...) __riscv_vreinterpret_u16mf2(__VA_ARGS__)
+#define vreinterpret_u16m1(...) __riscv_vreinterpret_u16m1(__VA_ARGS__)
+#define vreinterpret_u16m2(...) __riscv_vreinterpret_u16m2(__VA_ARGS__)
+#define vreinterpret_u16m4(...) __riscv_vreinterpret_u16m4(__VA_ARGS__)
+#define vreinterpret_u16m8(...) __riscv_vreinterpret_u16m8(__VA_ARGS__)
+#define vreinterpret_i16mf4(...) __riscv_vreinterpret_i16mf4(__VA_ARGS__)
+#define vreinterpret_i16mf2(...) __riscv_vreinterpret_i16mf2(__VA_ARGS__)
+#define vreinterpret_i16m1(...) __riscv_vreinterpret_i16m1(__VA_ARGS__)
+#define vreinterpret_i16m2(...) __riscv_vreinterpret_i16m2(__VA_ARGS__)
+#define vreinterpret_i16m4(...) __riscv_vreinterpret_i16m4(__VA_ARGS__)
+#define vreinterpret_i16m8(...) __riscv_vreinterpret_i16m8(__VA_ARGS__)
+#define vreinterpret_f32mf2(...) __riscv_vreinterpret_f32mf2(__VA_ARGS__)
+#define vreinterpret_f32m1(...) __riscv_vreinterpret_f32m1(__VA_ARGS__)
+#define vreinterpret_f32m2(...) __riscv_vreinterpret_f32m2(__VA_ARGS__)
+#define vreinterpret_f32m4(...) __riscv_vreinterpret_f32m4(__VA_ARGS__)
+#define vreinterpret_f32m8(...) __riscv_vreinterpret_f32m8(__VA_ARGS__)
+#define vreinterpret_u32mf2(...) __riscv_vreinterpret_u32mf2(__VA_ARGS__)
+#define vreinterpret_u32m1(...) __riscv_vreinterpret_u32m1(__VA_ARGS__)
+#define vreinterpret_u32m2(...) __riscv_vreinterpret_u32m2(__VA_ARGS__)
+#define vreinterpret_u32m4(...) __riscv_vreinterpret_u32m4(__VA_ARGS__)
+#define vreinterpret_u32m8(...) __riscv_vreinterpret_u32m8(__VA_ARGS__)
+#define vreinterpret_i32mf2(...) __riscv_vreinterpret_i32mf2(__VA_ARGS__)
+#define vreinterpret_i32m1(...) __riscv_vreinterpret_i32m1(__VA_ARGS__)
+#define vreinterpret_i32m2(...) __riscv_vreinterpret_i32m2(__VA_ARGS__)
+#define vreinterpret_i32m4(...) __riscv_vreinterpret_i32m4(__VA_ARGS__)
+#define vreinterpret_i32m8(...) __riscv_vreinterpret_i32m8(__VA_ARGS__)
+#define vreinterpret_f64m1(...) __riscv_vreinterpret_f64m1(__VA_ARGS__)
+#define vreinterpret_f64m2(...) __riscv_vreinterpret_f64m2(__VA_ARGS__)
+#define vreinterpret_f64m4(...) __riscv_vreinterpret_f64m4(__VA_ARGS__)
+#define vreinterpret_f64m8(...) __riscv_vreinterpret_f64m8(__VA_ARGS__)
+#define vreinterpret_u64m1(...) __riscv_vreinterpret_u64m1(__VA_ARGS__)
+#define vreinterpret_u64m2(...) __riscv_vreinterpret_u64m2(__VA_ARGS__)
+#define vreinterpret_u64m4(...) __riscv_vreinterpret_u64m4(__VA_ARGS__)
+#define vreinterpret_u64m8(...) __riscv_vreinterpret_u64m8(__VA_ARGS__)
+#define vreinterpret_i64m1(...) __riscv_vreinterpret_i64m1(__VA_ARGS__)
+#define vreinterpret_i64m2(...) __riscv_vreinterpret_i64m2(__VA_ARGS__)
+#define vreinterpret_i64m4(...) __riscv_vreinterpret_i64m4(__VA_ARGS__)
+#define vreinterpret_i64m8(...) __riscv_vreinterpret_i64m8(__VA_ARGS__)
+#define vlmul_ext_f16mf2(...) __riscv_vlmul_ext_f16mf2(__VA_ARGS__)
+#define vlmul_ext_f16m1(...) __riscv_vlmul_ext_f16m1(__VA_ARGS__)
+#define vlmul_ext_f16m2(...) __riscv_vlmul_ext_f16m2(__VA_ARGS__)
+#define vlmul_ext_f16m4(...) __riscv_vlmul_ext_f16m4(__VA_ARGS__)
+#define vlmul_ext_f16m8(...) __riscv_vlmul_ext_f16m8(__VA_ARGS__)
+#define vlmul_ext_f32m1(...) __riscv_vlmul_ext_f32m1(__VA_ARGS__)
+#define vlmul_ext_f32m2(...) __riscv_vlmul_ext_f32m2(__VA_ARGS__)
+#define vlmul_ext_f32m4(...) __riscv_vlmul_ext_f32m4(__VA_ARGS__)
+#define vlmul_ext_f32m8(...) __riscv_vlmul_ext_f32m8(__VA_ARGS__)
+#define vlmul_ext_f64m2(...) __riscv_vlmul_ext_f64m2(__VA_ARGS__)
+#define vlmul_ext_f64m4(...) __riscv_vlmul_ext_f64m4(__VA_ARGS__)
+#define vlmul_ext_f64m8(...) __riscv_vlmul_ext_f64m8(__VA_ARGS__)
+#define vlmul_ext_i8mf4(...) __riscv_vlmul_ext_i8mf4(__VA_ARGS__)
+#define vlmul_ext_i8mf2(...) __riscv_vlmul_ext_i8mf2(__VA_ARGS__)
+#define vlmul_ext_i8m1(...) __riscv_vlmul_ext_i8m1(__VA_ARGS__)
+#define vlmul_ext_i8m2(...) __riscv_vlmul_ext_i8m2(__VA_ARGS__)
+#define vlmul_ext_i8m4(...) __riscv_vlmul_ext_i8m4(__VA_ARGS__)
+#define vlmul_ext_i8m8(...) __riscv_vlmul_ext_i8m8(__VA_ARGS__)
+#define vlmul_ext_i16mf2(...) __riscv_vlmul_ext_i16mf2(__VA_ARGS__)
+#define vlmul_ext_i16m1(...) __riscv_vlmul_ext_i16m1(__VA_ARGS__)
+#define vlmul_ext_i16m2(...) __riscv_vlmul_ext_i16m2(__VA_ARGS__)
+#define vlmul_ext_i16m4(...) __riscv_vlmul_ext_i16m4(__VA_ARGS__)
+#define vlmul_ext_i16m8(...) __riscv_vlmul_ext_i16m8(__VA_ARGS__)
+#define vlmul_ext_i32m1(...) __riscv_vlmul_ext_i32m1(__VA_ARGS__)
+#define vlmul_ext_i32m2(...) __riscv_vlmul_ext_i32m2(__VA_ARGS__)
+#define vlmul_ext_i32m4(...) __riscv_vlmul_ext_i32m4(__VA_ARGS__)
+#define vlmul_ext_i32m8(...) __riscv_vlmul_ext_i32m8(__VA_ARGS__)
+#define vlmul_ext_i64m2(...) __riscv_vlmul_ext_i64m2(__VA_ARGS__)
+#define vlmul_ext_i64m4(...) __riscv_vlmul_ext_i64m4(__VA_ARGS__)
+#define vlmul_ext_i64m8(...) __riscv_vlmul_ext_i64m8(__VA_ARGS__)
+#define vlmul_ext_u8mf4(...) __riscv_vlmul_ext_u8mf4(__VA_ARGS__)
+#define vlmul_ext_u8mf2(...) __riscv_vlmul_ext_u8mf2(__VA_ARGS__)
+#define vlmul_ext_u8m1(...) __riscv_vlmul_ext_u8m1(__VA_ARGS__)
+#define vlmul_ext_u8m2(...) __riscv_vlmul_ext_u8m2(__VA_ARGS__)
+#define vlmul_ext_u8m4(...) __riscv_vlmul_ext_u8m4(__VA_ARGS__)
+#define vlmul_ext_u8m8(...) __riscv_vlmul_ext_u8m8(__VA_ARGS__)
+#define vlmul_ext_u16mf2(...) __riscv_vlmul_ext_u16mf2(__VA_ARGS__)
+#define vlmul_ext_u16m1(...) __riscv_vlmul_ext_u16m1(__VA_ARGS__)
+#define vlmul_ext_u16m2(...) __riscv_vlmul_ext_u16m2(__VA_ARGS__)
+#define vlmul_ext_u16m4(...) __riscv_vlmul_ext_u16m4(__VA_ARGS__)
+#define vlmul_ext_u16m8(...) __riscv_vlmul_ext_u16m8(__VA_ARGS__)
+#define vlmul_ext_u32m1(...) __riscv_vlmul_ext_u32m1(__VA_ARGS__)
+#define vlmul_ext_u32m2(...) __riscv_vlmul_ext_u32m2(__VA_ARGS__)
+#define vlmul_ext_u32m4(...) __riscv_vlmul_ext_u32m4(__VA_ARGS__)
+#define vlmul_ext_u32m8(...) __riscv_vlmul_ext_u32m8(__VA_ARGS__)
+#define vlmul_ext_u64m2(...) __riscv_vlmul_ext_u64m2(__VA_ARGS__)
+#define vlmul_ext_u64m4(...) __riscv_vlmul_ext_u64m4(__VA_ARGS__)
+#define vlmul_ext_u64m8(...) __riscv_vlmul_ext_u64m8(__VA_ARGS__)
+#define vlmul_trunc_f16mf4(...) __riscv_vlmul_trunc_f16mf4(__VA_ARGS__)
+#define vlmul_trunc_f16mf2(...) __riscv_vlmul_trunc_f16mf2(__VA_ARGS__)
+#define vlmul_trunc_f16m1(...) __riscv_vlmul_trunc_f16m1(__VA_ARGS__)
+#define vlmul_trunc_f16m2(...) __riscv_vlmul_trunc_f16m2(__VA_ARGS__)
+#define vlmul_trunc_f16m4(...) __riscv_vlmul_trunc_f16m4(__VA_ARGS__)
+#define vlmul_trunc_f32mf2(...) __riscv_vlmul_trunc_f32mf2(__VA_ARGS__)
+#define vlmul_trunc_f32m1(...) __riscv_vlmul_trunc_f32m1(__VA_ARGS__)
+#define vlmul_trunc_f32m2(...) __riscv_vlmul_trunc_f32m2(__VA_ARGS__)
+#define vlmul_trunc_f32m4(...) __riscv_vlmul_trunc_f32m4(__VA_ARGS__)
+#define vlmul_trunc_f64m1(...) __riscv_vlmul_trunc_f64m1(__VA_ARGS__)
+#define vlmul_trunc_f64m2(...) __riscv_vlmul_trunc_f64m2(__VA_ARGS__)
+#define vlmul_trunc_f64m4(...) __riscv_vlmul_trunc_f64m4(__VA_ARGS__)
+#define vlmul_trunc_i8mf8(...) __riscv_vlmul_trunc_i8mf8(__VA_ARGS__)
+#define vlmul_trunc_i8mf4(...) __riscv_vlmul_trunc_i8mf4(__VA_ARGS__)
+#define vlmul_trunc_i8mf2(...) __riscv_vlmul_trunc_i8mf2(__VA_ARGS__)
+#define vlmul_trunc_i8m1(...) __riscv_vlmul_trunc_i8m1(__VA_ARGS__)
+#define vlmul_trunc_i8m2(...) __riscv_vlmul_trunc_i8m2(__VA_ARGS__)
+#define vlmul_trunc_i8m4(...) __riscv_vlmul_trunc_i8m4(__VA_ARGS__)
+#define vlmul_trunc_i16mf4(...) __riscv_vlmul_trunc_i16mf4(__VA_ARGS__)
+#define vlmul_trunc_i16mf2(...) __riscv_vlmul_trunc_i16mf2(__VA_ARGS__)
+#define vlmul_trunc_i16m1(...) __riscv_vlmul_trunc_i16m1(__VA_ARGS__)
+#define vlmul_trunc_i16m2(...) __riscv_vlmul_trunc_i16m2(__VA_ARGS__)
+#define vlmul_trunc_i16m4(...) __riscv_vlmul_trunc_i16m4(__VA_ARGS__)
+#define vlmul_trunc_i32mf2(...) __riscv_vlmul_trunc_i32mf2(__VA_ARGS__)
+#define vlmul_trunc_i32m1(...) __riscv_vlmul_trunc_i32m1(__VA_ARGS__)
+#define vlmul_trunc_i32m2(...) __riscv_vlmul_trunc_i32m2(__VA_ARGS__)
+#define vlmul_trunc_i32m4(...) __riscv_vlmul_trunc_i32m4(__VA_ARGS__)
+#define vlmul_trunc_i64m1(...) __riscv_vlmul_trunc_i64m1(__VA_ARGS__)
+#define vlmul_trunc_i64m2(...) __riscv_vlmul_trunc_i64m2(__VA_ARGS__)
+#define vlmul_trunc_i64m4(...) __riscv_vlmul_trunc_i64m4(__VA_ARGS__)
+#define vlmul_trunc_u8mf8(...) __riscv_vlmul_trunc_u8mf8(__VA_ARGS__)
+#define vlmul_trunc_u8mf4(...) __riscv_vlmul_trunc_u8mf4(__VA_ARGS__)
+#define vlmul_trunc_u8mf2(...) __riscv_vlmul_trunc_u8mf2(__VA_ARGS__)
+#define vlmul_trunc_u8m1(...) __riscv_vlmul_trunc_u8m1(__VA_ARGS__)
+#define vlmul_trunc_u8m2(...) __riscv_vlmul_trunc_u8m2(__VA_ARGS__)
+#define vlmul_trunc_u8m4(...) __riscv_vlmul_trunc_u8m4(__VA_ARGS__)
+#define vlmul_trunc_u16mf4(...) __riscv_vlmul_trunc_u16mf4(__VA_ARGS__)
+#define vlmul_trunc_u16mf2(...) __riscv_vlmul_trunc_u16mf2(__VA_ARGS__)
+#define vlmul_trunc_u16m1(...) __riscv_vlmul_trunc_u16m1(__VA_ARGS__)
+#define vlmul_trunc_u16m2(...) __riscv_vlmul_trunc_u16m2(__VA_ARGS__)
+#define vlmul_trunc_u16m4(...) __riscv_vlmul_trunc_u16m4(__VA_ARGS__)
+#define vlmul_trunc_u32mf2(...) __riscv_vlmul_trunc_u32mf2(__VA_ARGS__)
+#define vlmul_trunc_u32m1(...) __riscv_vlmul_trunc_u32m1(__VA_ARGS__)
+#define vlmul_trunc_u32m2(...) __riscv_vlmul_trunc_u32m2(__VA_ARGS__)
+#define vlmul_trunc_u32m4(...) __riscv_vlmul_trunc_u32m4(__VA_ARGS__)
+#define vlmul_trunc_u64m1(...) __riscv_vlmul_trunc_u64m1(__VA_ARGS__)
+#define vlmul_trunc_u64m2(...) __riscv_vlmul_trunc_u64m2(__VA_ARGS__)
+#define vlmul_trunc_u64m4(...) __riscv_vlmul_trunc_u64m4(__VA_ARGS__)
+#define vset(...) __riscv_vset(__VA_ARGS__)
+#define vget_f16m1(...) __riscv_vget_f16m1(__VA_ARGS__)
+#define vget_f16m2(...) __riscv_vget_f16m2(__VA_ARGS__)
+#define vget_f16m4(...) __riscv_vget_f16m4(__VA_ARGS__)
+#define vget_f32m1(...) __riscv_vget_f32m1(__VA_ARGS__)
+#define vget_f32m2(...) __riscv_vget_f32m2(__VA_ARGS__)
+#define vget_f32m4(...) __riscv_vget_f32m4(__VA_ARGS__)
+#define vget_f64m1(...) __riscv_vget_f64m1(__VA_ARGS__)
+#define vget_f64m2(...) __riscv_vget_f64m2(__VA_ARGS__)
+#define vget_f64m4(...) __riscv_vget_f64m4(__VA_ARGS__)
+#define vget_i8m1(...) __riscv_vget_i8m1(__VA_ARGS__)
+#define vget_i8m2(...) __riscv_vget_i8m2(__VA_ARGS__)
+#define vget_i8m4(...) __riscv_vget_i8m4(__VA_ARGS__)
+#define vget_i16m1(...) __riscv_vget_i16m1(__VA_ARGS__)
+#define vget_i16m2(...) __riscv_vget_i16m2(__VA_ARGS__)
+#define vget_i16m4(...) __riscv_vget_i16m4(__VA_ARGS__)
+#define vget_i32m1(...) __riscv_vget_i32m1(__VA_ARGS__)
+#define vget_i32m2(...) __riscv_vget_i32m2(__VA_ARGS__)
+#define vget_i32m4(...) __riscv_vget_i32m4(__VA_ARGS__)
+#define vget_i64m1(...) __riscv_vget_i64m1(__VA_ARGS__)
+#define vget_i64m2(...) __riscv_vget_i64m2(__VA_ARGS__)
+#define vget_i64m4(...) __riscv_vget_i64m4(__VA_ARGS__)
+#define vget_u8m1(...) __riscv_vget_u8m1(__VA_ARGS__)
+#define vget_u8m2(...) __riscv_vget_u8m2(__VA_ARGS__)
+#define vget_u8m4(...) __riscv_vget_u8m4(__VA_ARGS__)
+#define vget_u16m1(...) __riscv_vget_u16m1(__VA_ARGS__)
+#define vget_u16m2(...) __riscv_vget_u16m2(__VA_ARGS__)
+#define vget_u16m4(...) __riscv_vget_u16m4(__VA_ARGS__)
+#define vget_u32m1(...) __riscv_vget_u32m1(__VA_ARGS__)
+#define vget_u32m2(...) __riscv_vget_u32m2(__VA_ARGS__)
+#define vget_u32m4(...) __riscv_vget_u32m4(__VA_ARGS__)
+#define vget_u64m1(...) __riscv_vget_u64m1(__VA_ARGS__)
+#define vget_u64m2(...) __riscv_vget_u64m2(__VA_ARGS__)
+#define vget_u64m4(...) __riscv_vget_u64m4(__VA_ARGS__)
+#define vle16(...) __riscv_vle16_tumu(__VA_ARGS__)
+#define vle32(...) __riscv_vle32_tumu(__VA_ARGS__)
+#define vle64(...) __riscv_vle64_tumu(__VA_ARGS__)
+#define vle8(...) __riscv_vle8_tumu(__VA_ARGS__)
+#define vlse16(...) __riscv_vlse16_tumu(__VA_ARGS__)
+#define vlse32(...) __riscv_vlse32_tumu(__VA_ARGS__)
+#define vlse64(...) __riscv_vlse64_tumu(__VA_ARGS__)
+#define vlse8(...) __riscv_vlse8_tumu(__VA_ARGS__)
+#define vle16ff(...) __riscv_vle16ff_tumu(__VA_ARGS__)
+#define vle32ff(...) __riscv_vle32ff_tumu(__VA_ARGS__)
+#define vle64ff(...) __riscv_vle64ff_tumu(__VA_ARGS__)
+#define vle8ff(...) __riscv_vle8ff_tumu(__VA_ARGS__)
+#define vlseg2e16(...) __riscv_vlseg2e16_tumu(__VA_ARGS__)
+#define vlseg3e16(...) __riscv_vlseg3e16_tumu(__VA_ARGS__)
+#define vlseg4e16(...) __riscv_vlseg4e16_tumu(__VA_ARGS__)
+#define vlseg5e16(...) __riscv_vlseg5e16_tumu(__VA_ARGS__)
+#define vlseg6e16(...) __riscv_vlseg6e16_tumu(__VA_ARGS__)
+#define vlseg7e16(...) __riscv_vlseg7e16_tumu(__VA_ARGS__)
+#define vlseg8e16(...) __riscv_vlseg8e16_tumu(__VA_ARGS__)
+#define vlseg2e32(...) __riscv_vlseg2e32_tumu(__VA_ARGS__)
+#define vlseg3e32(...) __riscv_vlseg3e32_tumu(__VA_ARGS__)
+#define vlseg4e32(...) __riscv_vlseg4e32_tumu(__VA_ARGS__)
+#define vlseg5e32(...) __riscv_vlseg5e32_tumu(__VA_ARGS__)
+#define vlseg6e32(...) __riscv_vlseg6e32_tumu(__VA_ARGS__)
+#define vlseg7e32(...) __riscv_vlseg7e32_tumu(__VA_ARGS__)
+#define vlseg8e32(...) __riscv_vlseg8e32_tumu(__VA_ARGS__)
+#define vlseg2e64(...) __riscv_vlseg2e64_tumu(__VA_ARGS__)
+#define vlseg3e64(...) __riscv_vlseg3e64_tumu(__VA_ARGS__)
+#define vlseg4e64(...) __riscv_vlseg4e64_tumu(__VA_ARGS__)
+#define vlseg5e64(...) __riscv_vlseg5e64_tumu(__VA_ARGS__)
+#define vlseg6e64(...) __riscv_vlseg6e64_tumu(__VA_ARGS__)
+#define vlseg7e64(...) __riscv_vlseg7e64_tumu(__VA_ARGS__)
+#define vlseg8e64(...) __riscv_vlseg8e64_tumu(__VA_ARGS__)
+#define vlseg2e16ff(...) __riscv_vlseg2e16ff_tumu(__VA_ARGS__)
+#define vlseg3e16ff(...) __riscv_vlseg3e16ff_tumu(__VA_ARGS__)
+#define vlseg4e16ff(...) __riscv_vlseg4e16ff_tumu(__VA_ARGS__)
+#define vlseg5e16ff(...) __riscv_vlseg5e16ff_tumu(__VA_ARGS__)
+#define vlseg6e16ff(...) __riscv_vlseg6e16ff_tumu(__VA_ARGS__)
+#define vlseg7e16ff(...) __riscv_vlseg7e16ff_tumu(__VA_ARGS__)
+#define vlseg8e16ff(...) __riscv_vlseg8e16ff_tumu(__VA_ARGS__)
+#define vlseg2e32ff(...) __riscv_vlseg2e32ff_tumu(__VA_ARGS__)
+#define vlseg3e32ff(...) __riscv_vlseg3e32ff_tumu(__VA_ARGS__)
+#define vlseg4e32ff(...) __riscv_vlseg4e32ff_tumu(__VA_ARGS__)
+#define vlseg5e32ff(...) __riscv_vlseg5e32ff_tumu(__VA_ARGS__)
+#define vlseg6e32ff(...) __riscv_vlseg6e32ff_tumu(__VA_ARGS__)
+#define vlseg7e32ff(...) __riscv_vlseg7e32ff_tumu(__VA_ARGS__)
+#define vlseg8e32ff(...) __riscv_vlseg8e32ff_tumu(__VA_ARGS__)
+#define vlseg2e64ff(...) __riscv_vlseg2e64ff_tumu(__VA_ARGS__)
+#define vlseg3e64ff(...) __riscv_vlseg3e64ff_tumu(__VA_ARGS__)
+#define vlseg4e64ff(...) __riscv_vlseg4e64ff_tumu(__VA_ARGS__)
+#define vlseg5e64ff(...) __riscv_vlseg5e64ff_tumu(__VA_ARGS__)
+#define vlseg6e64ff(...) __riscv_vlseg6e64ff_tumu(__VA_ARGS__)
+#define vlseg7e64ff(...) __riscv_vlseg7e64ff_tumu(__VA_ARGS__)
+#define vlseg8e64ff(...) __riscv_vlseg8e64ff_tumu(__VA_ARGS__)
+#define vlseg2e8(...) __riscv_vlseg2e8_tumu(__VA_ARGS__)
+#define vlseg3e8(...) __riscv_vlseg3e8_tumu(__VA_ARGS__)
+#define vlseg4e8(...) __riscv_vlseg4e8_tumu(__VA_ARGS__)
+#define vlseg5e8(...) __riscv_vlseg5e8_tumu(__VA_ARGS__)
+#define vlseg6e8(...) __riscv_vlseg6e8_tumu(__VA_ARGS__)
+#define vlseg7e8(...) __riscv_vlseg7e8_tumu(__VA_ARGS__)
+#define vlseg8e8(...) __riscv_vlseg8e8_tumu(__VA_ARGS__)
+#define vlseg2e8ff(...) __riscv_vlseg2e8ff_tumu(__VA_ARGS__)
+#define vlseg3e8ff(...) __riscv_vlseg3e8ff_tumu(__VA_ARGS__)
+#define vlseg4e8ff(...) __riscv_vlseg4e8ff_tumu(__VA_ARGS__)
+#define vlseg5e8ff(...) __riscv_vlseg5e8ff_tumu(__VA_ARGS__)
+#define vlseg6e8ff(...) __riscv_vlseg6e8ff_tumu(__VA_ARGS__)
+#define vlseg7e8ff(...) __riscv_vlseg7e8ff_tumu(__VA_ARGS__)
+#define vlseg8e8ff(...) __riscv_vlseg8e8ff_tumu(__VA_ARGS__)
+#define vlsseg2e16(...) __riscv_vlsseg2e16_tumu(__VA_ARGS__)
+#define vlsseg3e16(...) __riscv_vlsseg3e16_tumu(__VA_ARGS__)
+#define vlsseg4e16(...) __riscv_vlsseg4e16_tumu(__VA_ARGS__)
+#define vlsseg5e16(...) __riscv_vlsseg5e16_tumu(__VA_ARGS__)
+#define vlsseg6e16(...) __riscv_vlsseg6e16_tumu(__VA_ARGS__)
+#define vlsseg7e16(...) __riscv_vlsseg7e16_tumu(__VA_ARGS__)
+#define vlsseg8e16(...) __riscv_vlsseg8e16_tumu(__VA_ARGS__)
+#define vlsseg2e32(...) __riscv_vlsseg2e32_tumu(__VA_ARGS__)
+#define vlsseg3e32(...) __riscv_vlsseg3e32_tumu(__VA_ARGS__)
+#define vlsseg4e32(...) __riscv_vlsseg4e32_tumu(__VA_ARGS__)
+#define vlsseg5e32(...) __riscv_vlsseg5e32_tumu(__VA_ARGS__)
+#define vlsseg6e32(...) __riscv_vlsseg6e32_tumu(__VA_ARGS__)
+#define vlsseg7e32(...) __riscv_vlsseg7e32_tumu(__VA_ARGS__)
+#define vlsseg8e32(...) __riscv_vlsseg8e32_tumu(__VA_ARGS__)
+#define vlsseg2e64(...) __riscv_vlsseg2e64_tumu(__VA_ARGS__)
+#define vlsseg3e64(...) __riscv_vlsseg3e64_tumu(__VA_ARGS__)
+#define vlsseg4e64(...) __riscv_vlsseg4e64_tumu(__VA_ARGS__)
+#define vlsseg5e64(...) __riscv_vlsseg5e64_tumu(__VA_ARGS__)
+#define vlsseg6e64(...) __riscv_vlsseg6e64_tumu(__VA_ARGS__)
+#define vlsseg7e64(...) __riscv_vlsseg7e64_tumu(__VA_ARGS__)
+#define vlsseg8e64(...) __riscv_vlsseg8e64_tumu(__VA_ARGS__)
+#define vlsseg2e8(...) __riscv_vlsseg2e8_tumu(__VA_ARGS__)
+#define vlsseg3e8(...) __riscv_vlsseg3e8_tumu(__VA_ARGS__)
+#define vlsseg4e8(...) __riscv_vlsseg4e8_tumu(__VA_ARGS__)
+#define vlsseg5e8(...) __riscv_vlsseg5e8_tumu(__VA_ARGS__)
+#define vlsseg6e8(...) __riscv_vlsseg6e8_tumu(__VA_ARGS__)
+#define vlsseg7e8(...) __riscv_vlsseg7e8_tumu(__VA_ARGS__)
+#define vlsseg8e8(...) __riscv_vlsseg8e8_tumu(__VA_ARGS__)
+#define viota(...) __riscv_viota_tumu(__VA_ARGS__)
+#define vid(...) __riscv_vid_tumu(__VA_ARGS__)
+#endif

modules/core/include/opencv2/core/hal/intrin_rvv_compat_overloaded.hpp

@@ -0,0 +1,207 @@
+// 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 OPENCV_HAL_INTRIN_RVV_COMPAT_OVERLOAD_HPP
+#define OPENCV_HAL_INTRIN_RVV_COMPAT_OVERLOAD_HPP
+
+// This file requires VTraits to be defined for vector types
+
+#define OPENCV_HAL_IMPL_RVV_FUN_AND(REG, SUF) \
+inline static REG vand(const REG & op1, const REG & op2, size_t vl) \
+{ \
+    return vand_vv_##SUF(op1, op2, vl); \
+}
+
+OPENCV_HAL_IMPL_RVV_FUN_AND(vint8m1_t, i8m1)
+OPENCV_HAL_IMPL_RVV_FUN_AND(vuint8m1_t, u8m1)
+OPENCV_HAL_IMPL_RVV_FUN_AND(vint16m1_t, i16m1)
+OPENCV_HAL_IMPL_RVV_FUN_AND(vuint16m1_t, u16m1)
+OPENCV_HAL_IMPL_RVV_FUN_AND(vint32m1_t, i32m1)
+OPENCV_HAL_IMPL_RVV_FUN_AND(vuint32m1_t, u32m1)
+OPENCV_HAL_IMPL_RVV_FUN_AND(vint64m1_t, i64m1)
+OPENCV_HAL_IMPL_RVV_FUN_AND(vuint64m1_t, u64m1)
+
+#define OPENCV_HAL_IMPL_RVV_FUN_LOXEI(REG, SUF, INDX, ISUF) \
+inline static REG vloxe##ISUF(const VTraits<REG>::lane_type *base, INDX bindex, size_t vl) \
+{ \
+    return vloxe##ISUF##_v_##SUF(base, bindex, vl); \
+}
+
+OPENCV_HAL_IMPL_RVV_FUN_LOXEI(vint8m1_t, i8m1, vuint8m1_t, i8)
+OPENCV_HAL_IMPL_RVV_FUN_LOXEI(vint8m2_t, i8m2, vuint8m2_t, i8)
+OPENCV_HAL_IMPL_RVV_FUN_LOXEI(vint8m4_t, i8m4, vuint8m4_t, i8)
+OPENCV_HAL_IMPL_RVV_FUN_LOXEI(vint8m8_t, i8m8, vuint8m8_t, i8)
+OPENCV_HAL_IMPL_RVV_FUN_LOXEI(vint8m1_t, i8m1, vuint32m4_t, i32)
+OPENCV_HAL_IMPL_RVV_FUN_LOXEI(vint8m2_t, i8m2, vuint32m8_t, i32)
+OPENCV_HAL_IMPL_RVV_FUN_LOXEI(vint16m1_t, i16m1, vuint32m2_t, i32)
+OPENCV_HAL_IMPL_RVV_FUN_LOXEI(vint32m1_t, i32m1, vuint32m1_t, i32)
+OPENCV_HAL_IMPL_RVV_FUN_LOXEI(vint32m2_t, i32m2, vuint32m2_t, i32)
+OPENCV_HAL_IMPL_RVV_FUN_LOXEI(vint32m4_t, i32m4, vuint32m4_t, i32)
+OPENCV_HAL_IMPL_RVV_FUN_LOXEI(vint32m8_t, i32m8, vuint32m8_t, i32)
+OPENCV_HAL_IMPL_RVV_FUN_LOXEI(vint64m1_t, i64m1, vuint32mf2_t, i32)
+OPENCV_HAL_IMPL_RVV_FUN_LOXEI(vuint8m1_t, u8m1, vuint8m1_t, i8)
+OPENCV_HAL_IMPL_RVV_FUN_LOXEI(vuint8m2_t, u8m2, vuint8m2_t, i8)
+OPENCV_HAL_IMPL_RVV_FUN_LOXEI(vuint8m4_t, u8m4, vuint8m4_t, i8)
+OPENCV_HAL_IMPL_RVV_FUN_LOXEI(vuint8m8_t, u8m8, vuint8m8_t, i8)
+OPENCV_HAL_IMPL_RVV_FUN_LOXEI(vfloat32m1_t, f32m1, vuint32m1_t, i32)
+#if CV_SIMD_SCALABLE_64F
+OPENCV_HAL_IMPL_RVV_FUN_LOXEI(vfloat64m1_t, f64m1, vuint32mf2_t, i32)
+#endif
+
+#define OPENCV_HAL_IMPL_RVV_FUN_MUL(REG, SUF) \
+inline static REG##m1_t vmul(const REG##m1_t & op1, const REG##m1_t & op2, size_t vl) \
+{ \
+    return vmul_vv_##SUF##m1(op1, op2, vl); \
+} \
+inline static REG##m1_t vmul(const REG##m1_t & op1, VTraits<REG##m1_t>::lane_type op2, size_t vl) \
+{ \
+    return vmul_vx_##SUF##m1(op1, op2, vl); \
+} \
+inline static REG##m2_t vmul(const REG##m2_t & op1, const REG##m2_t & op2, size_t vl) \
+{ \
+    return vmul_vv_##SUF##m2(op1, op2, vl); \
+} \
+inline static REG##m2_t vmul(const REG##m2_t & op1, VTraits<REG##m2_t>::lane_type op2, size_t vl) \
+{ \
+    return vmul_vx_##SUF##m2(op1, op2, vl); \
+} \
+inline static REG##m4_t vmul(const REG##m4_t & op1, const REG##m4_t & op2, size_t vl) \
+{ \
+    return vmul_vv_##SUF##m4(op1, op2, vl); \
+} \
+inline static REG##m4_t vmul(const REG##m4_t & op1, VTraits<REG##m4_t>::lane_type op2, size_t vl) \
+{ \
+    return vmul_vx_##SUF##m4(op1, op2, vl); \
+} \
+inline static REG##m8_t vmul(const REG##m8_t & op1, const REG##m8_t & op2, size_t vl) \
+{ \
+    return vmul_vv_##SUF##m8(op1, op2, vl); \
+} \
+inline static REG##m8_t vmul(const REG##m8_t & op1, VTraits<REG##m8_t>::lane_type op2, size_t vl) \
+{ \
+    return vmul_vx_##SUF##m8(op1, op2, vl); \
+}
+
+OPENCV_HAL_IMPL_RVV_FUN_MUL(vint8, i8)
+OPENCV_HAL_IMPL_RVV_FUN_MUL(vuint8, u8)
+OPENCV_HAL_IMPL_RVV_FUN_MUL(vint16, i16)
+OPENCV_HAL_IMPL_RVV_FUN_MUL(vuint16, u16)
+OPENCV_HAL_IMPL_RVV_FUN_MUL(vint32, i32)
+OPENCV_HAL_IMPL_RVV_FUN_MUL(vuint32, u32)
+
+#define OPENCV_HAL_IMPL_RVV_FUN_REINTERPRET(REG1, SUF1, REG2, SUF2) \
+inline static REG1##m1_t vreinterpret_##SUF1##m1(const REG2##m1_t & src) \
+{\
+    return vreinterpret_v_##SUF2##m1_##SUF1##m1(src); \
+} \
+inline static REG1##m2_t vreinterpret_##SUF1##m2(const REG2##m2_t & src) \
+{\
+    return vreinterpret_v_##SUF2##m2_##SUF1##m2(src); \
+} \
+inline static REG1##m4_t vreinterpret_##SUF1##m4(const REG2##m4_t & src) \
+{\
+    return vreinterpret_v_##SUF2##m4_##SUF1##m4(src); \
+} \
+inline static REG1##m8_t vreinterpret_##SUF1##m8(const REG2##m8_t & src) \
+{\
+    return vreinterpret_v_##SUF2##m8_##SUF1##m8(src); \
+}
+
+OPENCV_HAL_IMPL_RVV_FUN_REINTERPRET(vint8, i8, vuint8, u8)
+OPENCV_HAL_IMPL_RVV_FUN_REINTERPRET(vint16, i16, vuint16, u16)
+OPENCV_HAL_IMPL_RVV_FUN_REINTERPRET(vint32, i32, vuint32, u32)
+OPENCV_HAL_IMPL_RVV_FUN_REINTERPRET(vfloat32, f32, vuint32, u32)
+OPENCV_HAL_IMPL_RVV_FUN_REINTERPRET(vfloat32, f32, vint32, i32)
+OPENCV_HAL_IMPL_RVV_FUN_REINTERPRET(vuint32, u32, vfloat32, f32)
+OPENCV_HAL_IMPL_RVV_FUN_REINTERPRET(vint32, i32, vfloat32, f32)
+OPENCV_HAL_IMPL_RVV_FUN_REINTERPRET(vuint8, u8, vint8, i8)
+OPENCV_HAL_IMPL_RVV_FUN_REINTERPRET(vuint8, u8, vuint16, u16)
+OPENCV_HAL_IMPL_RVV_FUN_REINTERPRET(vuint8, u8, vuint32, u32)
+OPENCV_HAL_IMPL_RVV_FUN_REINTERPRET(vuint8, u8, vuint64, u64)
+OPENCV_HAL_IMPL_RVV_FUN_REINTERPRET(vuint16, u16, vint16, i16)
+OPENCV_HAL_IMPL_RVV_FUN_REINTERPRET(vuint16, u16, vuint8, u8)
+OPENCV_HAL_IMPL_RVV_FUN_REINTERPRET(vuint16, u16, vuint32, u32)
+OPENCV_HAL_IMPL_RVV_FUN_REINTERPRET(vuint16, u16, vuint64, u64)
+OPENCV_HAL_IMPL_RVV_FUN_REINTERPRET(vuint32, u32, vint32, i32)
+OPENCV_HAL_IMPL_RVV_FUN_REINTERPRET(vuint32, u32, vuint8, u8)
+OPENCV_HAL_IMPL_RVV_FUN_REINTERPRET(vuint32, u32, vuint16, u16)
+OPENCV_HAL_IMPL_RVV_FUN_REINTERPRET(vuint32, u32, vuint64, u64)
+
+#define OPENCV_HAL_IMPL_RVV_FUN_STORE(REG, SUF, SZ) \
+inline static void vse##SZ(VTraits<REG>::lane_type *base, REG value, size_t vl) \
+{ \
+    return vse##SZ##_v_##SUF##m1(base, value, vl); \
+}
+
+OPENCV_HAL_IMPL_RVV_FUN_STORE(v_uint8, u8, 8)
+OPENCV_HAL_IMPL_RVV_FUN_STORE(v_int8, i8, 8)
+OPENCV_HAL_IMPL_RVV_FUN_STORE(v_uint16, u16, 16)
+OPENCV_HAL_IMPL_RVV_FUN_STORE(v_int16, i16, 16)
+OPENCV_HAL_IMPL_RVV_FUN_STORE(v_uint32, u32, 32)
+OPENCV_HAL_IMPL_RVV_FUN_STORE(v_int32, i32, 32)
+OPENCV_HAL_IMPL_RVV_FUN_STORE(v_uint64, u64, 64)
+OPENCV_HAL_IMPL_RVV_FUN_STORE(v_int64, i64, 64)
+OPENCV_HAL_IMPL_RVV_FUN_STORE(v_float32, f32, 32)
+#if CV_SIMD_SCALABLE_64F
+OPENCV_HAL_IMPL_RVV_FUN_STORE(v_float64, f64, 64)
+#endif
+
+#define OPENCV_HAL_IMPL_RVV_FUN_EXTRACT(REG, SUF) \
+inline static VTraits<REG>::lane_type vmv_x(const REG & reg) \
+{\
+    return vmv_x_s_##SUF##m1_##SUF(reg); \
+}
+#define OPENCV_HAL_IMPL_RVV_FUN_EXTRACT_F(REG, SUF) \
+inline static VTraits<REG>::lane_type vfmv_f(const REG & reg) \
+{\
+    return vfmv_f_s_##SUF##m1_##SUF(reg); \
+}
+
+OPENCV_HAL_IMPL_RVV_FUN_EXTRACT(v_uint8, u8)
+OPENCV_HAL_IMPL_RVV_FUN_EXTRACT(v_int8, i8)
+OPENCV_HAL_IMPL_RVV_FUN_EXTRACT(v_uint16, u16)
+OPENCV_HAL_IMPL_RVV_FUN_EXTRACT(v_int16, i16)
+OPENCV_HAL_IMPL_RVV_FUN_EXTRACT(v_uint32, u32)
+OPENCV_HAL_IMPL_RVV_FUN_EXTRACT(v_int32, i32)
+OPENCV_HAL_IMPL_RVV_FUN_EXTRACT(v_uint64, u64)
+OPENCV_HAL_IMPL_RVV_FUN_EXTRACT(v_int64, i64)
+OPENCV_HAL_IMPL_RVV_FUN_EXTRACT_F(v_float32, f32)
+#if CV_SIMD_SCALABLE_64F
+OPENCV_HAL_IMPL_RVV_FUN_EXTRACT_F(v_float64, f64)
+#endif
+
+#define OPENCV_HAL_IMPL_RVV_FUN_SLIDE(REG, SUF) \
+inline static REG vslidedown(const REG & dst, const REG & src, size_t offset, size_t vl) \
+{ \
+    return vslidedown_vx_##SUF##m1(dst, src, offset, vl); \
+} \
+inline static REG vslideup(const REG & dst, const REG & src, size_t offset, size_t vl) \
+{ \
+    return vslideup_vx_##SUF##m1(dst, src, offset, vl); \
+}
+
+OPENCV_HAL_IMPL_RVV_FUN_SLIDE(v_uint8, u8)
+OPENCV_HAL_IMPL_RVV_FUN_SLIDE(v_int8, i8)
+OPENCV_HAL_IMPL_RVV_FUN_SLIDE(v_uint16, u16)
+OPENCV_HAL_IMPL_RVV_FUN_SLIDE(v_int16, i16)
+OPENCV_HAL_IMPL_RVV_FUN_SLIDE(v_uint32, u32)
+OPENCV_HAL_IMPL_RVV_FUN_SLIDE(v_int32, i32)
+OPENCV_HAL_IMPL_RVV_FUN_SLIDE(v_float32, f32)
+OPENCV_HAL_IMPL_RVV_FUN_SLIDE(v_uint64, u64)
+OPENCV_HAL_IMPL_RVV_FUN_SLIDE(v_int64, i64)
+#if CV_SIMD_SCALABLE_64F
+OPENCV_HAL_IMPL_RVV_FUN_SLIDE(v_float64, f64)
+#endif
+
+inline static vuint32mf2_t vmul(const vuint32mf2_t & op1, uint32_t op2, size_t vl)
+{
+    return vmul_vx_u32mf2(op1, op2, vl);
+}
+
+inline static vuint32mf2_t vreinterpret_u32mf2(vint32mf2_t val)
+{
+    return vreinterpret_v_i32mf2_u32mf2(val);
+}
+
+#endif //OPENCV_HAL_INTRIN_RVV_COMPAT_OVERLOAD_HPP

modules/core/include/opencv2/core/hal/intrin_rvv_scalable.hpp

@@ -13,6 +13,14 @@
 #include <vector>
 #include <opencv2/core/check.hpp>
 
+// RVV intrinsics have been renamed in version 0.11, so we need to include
+// compatibility headers:
+// https://github.com/riscv-non-isa/rvv-intrinsic-doc/tree/master/auto-generated/rvv-v0p10-compatible-headers
+#if defined(__riscv_v_intrinsic) &&  __riscv_v_intrinsic>10999
+#include "intrin_rvv_010_compat_non-policy.hpp"
+#include "intrin_rvv_010_compat_overloaded-non-policy.hpp"
+#endif
+
 #if defined(__GNUC__) && !defined(__clang__)
 // FIXIT: eliminate massive warnigs from templates
 // GCC from 'rvv-next': riscv64-unknown-linux-gnu-g++ (g42df3464463) 12.0.1 20220505 (prerelease)
@@ -52,89 +60,93 @@ using uint = unsigned int;
 using uint64 = unsigned long int;
 using int64 = long int;
 
-static const int __cv_rvv_e8_nlanes = vsetvlmax_e8m1();
-static const int __cv_rvv_e16_nlanes = vsetvlmax_e16m1();
-static const int __cv_rvv_e32_nlanes = vsetvlmax_e32m1();
-static const int __cv_rvv_e64_nlanes = vsetvlmax_e64m1();
+static const int __cv_rvv_e8m1_nlanes = vsetvlmax_e8m1();
+static const int __cv_rvv_e16m1_nlanes = vsetvlmax_e16m1();
+static const int __cv_rvv_e32m1_nlanes = vsetvlmax_e32m1();
+static const int __cv_rvv_e64m1_nlanes = vsetvlmax_e64m1();
+static const int __cv_rvv_e8m2_nlanes = vsetvlmax_e8m2();
+static const int __cv_rvv_e16m2_nlanes = vsetvlmax_e16m2();
+static const int __cv_rvv_e32m2_nlanes = vsetvlmax_e32m2();
+static const int __cv_rvv_e64m2_nlanes = vsetvlmax_e64m2();
+static const int __cv_rvv_e8m4_nlanes = vsetvlmax_e8m4();
+static const int __cv_rvv_e16m4_nlanes = vsetvlmax_e16m4();
+static const int __cv_rvv_e32m4_nlanes = vsetvlmax_e32m4();
+static const int __cv_rvv_e64m4_nlanes = vsetvlmax_e64m4();
+static const int __cv_rvv_e8m8_nlanes = vsetvlmax_e8m8();
+static const int __cv_rvv_e16m8_nlanes = vsetvlmax_e16m8();
+static const int __cv_rvv_e32m8_nlanes = vsetvlmax_e32m8();
+static const int __cv_rvv_e64m8_nlanes = vsetvlmax_e64m8();
 
 template <class T>
 struct VTraits;
 
-template <>
-struct VTraits<v_uint8>
-{
-    static inline int vlanes() { return __cv_rvv_e8_nlanes; }
-    using lane_type = uchar;
-    static const int max_nlanes = CV_RVV_MAX_VLEN/8;
+#define OPENCV_HAL_IMPL_RVV_TRAITS(REG, TYP, SUF, SZ) \
+template <> \
+struct VTraits<REG> \
+{ \
+    static inline int vlanes() { return __cv_rvv_##SUF##_nlanes; } \
+    using lane_type = TYP; \
+    static const int max_nlanes = CV_RVV_MAX_VLEN/SZ; \
 };
 
-template <>
-struct VTraits<v_int8>
-{
-    static inline int vlanes() { return __cv_rvv_e8_nlanes; }
-    using lane_type = schar;
-    static const int max_nlanes = CV_RVV_MAX_VLEN/8;
-};
-template <>
-struct VTraits<v_uint16>
-{
-    static inline int vlanes() { return __cv_rvv_e16_nlanes; }
-    using lane_type = ushort;
-    static const int max_nlanes = CV_RVV_MAX_VLEN/16;
-};
-template <>
-struct VTraits<v_int16>
-{
-    static inline int vlanes() { return __cv_rvv_e16_nlanes; }
-    using lane_type = short;
-    static const int max_nlanes = CV_RVV_MAX_VLEN/16;
-};
-template <>
-struct VTraits<v_uint32>
-{
-    static inline int vlanes() { return __cv_rvv_e32_nlanes; }
-    using lane_type = uint;
-    static const int max_nlanes = CV_RVV_MAX_VLEN/32;
-};
-template <>
-struct VTraits<v_int32>
-{
-    static inline int vlanes() { return __cv_rvv_e32_nlanes; }
-    using lane_type = int;
-    static const int max_nlanes = CV_RVV_MAX_VLEN/32;
-};
+OPENCV_HAL_IMPL_RVV_TRAITS(vint8m1_t, int8_t, e8m1, 8)
+OPENCV_HAL_IMPL_RVV_TRAITS(vint8m2_t, int8_t, e8m2, 8)
+OPENCV_HAL_IMPL_RVV_TRAITS(vint8m4_t, int8_t, e8m4, 8)
+OPENCV_HAL_IMPL_RVV_TRAITS(vint8m8_t, int8_t, e8m8, 8)
+OPENCV_HAL_IMPL_RVV_TRAITS(vuint8m1_t, uint8_t, e8m1, 8)
+OPENCV_HAL_IMPL_RVV_TRAITS(vuint8m2_t, uint8_t, e8m2, 8)
+OPENCV_HAL_IMPL_RVV_TRAITS(vuint8m4_t, uint8_t, e8m4, 8)
+OPENCV_HAL_IMPL_RVV_TRAITS(vuint8m8_t, uint8_t, e8m8, 8)
+
+OPENCV_HAL_IMPL_RVV_TRAITS(vint16m1_t, int16_t, e16m1, 16)
+OPENCV_HAL_IMPL_RVV_TRAITS(vint16m2_t, int16_t, e16m2, 16)
+OPENCV_HAL_IMPL_RVV_TRAITS(vint16m4_t, int16_t, e16m4, 16)
+OPENCV_HAL_IMPL_RVV_TRAITS(vint16m8_t, int16_t, e16m8, 16)
+OPENCV_HAL_IMPL_RVV_TRAITS(vuint16m1_t, uint16_t, e16m1, 16)
+OPENCV_HAL_IMPL_RVV_TRAITS(vuint16m2_t, uint16_t, e16m2, 16)
+OPENCV_HAL_IMPL_RVV_TRAITS(vuint16m4_t, uint16_t, e16m4, 16)
+OPENCV_HAL_IMPL_RVV_TRAITS(vuint16m8_t, uint16_t, e16m8, 16)
+
+OPENCV_HAL_IMPL_RVV_TRAITS(vint32m1_t, int32_t, e32m1, 32)
+OPENCV_HAL_IMPL_RVV_TRAITS(vint32m2_t, int32_t, e32m2, 32)
+OPENCV_HAL_IMPL_RVV_TRAITS(vint32m4_t, int32_t, e32m4, 32)
+OPENCV_HAL_IMPL_RVV_TRAITS(vint32m8_t, int32_t, e32m8, 32)
+OPENCV_HAL_IMPL_RVV_TRAITS(vuint32m1_t, uint32_t, e32m1, 32)
+OPENCV_HAL_IMPL_RVV_TRAITS(vuint32m2_t, uint32_t, e32m2, 32)
+OPENCV_HAL_IMPL_RVV_TRAITS(vuint32m4_t, uint32_t, e32m4, 32)
+OPENCV_HAL_IMPL_RVV_TRAITS(vuint32m8_t, uint32_t, e32m8, 32)
+
+OPENCV_HAL_IMPL_RVV_TRAITS(vint64m1_t, int64_t, e64m1, 64)
+OPENCV_HAL_IMPL_RVV_TRAITS(vint64m2_t, int64_t, e64m2, 64)
+OPENCV_HAL_IMPL_RVV_TRAITS(vint64m4_t, int64_t, e64m4, 64)
+OPENCV_HAL_IMPL_RVV_TRAITS(vint64m8_t, int64_t, e64m8, 64)
+OPENCV_HAL_IMPL_RVV_TRAITS(vuint64m1_t, uint64_t, e64m1, 64)
+OPENCV_HAL_IMPL_RVV_TRAITS(vuint64m2_t, uint64_t, e64m2, 64)
+OPENCV_HAL_IMPL_RVV_TRAITS(vuint64m4_t, uint64_t, e64m4, 64)
+OPENCV_HAL_IMPL_RVV_TRAITS(vuint64m8_t, uint64_t, e64m8, 64)
+
+OPENCV_HAL_IMPL_RVV_TRAITS(vfloat32m1_t, float, e32m1, 32)
+OPENCV_HAL_IMPL_RVV_TRAITS(vfloat32m2_t, float, e32m2, 32)
+OPENCV_HAL_IMPL_RVV_TRAITS(vfloat32m4_t, float, e32m4, 32)
+OPENCV_HAL_IMPL_RVV_TRAITS(vfloat32m8_t, float, e32m8, 32)
 
-template <>
-struct VTraits<v_float32>
-{
-    static inline int vlanes() { return __cv_rvv_e32_nlanes; }
-    using lane_type = float;
-    static const int max_nlanes = CV_RVV_MAX_VLEN/32;
-};
-template <>
-struct VTraits<v_uint64>
-{
-    static inline int vlanes() { return __cv_rvv_e64_nlanes; }
-    using lane_type = uint64;
-    static const int max_nlanes = CV_RVV_MAX_VLEN/64;
-};
-template <>
-struct VTraits<v_int64>
-{
-    static inline int vlanes() { return __cv_rvv_e64_nlanes; }
-    using lane_type = int64;
-    static const int max_nlanes = CV_RVV_MAX_VLEN/64;
-};
 #if CV_SIMD_SCALABLE_64F
-template <>
-struct VTraits<v_float64>
-{
-    static inline int vlanes() { return __cv_rvv_e64_nlanes; }
-    using lane_type = double;
-    static const int max_nlanes = CV_RVV_MAX_VLEN/64;
-};
+OPENCV_HAL_IMPL_RVV_TRAITS(vfloat64m1_t, double, e64m1, 64)
+OPENCV_HAL_IMPL_RVV_TRAITS(vfloat64m2_t, double, e64m2, 64)
+OPENCV_HAL_IMPL_RVV_TRAITS(vfloat64m4_t, double, e64m4, 64)
+OPENCV_HAL_IMPL_RVV_TRAITS(vfloat64m8_t, double, e64m8, 64)
 #endif
 
+
+// LLVM/Clang defines "overloaded intrinsics" e.g. 'vand(op1, op2)'
+// GCC does not have these functions, so we need to implement them manually
+// We implement only selected subset required to build current state of the code
+// Included inside namespace cv::
+#ifndef __riscv_v_intrinsic_overloading
+#include "intrin_rvv_compat_overloaded.hpp"
+#endif // __riscv_v_intrinsic_overloading
+
+
 //////////// get0 ////////////
 #define OPENCV_HAL_IMPL_RVV_GRT0_INT(_Tpvec, _Tp) \
 inline _Tp v_get0(const v_##_Tpvec& v) \
@@ -435,7 +447,7 @@ inline _Tpvec v_lut(const _Tp* tab, const int* idx) \
 inline _Tpvec v_lut_pairs(const _Tp* tab, const int* idx) \
 { \
     std::vector<uint> idx_; \
-    for (size_t i = 0; i < VTraits<v_int16>::vlanes(); ++i) { \
+    for (int i = 0; i < VTraits<v_int16>::vlanes(); ++i) { \
         idx_.push_back(idx[i]); \
         idx_.push_back(idx[i]+1); \
     } \
@@ -445,7 +457,7 @@ inline _Tpvec v_lut_pairs(const _Tp* tab, const int* idx) \
 inline _Tpvec v_lut_quads(const _Tp* tab, const int* idx) \
 { \
     std::vector<uint> idx_; \
-    for (size_t i = 0; i < VTraits<v_int32>::vlanes(); ++i) { \
+    for (int i = 0; i < VTraits<v_int32>::vlanes(); ++i) { \
         idx_.push_back(idx[i]); \
         idx_.push_back(idx[i]+1); \
         idx_.push_back(idx[i]+2); \
@@ -479,7 +491,7 @@ inline v_uint64 v_lut_quads(const uint64* tab, const int* idx) { return v_reinte
 ////////////// Pack boolean ////////////////////
 inline v_uint8 v_pack_b(const v_uint16& a, const v_uint16& b)
 {
-    return vnsrl(vset(vlmul_ext_u16m2(a),1,b), 0, VTraits<v_uint8>::vlanes());
+    return vnsrl(vset(vlmul_ext_v_u16m1_u16m2(a),1,b), 0, VTraits<v_uint8>::vlanes());
 }
 
 inline v_uint8 v_pack_b(const v_uint32& a, const v_uint32& b,
@@ -1074,11 +1086,11 @@ inline v_float64 v_muladd(const v_float64& a, const v_float64& b, const v_float6
 #define OPENCV_HAL_IMPL_RVV_CHECK_ALLANY(_Tpvec, vl) \
 inline bool v_check_all(const _Tpvec& a) \
 { \
-    return vcpop(vmslt(a, 0, vl), vl) == vl; \
+    return (int)vcpop(vmslt(a, 0, vl), vl) == vl; \
 } \
 inline bool v_check_any(const _Tpvec& a) \
 { \
-    return vcpop(vmslt(a, 0, vl), vl) != 0; \
+    return (int)vcpop(vmslt(a, 0, vl), vl) != 0; \
 }
 
 OPENCV_HAL_IMPL_RVV_CHECK_ALLANY(v_int8, VTraits<v_int8>::vlanes())

modules/core/include/opencv2/core/hal/intrin_sse.hpp

@@ -1921,11 +1921,12 @@ OPENCV_HAL_IMPL_SSE_EXPAND(v_int16x8,  v_int32x4,   short,    _v128_cvtepi16_epi
 OPENCV_HAL_IMPL_SSE_EXPAND(v_uint32x4, v_uint64x2,  unsigned, _v128_cvtepu32_epi64)
 OPENCV_HAL_IMPL_SSE_EXPAND(v_int32x4,  v_int64x2,   int,      _v128_cvtepi32_epi64)
 
-#define OPENCV_HAL_IMPL_SSE_EXPAND_Q(_Tpvec, _Tp, intrin)  \
-    inline _Tpvec v_load_expand_q(const _Tp* ptr)          \
-    {                                                      \
-        __m128i a = _mm_cvtsi32_si128(*(const int*)ptr);   \
-        return _Tpvec(intrin(a));                          \
+#define OPENCV_HAL_IMPL_SSE_EXPAND_Q(_Tpvec, _Tp, intrin)          \
+    inline _Tpvec v_load_expand_q(const _Tp* ptr)                  \
+    {                                                              \
+        typedef int CV_DECL_ALIGNED(1) unaligned_int;              \
+        __m128i a = _mm_cvtsi32_si128(*(const unaligned_int*)ptr); \
+        return _Tpvec(intrin(a));                                  \
     }
 
 OPENCV_HAL_IMPL_SSE_EXPAND_Q(v_uint32x4, uchar, _v128_cvtepu8_epi32)

modules/core/include/opencv2/core/ocl.hpp

@@ -692,7 +692,8 @@ protected:
     Impl* p;
 };
 
-CV_EXPORTS const char* convertTypeStr(int sdepth, int ddepth, int cn, char* buf);
+CV_EXPORTS CV_DEPRECATED const char* convertTypeStr(int sdepth, int ddepth, int cn, char* buf);
+CV_EXPORTS const char* convertTypeStr(int sdepth, int ddepth, int cn, char* buf, size_t buf_size);
 CV_EXPORTS const char* typeToStr(int t);
 CV_EXPORTS const char* memopTypeToStr(int t);
 CV_EXPORTS const char* vecopTypeToStr(int t);

modules/core/include/opencv2/core/operations.hpp

@@ -61,10 +61,10 @@
 #  define CV_FORMAT_PRINTF(A, B)
 #endif
 
-//! @cond IGNORED
-
 namespace cv
 {
+//! @cond IGNORED
+
 
 ////////////////////////////// Matx methods depending on core API /////////////////////////////
 
@@ -434,26 +434,6 @@ template<typename _Tp> static inline _Tp randu()
   return (_Tp)theRNG();
 }
 
-///////////////////////////////// Formatted string generation /////////////////////////////////
-
-/** @brief Returns a text string formatted using the printf-like expression.
-
-The function acts like sprintf but forms and returns an STL string. It can be used to form an error
-message in the Exception constructor.
-@param fmt printf-compatible formatting specifiers.
-
-**Note**:
-|Type|Specifier|
-|-|-|
-|`const char*`|`%s`|
-|`char`|`%c`|
-|`float` / `double`|`%f`,`%g`|
-|`int`, `long`, `long long`|`%d`, `%ld`, ``%lld`|
-|`unsigned`, `unsigned long`, `unsigned long long`|`%u`, `%lu`, `%llu`|
-|`uint64` -> `uintmax_t`, `int64` -> `intmax_t`|`%ju`, `%jd`|
-|`size_t`|`%zu`|
- */
-CV_EXPORTS String format( const char* fmt, ... ) CV_FORMAT_PRINTF(1, 2);
 
 ///////////////////////////////// Formatted output of cv::Mat /////////////////////////////////
 
@@ -506,6 +486,28 @@ int print(const Matx<_Tp, m, n>& matx, FILE* stream = stdout)
 
 //! @endcond
 
+///////////////////////////////// Formatted string generation /////////////////////////////////
+
+/** @brief Returns a text string formatted using the printf-like expression.
+
+The function acts like sprintf but forms and returns an STL string. It can be used to form an error
+message in the Exception constructor.
+@param fmt printf-compatible formatting specifiers.
+
+**Note**:
+|Type|Specifier|
+|-|-|
+|`const char*`|`%s`|
+|`char`|`%c`|
+|`float` / `double`|`%f`,`%g`|
+|`int`, `long`, `long long`|`%d`, `%ld`, ``%lld`|
+|`unsigned`, `unsigned long`, `unsigned long long`|`%u`, `%lu`, `%llu`|
+|`uint64` -> `uintmax_t`, `int64` -> `intmax_t`|`%ju`, `%jd`|
+|`size_t`|`%zu`|
+@ingroup core_utils
+ */
+CV_EXPORTS String format(const char* fmt, ...) CV_FORMAT_PRINTF(1, 2);
+
 /****************************************************************************************\
 *                                  Auxiliary algorithms                                  *
 \****************************************************************************************/

modules/core/include/opencv2/core/private.hpp

@@ -235,6 +235,10 @@ T* allocSingletonNew() { return new(allocSingletonNewBuffer(sizeof(T))) T(); }
 #include "ipp.h"
 #endif
 #ifdef HAVE_IPP_IW
+#  if defined(__OPENCV_BUILD) && defined(__clang__)
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wstrict-prototypes"
+#  endif
 #  if defined(__OPENCV_BUILD) && defined(__GNUC__) && __GNUC__ >= 5
 #  pragma GCC diagnostic push
 #  pragma GCC diagnostic ignored "-Wsuggest-override"
@@ -246,6 +250,9 @@ T* allocSingletonNew() { return new(allocSingletonNewBuffer(sizeof(T))) T(); }
 #  if defined(__OPENCV_BUILD) && defined(__GNUC__) && __GNUC__ >= 5
 #  pragma GCC diagnostic pop
 #  endif
+#  if defined(__OPENCV_BUILD) && defined(__clang__)
+#  pragma clang diagnostic pop
+#  endif
 #endif
 
 #if IPP_VERSION_X100 >= 201700

modules/core/include/opencv2/core/quaternion.hpp

@@ -77,9 +77,9 @@ public:
      * For intrinsic rotations in the order of X-Y-Z, the rotation matrix R can be calculated by:\f[R =X(\theta_1) Y(\theta_2) Z(\theta_3) \f]
      * For extrinsic rotations in the order of X-Y-Z, the rotation matrix R can be calculated by:\f[R =Z({\theta_3}) Y({\theta_2}) X({\theta_1})\f]
      * where
-     * \f[X({\theta})={\begin{bmatrix}1&0&0\\0&\cos {\theta_1} &-\sin {\theta_1} \\0&\sin {\theta_1} &\cos {\theta_1} \\\end{bmatrix}},
-     * Y({\theta})={\begin{bmatrix}\cos \theta_{2}&0&\sin \theta_{2}\\0&1 &0 \\\ -sin \theta_2& 0&\cos \theta_{2} \\\end{bmatrix}},
-     * Z({\theta})={\begin{bmatrix}\cos\theta_{3} &-\sin \theta_3&0\\\sin \theta_3 &\cos \theta_3 &0\\0&0&1\\\end{bmatrix}}.
+     * \f[X({\theta_1})={\begin{bmatrix}1&0&0\\0&\cos {\theta_1} &-\sin {\theta_1} \\0&\sin {\theta_1} &\cos {\theta_1} \\\end{bmatrix}},
+     * Y({\theta_2})={\begin{bmatrix}\cos \theta_{2}&0&\sin \theta_{2}\\0&1 &0 \\\ -sin \theta_2& 0&\cos \theta_{2} \\\end{bmatrix}},
+     * Z({\theta_3})={\begin{bmatrix}\cos\theta_{3} &-\sin \theta_3&0\\\sin \theta_3 &\cos \theta_3 &0\\0&0&1\\\end{bmatrix}}.
      * \f]
      *
      * The function is designed according to this set of conventions:

modules/core/include/opencv2/core/quaternion.inl.hpp

@@ -745,8 +745,8 @@ Quat<T> Quat<T>::lerp(const Quat<T> &q0, const Quat<T> &q1, const T t)
 template <typename T>
 Quat<T> Quat<T>::slerp(const Quat<T> &q0, const Quat<T> &q1, const T t, QuatAssumeType assumeUnit, bool directChange)
 {
-    Quatd v0(q0);
-    Quatd v1(q1);
+    Quat<T> v0(q0);
+    Quat<T> v1(q1);
     if (!assumeUnit)
     {
         v0 = v0.normalize();
@@ -754,7 +754,7 @@ Quat<T> Quat<T>::slerp(const Quat<T> &q0, const Quat<T> &q1, const T t, QuatAssu
     }
     T cosTheta = v0.dot(v1);
     constexpr T DOT_THRESHOLD = 0.995;
-    if (cosTheta > DOT_THRESHOLD)
+    if (std::abs(cosTheta) > DOT_THRESHOLD)
     {
         return nlerp(v0, v1, t, QUAT_ASSUME_UNIT);
     }
@@ -843,7 +843,7 @@ Quat<T> Quat<T>::interPoint(const Quat<T> &q0, const Quat<T> &q1,
 template <typename T>
 Quat<T> Quat<T>::spline(const Quat<T> &q0, const Quat<T> &q1, const Quat<T> &q2, const Quat<T> &q3, const T t, QuatAssumeType assumeUnit)
 {
-    Quatd v0(q0), v1(q1), v2(q2), v3(q3);
+    Quat<T> v0(q0), v1(q1), v2(q2), v3(q3);
     if (!assumeUnit)
     {
         v0 = v0.normalize();

modules/core/include/opencv2/core/types.hpp

@@ -545,8 +545,11 @@ public:
      */
     RotatedRect(const Point2f& point1, const Point2f& point2, const Point2f& point3);
 
-    /** returns 4 vertices of the rectangle
-    @param pts The points array for storing rectangle vertices. The order is bottomLeft, topLeft, topRight, bottomRight.
+    /** returns 4 vertices of the rotated rectangle
+    @param pts The points array for storing rectangle vertices. The order is _bottomLeft_, _topLeft_, topRight, bottomRight.
+    @note _Bottom_, _Top_, _Left_ and _Right_ sides refer to the original rectangle (angle is 0),
+    so after 180 degree rotation _bottomLeft_ point will be located at the top right corner of the
+    rectangle.
     */
     void points(Point2f pts[]) const;
     //! returns the minimal up-right integer rectangle containing the rotated rectangle

modules/core/include/opencv2/core/utility.hpp

@@ -179,11 +179,11 @@ CV_EXPORTS ErrorCallback redirectError( ErrorCallback errCallback, void* userdat
 CV_EXPORTS String tempfile( const char* suffix = 0);
 CV_EXPORTS void glob(String pattern, std::vector<String>& result, bool recursive = false);
 
-/** @brief OpenCV will try to set the number of threads for the next parallel region.
+/** @brief OpenCV will try to set the number of threads for subsequent parallel regions.
 
-If threads == 0, OpenCV will disable threading optimizations and run all it's functions
-sequentially. Passing threads \< 0 will reset threads number to system default. This function must
-be called outside of parallel region.
+If threads == 1, OpenCV will disable threading optimizations and run all it's functions
+sequentially. Passing threads \< 0 will reset threads number to system default.
+The function is not thread-safe. It must not be called in parallel region or concurrent threads.
 
 OpenCV will try to run its functions with specified threads number, but some behaviour differs from
 framework:

modules/core/misc/java/gen_dict.json

@@ -122,10 +122,7 @@
                     "}",
                     "\n"
                 ]
-            },
-            "checkHardwareSupport" : {"j_code" : [""], "jn_code" : [""], "cpp_code" : [""] },
-            "setUseOptimized"      : {"j_code" : [""], "jn_code" : [""], "cpp_code" : [""] },
-            "useOptimized"         : {"j_code" : [""], "jn_code" : [""], "cpp_code" : [""] }
+            }
         }
     },
     "func_arg_fix" : {

modules/core/misc/java/test/CoreTest.java

@@ -2059,4 +2059,12 @@ public class CoreTest extends OpenCVTestCase {
         assertEquals(Core.VERSION, Core.getVersionString());
     }
 
+    public void testHardwareOptions() {
+        Core.checkHardwareSupport(0);
+        boolean original_status = Core.useOptimized();
+        Core.setUseOptimized(!original_status);
+        assertEquals(!original_status, Core.useOptimized());
+        Core.setUseOptimized(original_status);
+        assertEquals(original_status, Core.useOptimized());
+    }
 }

modules/core/misc/objc/common/Mat.h

@@ -14,6 +14,14 @@
 
 #import <Foundation/Foundation.h>
 
+#ifdef AVAILABLE_IMGCODECS
+#if TARGET_OS_IPHONE
+#import <UIKit/UIKit.h>
+#elif TARGET_OS_MAC
+#import <AppKit/AppKit.h>
+#endif
+#endif
+
 @class Size2i;
 @class Scalar;
 @class Range;
@@ -181,6 +189,37 @@ CV_EXPORTS @interface Mat : NSObject
 - (int)put:(NSArray<NSNumber*>*)indices count:(int)count intBuffer:(const int*)buffer NS_REFINED_FOR_SWIFT;
 - (int)put:(NSArray<NSNumber*>*)indices count:(int)count shortBuffer:(const short*)buffer NS_REFINED_FOR_SWIFT;
 
+#pragma mark - Converters
+
+#ifdef AVAILABLE_IMGCODECS
+
+- (CGImageRef)toCGImage CF_RETURNS_RETAINED;
+- (instancetype)initWithCGImage:(CGImageRef)image;
+- (instancetype)initWithCGImage:(CGImageRef)image alphaExist:(BOOL)alphaExist;
+
+#if TARGET_OS_IPHONE
+
+- (UIImage*)toUIImage;
+- (instancetype)initWithUIImage:(UIImage*)image;
+- (instancetype)initWithUIImage:(UIImage*)image alphaExist:(BOOL)alphaExist;
+
+#elif TARGET_OS_MAC
+
+- (NSImage*)toNSImage;
+- (instancetype)initWithNSImage:(NSImage*)image;
+- (instancetype)initWithNSImage:(NSImage*)image alphaExist:(BOOL)alphaExist;
+
+#endif
+
+#endif
+
+#pragma mark - QuickLook
+
+#ifdef AVAILABLE_IMGCODECS
+
+- (id)debugQuickLookObject;
+
+#endif
 
 @end
 

modules/core/misc/objc/common/Mat.mm

@@ -13,6 +13,11 @@
 #import "CvType.h"
 #import "CVObjcUtil.h"
 
+#ifdef AVAILABLE_IMGCODECS
+#import "MatConverters.h"
+#import "MatQuickLook.h"
+#endif
+
 static int idx2Offset(cv::Mat* mat, std::vector<int>& indices) {
     int offset = indices[0];
     for (int dim=1; dim < mat->dims; dim++) {
@@ -932,4 +937,54 @@ template<typename T> int putData(NSArray<NSNumber*>* indices, cv::Mat* mat, int
     return [self cols];
 }
 
+#ifdef AVAILABLE_IMGCODECS
+
+-(CGImageRef)toCGImage {
+    return [MatConverters convertMatToCGImageRef:self];
+}
+
+-(instancetype)initWithCGImage:(CGImageRef)image {
+    return [MatConverters convertCGImageRefToMat:image];
+}
+
+-(instancetype)initWithCGImage:(CGImageRef)image alphaExist:(BOOL)alphaExist {
+    return [MatConverters convertCGImageRefToMat:image alphaExist:alphaExist];
+}
+
+#if TARGET_OS_IPHONE
+
+-(UIImage*)toUIImage {
+    return [MatConverters converMatToUIImage:self];
+}
+
+-(instancetype)initWithUIImage:(UIImage*)image {
+    return [MatConverters convertUIImageToMat:image];
+}
+
+-(instancetype)initWithUIImage:(UIImage*)image alphaExist:(BOOL)alphaExist {
+    return [MatConverters convertUIImageToMat:image alphaExist:alphaExist];
+}
+
+#elif TARGET_OS_MAC
+
+-(NSImage*)toNSImage {
+    return [MatConverters converMatToNSImage:self];
+}
+
+-(instancetype)initWithNSImage:(NSImage*)image {
+    return [MatConverters convertNSImageToMat:image];
+}
+
+-(instancetype)initWithNSImage:(NSImage*)image alphaExist:(BOOL)alphaExist {
+    return [MatConverters convertNSImageToMat:image alphaExist:alphaExist];
+}
+
+#endif
+
+- (id)debugQuickLookObject {
+    return [MatQuickLook matDebugQuickLookObject:self];
+}
+
+#endif
+
 @end

modules/core/misc/python/pyopencv_core.hpp

@@ -0,0 +1,35 @@
+#ifndef OPENCV_CORE_PYOPENCV_CORE_HPP
+#define OPENCV_CORE_PYOPENCV_CORE_HPP
+
+#ifdef HAVE_OPENCV_CORE
+
+static PyObject* pycvMakeType(PyObject* , PyObject* args, PyObject* kw) {
+    const char *keywords[] = { "depth", "channels", NULL };
+
+    int depth, channels;
+    if (!PyArg_ParseTupleAndKeywords(args, kw, "ii", (char**)keywords, &depth, &channels))
+        return NULL;
+
+    int type = CV_MAKETYPE(depth, channels);
+    return PyInt_FromLong(type);
+}
+
+template <int depth>
+static PyObject* pycvMakeTypeCh(PyObject*, PyObject *value) {
+    int channels = (int)PyLong_AsLong(value);
+    return PyInt_FromLong(CV_MAKETYPE(depth, channels));
+}
+
+#define PYOPENCV_EXTRA_METHODS_CV \
+  {"CV_MAKETYPE", CV_PY_FN_WITH_KW(pycvMakeType), "CV_MAKETYPE(depth, channels) -> retval"}, \
+  {"CV_8UC", (PyCFunction)(pycvMakeTypeCh<CV_8U>), METH_O, "CV_8UC(channels) -> retval"}, \
+  {"CV_8SC", (PyCFunction)(pycvMakeTypeCh<CV_8S>), METH_O, "CV_8SC(channels) -> retval"}, \
+  {"CV_16UC", (PyCFunction)(pycvMakeTypeCh<CV_16U>), METH_O, "CV_16UC(channels) -> retval"}, \
+  {"CV_16SC", (PyCFunction)(pycvMakeTypeCh<CV_16S>), METH_O, "CV_16SC(channels) -> retval"}, \
+  {"CV_32SC", (PyCFunction)(pycvMakeTypeCh<CV_32S>), METH_O, "CV_32SC(channels) -> retval"}, \
+  {"CV_32FC", (PyCFunction)(pycvMakeTypeCh<CV_32F>), METH_O, "CV_32FC(channels) -> retval"}, \
+  {"CV_64FC", (PyCFunction)(pycvMakeTypeCh<CV_64F>), METH_O, "CV_64FC(channels) -> retval"}, \
+  {"CV_16FC", (PyCFunction)(pycvMakeTypeCh<CV_16F>), METH_O, "CV_16FC(channels) -> retval"},
+
+#endif  // HAVE_OPENCV_CORE
+#endif  // OPENCV_CORE_PYOPENCV_CORE_HPP

modules/core/perf/opencl/perf_arithm.cpp

@@ -1150,7 +1150,7 @@ OCL_PERF_TEST_P(ReduceMinMaxFixture, Reduce,
     SANITY_CHECK(dst, eps);
 }
 
-CV_ENUM(ReduceAccOp, CV_REDUCE_SUM, CV_REDUCE_AVG)
+CV_ENUM(ReduceAccOp, REDUCE_SUM, REDUCE_AVG, REDUCE_SUM2)
 
 typedef tuple<Size, std::pair<MatType, MatType>, int, ReduceAccOp> ReduceAccParams;
 typedef TestBaseWithParam<ReduceAccParams> ReduceAccFixture;
@@ -1168,7 +1168,6 @@ OCL_PERF_TEST_P(ReduceAccFixture, Reduce,
             dim = get<2>(params), op = get<3>(params);
     const Size srcSize = get<0>(params),
             dstSize(dim == 0 ? srcSize.width : 1, dim == 0 ? 1 : srcSize.height);
-    const double eps = CV_MAT_DEPTH(dtype) <= CV_32S ? 1 : 3e-4;
 
     checkDeviceMaxMemoryAllocSize(srcSize, stype);
     checkDeviceMaxMemoryAllocSize(srcSize, dtype);
@@ -1178,7 +1177,7 @@ OCL_PERF_TEST_P(ReduceAccFixture, Reduce,
 
     OCL_TEST_CYCLE() cv::reduce(src, dst, dim, op, dtype);
 
-    SANITY_CHECK(dst, eps);
+    SANITY_CHECK_NOTHING();
 }
 
 } } // namespace opencv_test::ocl

modules/core/perf/perf_reduce.cpp

@@ -5,7 +5,7 @@ namespace opencv_test
 {
 using namespace perf;
 
-CV_ENUM(ROp, CV_REDUCE_SUM, CV_REDUCE_AVG, CV_REDUCE_MAX, CV_REDUCE_MIN)
+CV_ENUM(ROp, REDUCE_SUM, REDUCE_AVG, REDUCE_MAX, REDUCE_MIN, REDUCE_SUM2)
 typedef tuple<Size, MatType, ROp> Size_MatType_ROp_t;
 typedef perf::TestBaseWithParam<Size_MatType_ROp_t> Size_MatType_ROp;
 
@@ -23,7 +23,7 @@ PERF_TEST_P(Size_MatType_ROp, reduceR,
     int reduceOp = get<2>(GetParam());
 
     int ddepth = -1;
-    if( CV_MAT_DEPTH(matType) < CV_32S && (reduceOp == REDUCE_SUM || reduceOp == REDUCE_AVG) )
+    if( CV_MAT_DEPTH(matType) < CV_32S && (reduceOp == REDUCE_SUM || reduceOp == REDUCE_AVG || reduceOp == REDUCE_SUM2) )
         ddepth = CV_32S;
 
     Mat src(sz, matType);
@@ -35,7 +35,7 @@ PERF_TEST_P(Size_MatType_ROp, reduceR,
     int runs = 15;
     TEST_CYCLE_MULTIRUN(runs) reduce(src, vec, 0, reduceOp, ddepth);
 
-    SANITY_CHECK(vec, 1);
+    SANITY_CHECK_NOTHING();
 }
 
 PERF_TEST_P(Size_MatType_ROp, reduceC,
@@ -51,7 +51,7 @@ PERF_TEST_P(Size_MatType_ROp, reduceC,
     int reduceOp = get<2>(GetParam());
 
     int ddepth = -1;
-    if( CV_MAT_DEPTH(matType)< CV_32S && (reduceOp == REDUCE_SUM || reduceOp == REDUCE_AVG) )
+    if( CV_MAT_DEPTH(matType)< CV_32S && (reduceOp == REDUCE_SUM || reduceOp == REDUCE_AVG || reduceOp == REDUCE_SUM2) )
         ddepth = CV_32S;
 
     Mat src(sz, matType);
@@ -62,7 +62,7 @@ PERF_TEST_P(Size_MatType_ROp, reduceC,
 
     TEST_CYCLE() reduce(src, vec, 1, reduceOp, ddepth);
 
-    SANITY_CHECK(vec, 1);
+    SANITY_CHECK_NOTHING();
 }
 
 typedef tuple<Size, MatType, int> Size_MatType_RMode_t;

modules/core/src/arithm.cpp

@@ -489,7 +489,7 @@ static bool ocl_arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
     int kercn = haveMask || haveScalar ? cn : ocl::predictOptimalVectorWidth(_src1, _src2, _dst);
     int scalarcn = kercn == 3 ? 4 : kercn, rowsPerWI = d.isIntel() ? 4 : 1;
 
-    char cvtstr[4][32], opts[1024];
+    char cvtstr[4][50], opts[1024];
     snprintf(opts, sizeof(opts), "-D %s%s -D %s -D srcT1=%s -D srcT1_C1=%s -D srcT2=%s -D srcT2_C1=%s "
             "-D dstT=%s -D DEPTH_dst=%d -D dstT_C1=%s -D workT=%s -D workST=%s -D scaleT=%s -D wdepth=%d -D convertToWT1=%s "
             "-D convertToWT2=%s -D convertToDT=%s%s -D cn=%d -D rowsPerWI=%d -D convertFromU=%s",
@@ -500,12 +500,12 @@ static bool ocl_arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
             ocl::typeToStr(ddepth), ocl::typeToStr(CV_MAKETYPE(wdepth, kercn)),
             ocl::typeToStr(CV_MAKETYPE(wdepth, scalarcn)),
             ocl::typeToStr(wdepth), wdepth,
-            ocl::convertTypeStr(depth1, wdepth, kercn, cvtstr[0]),
-            ocl::convertTypeStr(depth2, wdepth, kercn, cvtstr[1]),
-            ocl::convertTypeStr(wdepth, ddepth, kercn, cvtstr[2]),
+            ocl::convertTypeStr(depth1, wdepth, kercn, cvtstr[0], sizeof(cvtstr[0])),
+            ocl::convertTypeStr(depth2, wdepth, kercn, cvtstr[1], sizeof(cvtstr[1])),
+            ocl::convertTypeStr(wdepth, ddepth, kercn, cvtstr[2], sizeof(cvtstr[2])),
             doubleSupport ? " -D DOUBLE_SUPPORT" : "", kercn, rowsPerWI,
             oclop == OCL_OP_ABSDIFF && wdepth == CV_32S && ddepth == wdepth ?
-            ocl::convertTypeStr(CV_8U, ddepth, kercn, cvtstr[3]) : "noconvert");
+            ocl::convertTypeStr(CV_8U, ddepth, kercn, cvtstr[3], sizeof(cvtstr[3])) : "noconvert");
 
     size_t usrdata_esz = CV_ELEM_SIZE(wdepth);
     const uchar* usrdata_p = (const uchar*)usrdata;
@@ -1098,7 +1098,7 @@ static bool ocl_compare(InputArray _src1, InputArray _src2, OutputArray _dst, in
 
     int scalarcn = kercn == 3 ? 4 : kercn;
     const char * const operationMap[] = { "==", ">", ">=", "<", "<=", "!=" };
-    char cvt[40];
+    char cvt[50];
 
     String opts = format("-D %s -D srcT1=%s -D dstT=%s -D DEPTH_dst=%d -D workT=srcT1 -D cn=%d"
                          " -D convertToDT=%s -D OP_CMP -D CMP_OPERATOR=%s -D srcT1_C1=%s"
@@ -1106,7 +1106,7 @@ static bool ocl_compare(InputArray _src1, InputArray _src2, OutputArray _dst, in
                          haveScalar ? "UNARY_OP" : "BINARY_OP",
                          ocl::typeToStr(CV_MAKE_TYPE(depth1, kercn)),
                          ocl::typeToStr(CV_8UC(kercn)), CV_8U, kercn,
-                         ocl::convertTypeStr(depth1, CV_8U, kercn, cvt),
+                         ocl::convertTypeStr(depth1, CV_8U, kercn, cvt, sizeof(cvt)),
                          operationMap[op], ocl::typeToStr(depth1),
                          ocl::typeToStr(depth1), ocl::typeToStr(CV_8U),
                          ocl::typeToStr(CV_MAKE_TYPE(depth1, scalarcn)), rowsPerWI,

modules/core/src/convert_scale.dispatch.cpp

@@ -59,8 +59,8 @@ static bool ocl_convertScaleAbs( InputArray _src, OutputArray _dst, double alpha
                          ocl::typeToStr(CV_8UC(kercn)), CV_8U,
                          ocl::typeToStr(CV_MAKE_TYPE(depth, kercn)),
                          ocl::typeToStr(CV_MAKE_TYPE(wdepth, kercn)), wdepth,
-                         ocl::convertTypeStr(depth, wdepth, kercn, cvt[0]),
-                         ocl::convertTypeStr(wdepth, CV_8U, kercn, cvt[1]),
+                         ocl::convertTypeStr(depth, wdepth, kercn, cvt[0], sizeof(cvt[0])),
+                         ocl::convertTypeStr(wdepth, CV_8U, kercn, cvt[1], sizeof(cvt[1])),
                          ocl::typeToStr(wdepth), rowsPerWI,
                          doubleSupport ? " -D DOUBLE_SUPPORT" : "");
     ocl::Kernel k("KF", ocl::core::arithm_oclsrc, build_opt);

modules/core/src/count_non_zero.dispatch.cpp

@@ -62,10 +62,6 @@ static bool ipp_countNonZero( Mat &src, int &res )
 {
     CV_INSTRUMENT_REGION_IPP();
 
-    // see https://github.com/opencv/opencv/issues/17453
-    if (src.dims <= 2 && src.step > 520000 && cv::ipp::getIppTopFeatures() == ippCPUID_SSE42)
-        return false;
-
 #if IPP_VERSION_X100 < 201801
     // Poor performance of SSE42
     if(cv::ipp::getIppTopFeatures() == ippCPUID_SSE42)

modules/core/src/cuda_stream.cpp

@@ -586,6 +586,15 @@ Stream cv::cuda::StreamAccessor::wrapStream(cudaStream_t stream)
 
 #endif
 
+Stream cv::cuda::wrapStream(size_t cudaStreamMemoryAddress) {
+#ifndef HAVE_CUDA
+    CV_UNUSED(cudaStreamMemoryAddress);
+    throw_no_cuda();
+#else
+    return cv::cuda::StreamAccessor::wrapStream(reinterpret_cast<cudaStream_t>(cudaStreamMemoryAddress));
+#endif
+}
+
 /////////////////////////////////////////////////////////////
 /// StackAllocator
 

modules/core/src/hal_replacement.hpp

@@ -531,7 +531,7 @@ inline int hal_ni_dftFree1D(cvhalDFT *context) { return CV_HAL_ERROR_NOT_IMPLEME
 /**
 @param context double pointer to context storing all necessary data
 @param width,height image dimensions
-@param depth image type (CV_32F or CV64F)
+@param depth image type (CV_32F or CV_64F)
 @param src_channels number of channels in input image
 @param dst_channels number of channels in output image
 @param flags algorithm options (combination of CV_HAL_DFT_INVERSE, ...)
@@ -558,7 +558,7 @@ inline int hal_ni_dftFree2D(cvhalDFT *context) { return CV_HAL_ERROR_NOT_IMPLEME
 /**
 @param context double pointer to context storing all necessary data
 @param width,height image dimensions
-@param depth image type (CV_32F or CV64F)
+@param depth image type (CV_32F or CV_64F)
 @param flags algorithm options (combination of CV_HAL_DFT_INVERSE, ...)
  */
 inline int hal_ni_dctInit2D(cvhalDFT **context, int width, int height, int depth, int flags) { return CV_HAL_ERROR_NOT_IMPLEMENTED; }

modules/core/src/mathfuncs_core.dispatch.cpp

@@ -7,10 +7,6 @@
 #include "mathfuncs_core.simd.hpp"
 #include "mathfuncs_core.simd_declarations.hpp" // defines CV_CPU_DISPATCH_MODES_ALL=AVX2,...,BASELINE based on CMakeLists.txt content
 
-
-#define IPP_DISABLE_MAGNITUDE_32F 1  // accuracy: https://github.com/opencv/opencv/issues/19506
-
-
 namespace cv { namespace hal {
 
 ///////////////////////////////////// ATAN2 ////////////////////////////////////
@@ -48,25 +44,8 @@ void magnitude32f(const float* x, const float* y, float* mag, int len)
     CV_INSTRUMENT_REGION();
 
     CALL_HAL(magnitude32f, cv_hal_magnitude32f, x, y, mag, len);
-
-#ifdef HAVE_IPP
-    bool allowIPP = true;
-#ifdef IPP_DISABLE_MAGNITUDE_32F
-    if (cv::ipp::getIppTopFeatures() & (
-#if IPP_VERSION_X100 >= 201700
-            ippCPUID_AVX512F |
-#endif
-            ippCPUID_AVX2)
-    )
-    {
-        allowIPP = (len & 7) == 0;
-    }
-#endif
-
     // SSE42 performance issues
-    CV_IPP_RUN((IPP_VERSION_X100 > 201800 || cv::ipp::getIppTopFeatures() != ippCPUID_SSE42) && allowIPP,
-        CV_INSTRUMENT_FUN_IPP(ippsMagnitude_32f, x, y, mag, len) >= 0);
-#endif
+    CV_IPP_RUN(IPP_VERSION_X100 > 201800 || cv::ipp::getIppTopFeatures() != ippCPUID_SSE42, CV_INSTRUMENT_FUN_IPP(ippsMagnitude_32f, x, y, mag, len) >= 0);
 
     CV_CPU_DISPATCH(magnitude32f, (x, y, mag, len),
         CV_CPU_DISPATCH_MODES_ALL);

modules/core/src/matmul.dispatch.cpp

@@ -606,8 +606,8 @@ static bool ocl_scaleAdd( InputArray _src1, double alpha, InputArray _src2, Outp
                          " -D wdepth=%d%s -D rowsPerWI=%d",
                          ocl::typeToStr(CV_MAKE_TYPE(depth, kercn)), depth,
                          ocl::typeToStr(CV_MAKE_TYPE(wdepth, kercn)),
-                         ocl::convertTypeStr(depth, wdepth, kercn, cvt[0]),
-                         ocl::convertTypeStr(wdepth, depth, kercn, cvt[1]),
+                         ocl::convertTypeStr(depth, wdepth, kercn, cvt[0], sizeof(cvt[0])),
+                         ocl::convertTypeStr(wdepth, depth, kercn, cvt[1], sizeof(cvt[1])),
                          ocl::typeToStr(wdepth), wdepth,
                          doubleSupport ? " -D DOUBLE_SUPPORT" : "", rowsPerWI));
     if (k.empty())
@@ -1041,13 +1041,13 @@ static bool ocl_dot( InputArray _src1, InputArray _src2, double & res )
         wgs2_aligned <<= 1;
     wgs2_aligned >>= 1;
 
-    char cvt[40];
+    char cvt[50];
     ocl::Kernel k("reduce", ocl::core::reduce_oclsrc,
                   format("-D srcT=%s -D srcT1=%s -D dstT=%s -D dstTK=%s -D ddepth=%d -D convertToDT=%s -D OP_DOT "
                          "-D WGS=%d -D WGS2_ALIGNED=%d%s%s%s -D kercn=%d",
                          ocl::typeToStr(CV_MAKE_TYPE(depth, kercn)), ocl::typeToStr(depth),
                          ocl::typeToStr(ddepth), ocl::typeToStr(CV_MAKE_TYPE(ddepth, kercn)),
-                         ddepth, ocl::convertTypeStr(depth, ddepth, kercn, cvt),
+                         ddepth, ocl::convertTypeStr(depth, ddepth, kercn, cvt, sizeof(cvt)),
                          (int)wgs, wgs2_aligned, doubleSupport ? " -D DOUBLE_SUPPORT" : "",
                          _src1.isContinuous() ? " -D HAVE_SRC_CONT" : "",
                          _src2.isContinuous() ? " -D HAVE_SRC2_CONT" : "", kercn));

modules/core/src/matrix_operations.cpp

@@ -341,29 +341,32 @@ cv::Mat cv::Mat::cross(InputArray _m) const
 namespace cv
 {
 
-template<typename T, typename ST, class Op> static void
-reduceR_( const Mat& srcmat, Mat& dstmat )
+template<typename T, typename ST, typename WT, class Op, class OpInit>
+class ReduceR_Invoker : public ParallelLoopBody
 {
-    typedef typename Op::rtype WT;
-    Size size = srcmat.size();
-    size.width *= srcmat.channels();
-    AutoBuffer<WT> buffer(size.width);
+public:
+  ReduceR_Invoker(const Mat& aSrcmat, Mat& aDstmat, Op& aOp, OpInit& aOpInit)
+                 :srcmat(aSrcmat),dstmat(aDstmat),op(aOp),opInit(aOpInit),buffer(srcmat.size().width*srcmat.channels())
+  {
+  }
+  void operator()(const Range& range) const CV_OVERRIDE
+  {
+    const T* src = srcmat.ptr<T>();
+    const size_t srcstep = srcmat.step/sizeof(src[0]);
     WT* buf = buffer.data();
     ST* dst = dstmat.ptr<ST>();
-    const T* src = srcmat.ptr<T>();
-    size_t srcstep = srcmat.step/sizeof(src[0]);
-    int i;
-    Op op;
+    int i = 0;
 
-    for( i = 0; i < size.width; i++ )
-        buf[i] = src[i];
+    for( i = range.start ; i < range.end; i++ )
+        buf[i] = opInit(src[i]);
 
-    for( ; --size.height; )
+    int height = srcmat.size().height;
+    for( ; --height; )
     {
         src += srcstep;
-        i = 0;
+        i = range.start;
         #if CV_ENABLE_UNROLLED
-        for(; i <= size.width - 4; i += 4 )
+        for(; i <= range.end - 4; i += 4 )
         {
             WT s0, s1;
             s0 = op(buf[i], (WT)src[i]);
@@ -375,63 +378,94 @@ reduceR_( const Mat& srcmat, Mat& dstmat )
             buf[i+2] = s0; buf[i+3] = s1;
         }
         #endif
-        for( ; i < size.width; i++ )
+        for( ; i < range.end; i++ )
             buf[i] = op(buf[i], (WT)src[i]);
     }
 
-    for( i = 0; i < size.width; i++ )
+    for( i = range.start ; i < range.end; i++ )
         dst[i] = (ST)buf[i];
-}
+  }
+private:
+  const Mat& srcmat;
+  Mat& dstmat;
+  Op& op;
+  OpInit& opInit;
+  mutable AutoBuffer<WT> buffer;
+};
 
-
-template<typename T, typename ST, class Op> static void
-reduceC_( const Mat& srcmat, Mat& dstmat )
+template<typename T, typename ST, class Op, class OpInit = OpNop<ST> > static void
+reduceR_( const Mat& srcmat, Mat& dstmat)
 {
     typedef typename Op::rtype WT;
-    Size size = srcmat.size();
-    int cn = srcmat.channels();
-    size.width *= cn;
     Op op;
+    OpInit opInit;
 
-    for( int y = 0; y < size.height; y++ )
+    ReduceR_Invoker<T, ST, WT, Op, OpInit> body(srcmat, dstmat, op, opInit);
+    //group columns by 64 bytes for data locality
+    parallel_for_(Range(0, srcmat.size().width*srcmat.channels()), body, srcmat.size().width*CV_ELEM_SIZE(srcmat.depth())/64);
+}
+
+template<typename T, typename ST, typename WT, class Op, class OpInit>
+class ReduceC_Invoker : public ParallelLoopBody
+{
+public:
+  ReduceC_Invoker(const Mat& aSrcmat, Mat& aDstmat, Op& aOp, OpInit& aOpInit)
+                 :srcmat(aSrcmat),dstmat(aDstmat),op(aOp),opInit(aOpInit)
+  {
+  }
+  void operator()(const Range& range) const CV_OVERRIDE
+  {
+    const int cn = srcmat.channels();
+    const int width = srcmat.size().width*cn;
+    AutoBuffer<WT> cumul(cn);
+    for( int y = range.start; y < range.end; y++ )
     {
         const T* src = srcmat.ptr<T>(y);
         ST* dst = dstmat.ptr<ST>(y);
-        if( size.width == cn )
-            for( int k = 0; k < cn; k++ )
-                dst[k] = src[k];
+        if( width == cn )
+        {
+          for( int k = 0; k < cn; k++ )
+              dst[k] = (ST)opInit(src[k]);
+        }
         else
         {
-            for( int k = 0; k < cn; k++ )
+            for(int k = 0; k < cn ; ++k )
+              cumul[k] = opInit(src[k]);
+            for(int k = cn ; k < width ; k += cn )
             {
-                WT a0 = src[k], a1 = src[k+cn];
-                int i;
-                for( i = 2*cn; i <= size.width - 4*cn; i += 4*cn )
-                {
-                    a0 = op(a0, (WT)src[i+k]);
-                    a1 = op(a1, (WT)src[i+k+cn]);
-                    a0 = op(a0, (WT)src[i+k+cn*2]);
-                    a1 = op(a1, (WT)src[i+k+cn*3]);
-                }
-
-                for( ; i < size.width; i += cn )
-                {
-                    a0 = op(a0, (WT)src[i+k]);
-                }
-                a0 = op(a0, a1);
-                dst[k] = (ST)a0;
+                for (int c = 0 ; c < cn ; ++c)
+                  cumul[c] = op(cumul[c], src[k+c]);
             }
+            for(int k = 0 ; k < cn ; ++k )
+              dst[k] = (ST)cumul[k];
         }
     }
+  }
+private:
+  const Mat& srcmat;
+  Mat& dstmat;
+  Op& op;
+  OpInit& opInit;
+};
+
+template<typename T, typename ST, class Op, class OpInit = OpNop<ST> > static void
+reduceC_( const Mat& srcmat, Mat& dstmat)
+{
+    typedef typename Op::rtype WT;
+    Op op;
+    OpInit opInit;
+
+    ReduceC_Invoker<T, ST, WT, Op, OpInit> body(srcmat, dstmat, op, opInit);
+    parallel_for_(Range(0, srcmat.size().height), body);
 }
 
 typedef void (*ReduceFunc)( const Mat& src, Mat& dst );
 
 }
 
-#define reduceSumR8u32s  reduceR_<uchar, int,   OpAdd<int> >
-#define reduceSumR8u32f  reduceR_<uchar, float, OpAdd<int> >
-#define reduceSumR8u64f  reduceR_<uchar, double,OpAdd<int> >
+#define reduceSumR8u32s  reduceR_<uchar, int,   OpAdd<int>, OpNop<int> >
+#define reduceSumR8u32f  reduceR_<uchar, float, OpAdd<int>, OpNop<int> >
+#define reduceSumR8u64f  reduceR_<uchar, double,OpAdd<int>, OpNop<int> >
 #define reduceSumR16u32f reduceR_<ushort,float, OpAdd<float> >
 #define reduceSumR16u64f reduceR_<ushort,double,OpAdd<double> >
 #define reduceSumR16s32f reduceR_<short, float, OpAdd<float> >
@@ -440,6 +474,17 @@ typedef void (*ReduceFunc)( const Mat& src, Mat& dst );
 #define reduceSumR32f64f reduceR_<float, double,OpAdd<double> >
 #define reduceSumR64f64f reduceR_<double,double,OpAdd<double> >
 
+#define reduceSum2R8u32s  reduceR_<uchar, int,   OpAddSqr<int>,   OpSqr<int> >
+#define reduceSum2R8u32f  reduceR_<uchar, float, OpAddSqr<int>,   OpSqr<int> >
+#define reduceSum2R8u64f  reduceR_<uchar, double,OpAddSqr<int>,   OpSqr<int> >
+#define reduceSum2R16u32f reduceR_<ushort,float, OpAddSqr<float>, OpSqr<float> >
+#define reduceSum2R16u64f reduceR_<ushort,double,OpAddSqr<double>,OpSqr<double> >
+#define reduceSum2R16s32f reduceR_<short, float, OpAddSqr<float>, OpSqr<float> >
+#define reduceSum2R16s64f reduceR_<short, double,OpAddSqr<double>,OpSqr<double> >
+#define reduceSum2R32f32f reduceR_<float, float, OpAddSqr<float>, OpSqr<float> >
+#define reduceSum2R32f64f reduceR_<float, double,OpAddSqr<double>,OpSqr<double> >
+#define reduceSum2R64f64f reduceR_<double,double,OpAddSqr<double>,OpSqr<double> >
+
 #define reduceMaxR8u  reduceR_<uchar, uchar, OpMax<uchar> >
 #define reduceMaxR16u reduceR_<ushort,ushort,OpMax<ushort> >
 #define reduceMaxR16s reduceR_<short, short, OpMax<short> >
@@ -527,23 +572,35 @@ static inline void reduceSumC_8u16u16s32f_64f(const cv::Mat& srcmat, cv::Mat& ds
 
 #endif
 
-#define reduceSumC8u32s  reduceC_<uchar, int,   OpAdd<int> >
-#define reduceSumC8u32f  reduceC_<uchar, float, OpAdd<int> >
+#define reduceSumC8u32s  reduceC_<uchar, int,   OpAdd<int>, OpNop<int> >
+#define reduceSumC8u32f  reduceC_<uchar, float, OpAdd<int>, OpNop<int> >
 #define reduceSumC16u32f reduceC_<ushort,float, OpAdd<float> >
 #define reduceSumC16s32f reduceC_<short, float, OpAdd<float> >
 #define reduceSumC32f32f reduceC_<float, float, OpAdd<float> >
 #define reduceSumC64f64f reduceC_<double,double,OpAdd<double> >
 
+#define reduceSum2C8u32s  reduceC_<uchar, int,   OpAddSqr<int>,   OpSqr<int> >
+#define reduceSum2C8u32f  reduceC_<uchar, float, OpAddSqr<int>,   OpSqr<int> >
+#define reduceSum2C16u32f reduceC_<ushort,float, OpAddSqr<float>, OpSqr<float> >
+#define reduceSum2C16s32f reduceC_<short, float, OpAddSqr<float>, OpSqr<float> >
+#define reduceSum2C32f32f reduceC_<float, float, OpAddSqr<float>, OpSqr<float> >
+#define reduceSum2C64f64f reduceC_<double,double,OpAddSqr<double>,OpSqr<double> >
+
 #ifdef HAVE_IPP
 #define reduceSumC8u64f  reduceSumC_8u16u16s32f_64f
 #define reduceSumC16u64f reduceSumC_8u16u16s32f_64f
 #define reduceSumC16s64f reduceSumC_8u16u16s32f_64f
 #define reduceSumC32f64f reduceSumC_8u16u16s32f_64f
 #else
-#define reduceSumC8u64f  reduceC_<uchar, double,OpAdd<int> >
+#define reduceSumC8u64f  reduceC_<uchar, double,OpAdd<int>, OpNop<int> >
 #define reduceSumC16u64f reduceC_<ushort,double,OpAdd<double> >
 #define reduceSumC16s64f reduceC_<short, double,OpAdd<double> >
 #define reduceSumC32f64f reduceC_<float, double,OpAdd<double> >
+
+#define reduceSum2C8u64f  reduceC_<uchar, double,OpAddSqr<int>,   OpSqr<int> >
+#define reduceSum2C16u64f reduceC_<ushort,double,OpAddSqr<double>,OpSqr<double> >
+#define reduceSum2C16s64f reduceC_<short, double,OpAddSqr<double>,OpSqr<double> >
+#define reduceSum2C32f64f reduceC_<float, double,OpAddSqr<double>,OpSqr<double> >
 #endif
 
 #ifdef HAVE_IPP
@@ -622,8 +679,9 @@ static bool ocl_reduce(InputArray _src, OutputArray _dst,
             ddepth = CV_32S;
     }
 
-    const char * const ops[4] = { "OCL_CV_REDUCE_SUM", "OCL_CV_REDUCE_AVG",
-                                  "OCL_CV_REDUCE_MAX", "OCL_CV_REDUCE_MIN" };
+    const char * const ops[5] = { "OCL_CV_REDUCE_SUM", "OCL_CV_REDUCE_AVG",
+                                  "OCL_CV_REDUCE_MAX", "OCL_CV_REDUCE_MIN",
+                                  "OCL_CV_REDUCE_SUM2"};
     int wdepth = std::max(ddepth, CV_32F);
     if (useOptimized)
     {
@@ -633,7 +691,7 @@ static bool ocl_reduce(InputArray _src, OutputArray _dst,
             static const size_t maxItemInGroupCount = 16;
             tileHeight = min(tileHeight, defDev.localMemSize() / buf_cols / CV_ELEM_SIZE(CV_MAKETYPE(wdepth, cn)) / maxItemInGroupCount);
         }
-        char cvt[3][40];
+        char cvt[3][50];
         cv::String build_opt = format("-D OP_REDUCE_PRE -D BUF_COLS=%d -D TILE_HEIGHT=%zu -D %s -D dim=1"
                                             " -D cn=%d -D ddepth=%d"
                                             " -D srcT=%s -D bufT=%s -D dstT=%s"
@@ -642,9 +700,9 @@ static bool ocl_reduce(InputArray _src, OutputArray _dst,
                                             ocl::typeToStr(sdepth),
                                             ocl::typeToStr(ddepth),
                                             ocl::typeToStr(ddepth0),
-                                            ocl::convertTypeStr(ddepth, wdepth, 1, cvt[0]),
-                                            ocl::convertTypeStr(sdepth, ddepth, 1, cvt[1]),
-                                            ocl::convertTypeStr(wdepth, ddepth0, 1, cvt[2]),
+                                            ocl::convertTypeStr(ddepth, wdepth, 1, cvt[0], sizeof(cvt[0])),
+                                            ocl::convertTypeStr(sdepth, ddepth, 1, cvt[1], sizeof(cvt[1])),
+                                            ocl::convertTypeStr(wdepth, ddepth0, 1, cvt[2], sizeof(cvt[2])),
                                             doubleSupport ? " -D DOUBLE_SUPPORT" : "");
         ocl::Kernel k("reduce_horz_opt", ocl::core::reduce2_oclsrc, build_opt);
         if (k.empty())
@@ -667,15 +725,15 @@ static bool ocl_reduce(InputArray _src, OutputArray _dst,
     }
     else
     {
-        char cvt[2][40];
+        char cvt[2][50];
         cv::String build_opt = format("-D %s -D dim=%d -D cn=%d -D ddepth=%d"
                                       " -D srcT=%s -D dstT=%s -D dstT0=%s -D convertToWT=%s"
                                       " -D convertToDT=%s -D convertToDT0=%s%s",
                                       ops[op], dim, cn, ddepth, ocl::typeToStr(useOptimized ? ddepth : sdepth),
                                       ocl::typeToStr(ddepth), ocl::typeToStr(ddepth0),
-                                      ocl::convertTypeStr(ddepth, wdepth, 1, cvt[0]),
-                                      ocl::convertTypeStr(sdepth, ddepth, 1, cvt[0]),
-                                      ocl::convertTypeStr(wdepth, ddepth0, 1, cvt[1]),
+                                      ocl::convertTypeStr(ddepth, wdepth, 1, cvt[0], sizeof(cvt[0])),
+                                      ocl::convertTypeStr(sdepth, ddepth, 1, cvt[0], sizeof(cvt[0])),
+                                      ocl::convertTypeStr(wdepth, ddepth0, 1, cvt[1], sizeof(cvt[1])),
                                       doubleSupport ? " -D DOUBLE_SUPPORT" : "");
 
         ocl::Kernel k("reduce", ocl::core::reduce2_oclsrc, build_opt);
@@ -718,7 +776,8 @@ void cv::reduce(InputArray _src, OutputArray _dst, int dim, int op, int dtype)
 
     CV_Assert( cn == CV_MAT_CN(dtype) );
     CV_Assert( op == REDUCE_SUM || op == REDUCE_MAX ||
-               op == REDUCE_MIN || op == REDUCE_AVG );
+               op == REDUCE_MIN || op == REDUCE_AVG ||
+               op == REDUCE_SUM2);
 
     CV_OCL_RUN(_dst.isUMat(),
                ocl_reduce(_src, _dst, dim, op, op0, stype, dtype))
@@ -748,7 +807,7 @@ void cv::reduce(InputArray _src, OutputArray _dst, int dim, int op, int dtype)
         if( op == REDUCE_SUM )
         {
             if(sdepth == CV_8U && ddepth == CV_32S)
-                func = GET_OPTIMIZED(reduceSumR8u32s);
+                func = reduceSumR8u32s;
             else if(sdepth == CV_8U && ddepth == CV_32F)
                 func = reduceSumR8u32f;
             else if(sdepth == CV_8U && ddepth == CV_64F)
@@ -762,7 +821,7 @@ void cv::reduce(InputArray _src, OutputArray _dst, int dim, int op, int dtype)
             else if(sdepth == CV_16S && ddepth == CV_64F)
                 func = reduceSumR16s64f;
             else if(sdepth == CV_32F && ddepth == CV_32F)
-                func = GET_OPTIMIZED(reduceSumR32f32f);
+                func = reduceSumR32f32f;
             else if(sdepth == CV_32F && ddepth == CV_64F)
                 func = reduceSumR32f64f;
             else if(sdepth == CV_64F && ddepth == CV_64F)
@@ -771,36 +830,59 @@ void cv::reduce(InputArray _src, OutputArray _dst, int dim, int op, int dtype)
         else if(op == REDUCE_MAX)
         {
             if(sdepth == CV_8U && ddepth == CV_8U)
-                func = GET_OPTIMIZED(reduceMaxR8u);
+                func = reduceMaxR8u;
             else if(sdepth == CV_16U && ddepth == CV_16U)
                 func = reduceMaxR16u;
             else if(sdepth == CV_16S && ddepth == CV_16S)
                 func = reduceMaxR16s;
             else if(sdepth == CV_32F && ddepth == CV_32F)
-                func = GET_OPTIMIZED(reduceMaxR32f);
+                func = reduceMaxR32f;
             else if(sdepth == CV_64F && ddepth == CV_64F)
                 func = reduceMaxR64f;
         }
         else if(op == REDUCE_MIN)
         {
             if(sdepth == CV_8U && ddepth == CV_8U)
-                func = GET_OPTIMIZED(reduceMinR8u);
+                func = reduceMinR8u;
             else if(sdepth == CV_16U && ddepth == CV_16U)
                 func = reduceMinR16u;
             else if(sdepth == CV_16S && ddepth == CV_16S)
                 func = reduceMinR16s;
             else if(sdepth == CV_32F && ddepth == CV_32F)
-                func = GET_OPTIMIZED(reduceMinR32f);
+                func = reduceMinR32f;
             else if(sdepth == CV_64F && ddepth == CV_64F)
                 func = reduceMinR64f;
         }
+        else if( op == REDUCE_SUM2 )
+        {
+            if(sdepth == CV_8U && ddepth == CV_32S)
+                func = reduceSum2R8u32s;
+            else if(sdepth == CV_8U && ddepth == CV_32F)
+                func = reduceSum2R8u32f;
+            else if(sdepth == CV_8U && ddepth == CV_64F)
+                func = reduceSum2R8u64f;
+            else if(sdepth == CV_16U && ddepth == CV_32F)
+                func = reduceSum2R16u32f;
+            else if(sdepth == CV_16U && ddepth == CV_64F)
+                func = reduceSum2R16u64f;
+            else if(sdepth == CV_16S && ddepth == CV_32F)
+                func = reduceSum2R16s32f;
+            else if(sdepth == CV_16S && ddepth == CV_64F)
+                func = reduceSum2R16s64f;
+            else if(sdepth == CV_32F && ddepth == CV_32F)
+                func = reduceSum2R32f32f;
+            else if(sdepth == CV_32F && ddepth == CV_64F)
+                func = reduceSum2R32f64f;
+            else if(sdepth == CV_64F && ddepth == CV_64F)
+                func = reduceSum2R64f64f;
+        }
     }
     else
     {
         if(op == REDUCE_SUM)
         {
             if(sdepth == CV_8U && ddepth == CV_32S)
-                func = GET_OPTIMIZED(reduceSumC8u32s);
+                func = reduceSumC8u32s;
             else if(sdepth == CV_8U && ddepth == CV_32F)
                 func = reduceSumC8u32f;
             else if(sdepth == CV_8U && ddepth == CV_64F)
@@ -814,7 +896,7 @@ void cv::reduce(InputArray _src, OutputArray _dst, int dim, int op, int dtype)
             else if(sdepth == CV_16S && ddepth == CV_64F)
                 func = reduceSumC16s64f;
             else if(sdepth == CV_32F && ddepth == CV_32F)
-                func = GET_OPTIMIZED(reduceSumC32f32f);
+                func = reduceSumC32f32f;
             else if(sdepth == CV_32F && ddepth == CV_64F)
                 func = reduceSumC32f64f;
             else if(sdepth == CV_64F && ddepth == CV_64F)
@@ -823,29 +905,52 @@ void cv::reduce(InputArray _src, OutputArray _dst, int dim, int op, int dtype)
         else if(op == REDUCE_MAX)
         {
             if(sdepth == CV_8U && ddepth == CV_8U)
-                func = GET_OPTIMIZED(reduceMaxC8u);
+                func = reduceMaxC8u;
             else if(sdepth == CV_16U && ddepth == CV_16U)
                 func = reduceMaxC16u;
             else if(sdepth == CV_16S && ddepth == CV_16S)
                 func = reduceMaxC16s;
             else if(sdepth == CV_32F && ddepth == CV_32F)
-                func = GET_OPTIMIZED(reduceMaxC32f);
+                func = reduceMaxC32f;
             else if(sdepth == CV_64F && ddepth == CV_64F)
                 func = reduceMaxC64f;
         }
         else if(op == REDUCE_MIN)
         {
             if(sdepth == CV_8U && ddepth == CV_8U)
-                func = GET_OPTIMIZED(reduceMinC8u);
+                func = reduceMinC8u;
             else if(sdepth == CV_16U && ddepth == CV_16U)
                 func = reduceMinC16u;
             else if(sdepth == CV_16S && ddepth == CV_16S)
                 func = reduceMinC16s;
             else if(sdepth == CV_32F && ddepth == CV_32F)
-                func = GET_OPTIMIZED(reduceMinC32f);
+                func = reduceMinC32f;
             else if(sdepth == CV_64F && ddepth == CV_64F)
                 func = reduceMinC64f;
         }
+        else if(op == REDUCE_SUM2)
+        {
+            if(sdepth == CV_8U && ddepth == CV_32S)
+                func = reduceSum2C8u32s;
+            else if(sdepth == CV_8U && ddepth == CV_32F)
+                func = reduceSum2C8u32f;
+            else if(sdepth == CV_8U && ddepth == CV_64F)
+                func = reduceSum2C8u64f;
+            else if(sdepth == CV_16U && ddepth == CV_32F)
+                func = reduceSum2C16u32f;
+            else if(sdepth == CV_16U && ddepth == CV_64F)
+                func = reduceSum2C16u64f;
+            else if(sdepth == CV_16S && ddepth == CV_32F)
+                func = reduceSum2C16s32f;
+            else if(sdepth == CV_16S && ddepth == CV_64F)
+                func = reduceSum2C16s64f;
+            else if(sdepth == CV_32F && ddepth == CV_32F)
+                func = reduceSum2C32f32f;
+            else if(sdepth == CV_32F && ddepth == CV_64F)
+                func = reduceSum2C32f64f;
+            else if(sdepth == CV_64F && ddepth == CV_64F)
+                func = reduceSum2C64f64f;
+        }
     }
 
     if( !func )

modules/core/src/mean.dispatch.cpp

@@ -227,17 +227,17 @@ static bool ocl_meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv
         if ( (!doubleSupport && depth == CV_64F) )
             return false;
 
-        char cvt[2][40];
+        char cvt[2][50];
         String opts = format("-D srcT=%s -D srcT1=%s -D dstT=%s -D dstT1=%s -D sqddepth=%d"
                              " -D sqdstT=%s -D sqdstT1=%s -D convertToSDT=%s -D cn=%d%s%s"
                              " -D convertToDT=%s -D WGS=%d -D WGS2_ALIGNED=%d%s%s",
                              ocl::typeToStr(type), ocl::typeToStr(depth),
                              ocl::typeToStr(dtype), ocl::typeToStr(ddepth), sqddepth,
                              ocl::typeToStr(sqdtype), ocl::typeToStr(sqddepth),
-                             ocl::convertTypeStr(depth, sqddepth, cn, cvt[0]),
+                             ocl::convertTypeStr(depth, sqddepth, cn, cvt[0], sizeof(cvt[0])),
                              cn, isContinuous ? " -D HAVE_SRC_CONT" : "",
                              isMaskContinuous ? " -D HAVE_MASK_CONT" : "",
-                             ocl::convertTypeStr(depth, ddepth, cn, cvt[1]),
+                             ocl::convertTypeStr(depth, ddepth, cn, cvt[1], sizeof(cvt[1])),
                              (int)wgs, wgs2_aligned, haveMask ? " -D HAVE_MASK" : "",
                              doubleSupport ? " -D DOUBLE_SUPPORT" : "");
 

modules/core/src/minmax.cpp

@@ -1029,7 +1029,7 @@ bool ocl_minMaxIdx( InputArray _src, double* minVal, double* maxVal, int* minLoc
             needMaxLoc = true;
     }
 
-    char cvt[2][40];
+    char cvt[2][50];
     String opts = format("-D DEPTH_%d -D srcT1=%s%s -D WGS=%d -D srcT=%s"
                          " -D WGS2_ALIGNED=%d%s%s%s -D kercn=%d%s%s%s%s"
                          " -D dstT1=%s -D dstT=%s -D convertToDT=%s%s%s%s%s -D wdepth=%d -D convertFromU=%s"
@@ -1042,11 +1042,11 @@ bool ocl_minMaxIdx( InputArray _src, double* minVal, double* maxVal, int* minLoc
                          needMinVal ? " -D NEED_MINVAL" : "", needMaxVal ? " -D NEED_MAXVAL" : "",
                          needMinLoc ? " -D NEED_MINLOC" : "", needMaxLoc ? " -D NEED_MAXLOC" : "",
                          ocl::typeToStr(ddepth), ocl::typeToStr(CV_MAKE_TYPE(ddepth, kercn)),
-                         ocl::convertTypeStr(depth, ddepth, kercn, cvt[0]),
+                         ocl::convertTypeStr(depth, ddepth, kercn, cvt[0], sizeof(cvt[0])),
                          absValues ? " -D OP_ABS" : "",
                          haveSrc2 ? " -D HAVE_SRC2" : "", maxVal2 ? " -D OP_CALC2" : "",
                          haveSrc2 && _src2.isContinuous() ? " -D HAVE_SRC2_CONT" : "", ddepth,
-                         depth <= CV_32S && ddepth == CV_32S ? ocl::convertTypeStr(CV_8U, ddepth, kercn, cvt[1]) : "noconvert",
+                         depth <= CV_32S && ddepth == CV_32S ? ocl::convertTypeStr(CV_8U, ddepth, kercn, cvt[1], sizeof(cvt[1])) : "noconvert",
                          MINMAX_STRUCT_ALIGNMENT);
 
     ocl::Kernel k("minmaxloc", ocl::core::minmaxloc_oclsrc, opts);

modules/core/src/norm.cpp

@@ -753,7 +753,7 @@ double norm( InputArray _src, int normType, InputArray _mask )
             {
                 int bsz = std::min(total - j, blockSize);
                 hal::cvt16f32f((const float16_t*)ptrs[0], data0, bsz * cn);
-                func((uchar*)data0, ptrs[1], (uchar*)&result.d, bsz, cn);
+                func((uchar*)data0, ptrs[1], (uchar*)&result.f, bsz, cn);
                 ptrs[0] += bsz*esz;
                 if (ptrs[1])
                     ptrs[1] += bsz;
@@ -771,9 +771,9 @@ double norm( InputArray _src, int normType, InputArray _mask )
 
     if( normType == NORM_INF )
     {
-        if(depth == CV_64F || depth == CV_16F)
+        if(depth == CV_64F)
             return result.d;
-        else if (depth == CV_32F)
+        else if (depth == CV_32F || depth == CV_16F)
             return result.f;
         else
             return result.i;
@@ -995,16 +995,6 @@ static bool ipp_norm(InputArray _src1, InputArray _src2, int normType, InputArra
                 type == CV_16UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L2_16u_C3CMR :
                 type == CV_32FC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L2_32f_C3CMR :
                 0) : 0;
-            if (cv::ipp::getIppTopFeatures() & (
-#if IPP_VERSION_X100 >= 201700
-                    ippCPUID_AVX512F |
-#endif
-                    ippCPUID_AVX2)
-            ) // IPP_DISABLE_NORM_16UC3_mask_small (#11399)
-            {
-                if (normType == NORM_L1 && type == CV_16UC3 && sz.width < 16)
-                    return false;
-            }
             if( ippiNormDiff_C3CMR )
             {
                 Ipp64f norm1, norm2, norm3;
@@ -1234,7 +1224,7 @@ double norm( InputArray _src1, InputArray _src2, int normType, InputArray _mask
                 int bsz = std::min(total - j, blockSize);
                 hal::cvt16f32f((const float16_t*)ptrs[0], data0, bsz * cn);
                 hal::cvt16f32f((const float16_t*)ptrs[1], data1, bsz * cn);
-                func((uchar*)data0, (uchar*)data1, ptrs[2], (uchar*)&result.d, bsz, cn);
+                func((uchar*)data0, (uchar*)data1, ptrs[2], (uchar*)&result.f, bsz, cn);
                 ptrs[0] += bsz*esz;
                 ptrs[1] += bsz*esz;
                 if (ptrs[2])
@@ -1253,9 +1243,9 @@ double norm( InputArray _src1, InputArray _src2, int normType, InputArray _mask
 
     if( normType == NORM_INF )
     {
-        if (depth == CV_64F || depth == CV_16F)
+        if (depth == CV_64F)
             return result.d;
-        else if (depth == CV_32F)
+        else if (depth == CV_32F || depth == CV_16F)
             return result.f;
         else
             return result.u;
@@ -1319,12 +1309,12 @@ static bool ocl_normalize( InputArray _src, InputOutputArray _dst, InputArray _m
         if ((sdepth == CV_64F || ddepth == CV_64F) && !doubleSupport)
             return false;
 
-        char cvt[2][40];
+        char cvt[2][50];
         String opts = format("-D srcT=%s -D dstT=%s -D convertToWT=%s -D cn=%d -D rowsPerWI=%d"
                              " -D convertToDT=%s -D workT=%s%s%s%s -D srcT1=%s -D dstT1=%s",
                              ocl::typeToStr(stype), ocl::typeToStr(dtype),
-                             ocl::convertTypeStr(sdepth, wdepth, cn, cvt[0]), cn,
-                             rowsPerWI, ocl::convertTypeStr(wdepth, ddepth, cn, cvt[1]),
+                             ocl::convertTypeStr(sdepth, wdepth, cn, cvt[0], sizeof(cvt[0])), cn,
+                             rowsPerWI, ocl::convertTypeStr(wdepth, ddepth, cn, cvt[1], sizeof(cvt[1])),
                              ocl::typeToStr(CV_MAKE_TYPE(wdepth, cn)),
                              doubleSupport ? " -D DOUBLE_SUPPORT" : "",
                              haveScale ? " -D HAVE_SCALE" : "",

modules/core/src/ocl.cpp

@@ -1611,7 +1611,7 @@ struct Device::Impl
         if (vendorName_ == "Advanced Micro Devices, Inc." ||
             vendorName_ == "AMD")
             vendorID_ = VENDOR_AMD;
-        else if (vendorName_ == "Intel(R) Corporation" || vendorName_ == "Intel" || strstr(name_.c_str(), "Iris") != 0)
+        else if (vendorName_ == "Intel(R) Corporation" || vendorName_ == "Intel" || vendorName_ == "Intel Inc." || strstr(name_.c_str(), "Iris") != 0)
             vendorID_ = VENDOR_INTEL;
         else if (vendorName_ == "NVIDIA Corporation")
             vendorID_ = VENDOR_NVIDIA;
@@ -6964,7 +6964,7 @@ const char* typeToStr(int type)
     {
         "uchar", "uchar2", "uchar3", "uchar4", 0, 0, 0, "uchar8", 0, 0, 0, 0, 0, 0, 0, "uchar16",
         "char", "char2", "char3", "char4", 0, 0, 0, "char8", 0, 0, 0, 0, 0, 0, 0, "char16",
-        "ushort", "ushort2", "ushort3", "ushort4",0, 0, 0, "ushort8", 0, 0, 0, 0, 0, 0, 0, "ushort16",
+        "ushort", "ushort2", "ushort3", "ushort4", 0, 0, 0, "ushort8", 0, 0, 0, 0, 0, 0, 0, "ushort16",
         "short", "short2", "short3", "short4", 0, 0, 0, "short8", 0, 0, 0, 0, 0, 0, 0, "short16",
         "int", "int2", "int3", "int4", 0, 0, 0, "int8", 0, 0, 0, 0, 0, 0, 0, "int16",
         "float", "float2", "float3", "float4", 0, 0, 0, "float8", 0, 0, 0, 0, 0, 0, 0, "float16",
@@ -6973,7 +6973,7 @@ const char* typeToStr(int type)
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
     };
     int cn = CV_MAT_CN(type), depth = CV_MAT_DEPTH(type);
-    const char* result = cn > 16 ? 0 : tab[depth*16 + cn-1];
+    const char* result = cn > 16 ? nullptr : tab[depth*16 + cn-1];
     CV_Assert(result);
     return result;
 }
@@ -6984,7 +6984,7 @@ const char* memopTypeToStr(int type)
     {
         "uchar", "uchar2", "uchar3", "uchar4", 0, 0, 0, "uchar8", 0, 0, 0, 0, 0, 0, 0, "uchar16",
         "char", "char2", "char3", "char4", 0, 0, 0, "char8", 0, 0, 0, 0, 0, 0, 0, "char16",
-        "ushort", "ushort2", "ushort3", "ushort4",0, 0, 0, "ushort8", 0, 0, 0, 0, 0, 0, 0, "ushort16",
+        "ushort", "ushort2", "ushort3", "ushort4", 0, 0, 0, "ushort8", 0, 0, 0, 0, 0, 0, 0, "ushort16",
         "short", "short2", "short3", "short4", 0, 0, 0, "short8", 0, 0, 0, 0, 0, 0, 0, "short16",
         "int", "int2", "int3", "int4", 0, 0, 0, "int8", 0, 0, 0, 0, 0, 0, 0, "int16",
         "int", "int2", "int3", "int4", 0, 0, 0, "int8", 0, 0, 0, 0, 0, 0, 0, "int16",
@@ -6993,7 +6993,7 @@ const char* memopTypeToStr(int type)
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
     };
     int cn = CV_MAT_CN(type), depth = CV_MAT_DEPTH(type);
-    const char* result = cn > 16 ? 0 : tab[depth*16 + cn-1];
+    const char* result = cn > 16 ? nullptr : tab[depth*16 + cn-1];
     CV_Assert(result);
     return result;
 }
@@ -7018,7 +7018,16 @@ const char* vecopTypeToStr(int type)
     return result;
 }
 
+// Deprecated due to size of buf buffer being unknowable.
 const char* convertTypeStr(int sdepth, int ddepth, int cn, char* buf)
+{
+    // Since the size of buf is not given, we assume 50 because that's what all callers use.
+    constexpr size_t buf_max = 50;
+
+    return convertTypeStr(sdepth, ddepth, cn, buf, buf_max);
+}
+
+const char* convertTypeStr(int sdepth, int ddepth, int cn, char* buf, size_t buf_size)
 {
     if( sdepth == ddepth )
         return "noconvert";
@@ -7028,12 +7037,12 @@ const char* convertTypeStr(int sdepth, int ddepth, int cn, char* buf)
         (ddepth == CV_16S && sdepth <= CV_8S) ||
         (ddepth == CV_16U && sdepth == CV_8U))
     {
-        sprintf(buf, "convert_%s", typestr);
+        snprintf(buf, buf_size, "convert_%s", typestr);
     }
     else if( sdepth >= CV_32F )
-        sprintf(buf, "convert_%s%s_rte", typestr, (ddepth < CV_32S ? "_sat" : ""));
+        snprintf(buf, buf_size, "convert_%s%s_rte", typestr, (ddepth < CV_32S ? "_sat" : ""));
     else
-        sprintf(buf, "convert_%s_sat", typestr);
+        snprintf(buf, buf_size, "convert_%s_sat", typestr);
 
     return buf;
 }

modules/core/src/opencl/reduce2.cl

@@ -85,6 +85,9 @@
 #elif defined OCL_CV_REDUCE_MIN
 #define INIT_VALUE MAX_VAL
 #define PROCESS_ELEM(acc, value) acc = min(value, acc)
+#elif defined OCL_CV_REDUCE_SUM2
+#define INIT_VALUE 0
+#define PROCESS_ELEM(acc, value) acc += value*value
 #else
 #error "No operation is specified"
 #endif

modules/core/src/persistence.cpp

@@ -161,14 +161,21 @@ static int symbolToType(char c)
     return static_cast<int>(pos - symbols);
 }
 
-char* encodeFormat(int elem_type, char* dt)
+char* encodeFormat(int elem_type, char* dt, size_t dt_len)
 {
     int cn = (elem_type == CV_SEQ_ELTYPE_PTR/*CV_USRTYPE1*/) ? 1 : CV_MAT_CN(elem_type);
     char symbol = (elem_type == CV_SEQ_ELTYPE_PTR/*CV_USRTYPE1*/) ? 'r' : typeSymbol(CV_MAT_DEPTH(elem_type));
-    sprintf(dt, "%d%c", cn, symbol);
+    snprintf(dt, dt_len, "%d%c", cn, symbol);
     return dt + (cn == 1 ? 1 : 0);
 }
 
+// Deprecated due to size of dt buffer being unknowable.
+char* encodeFormat(int elem_type, char* dt)
+{
+    constexpr size_t max = 20+1+1; // UINT64_MAX + one char + nul termination.
+    return encodeFormat(elem_type, dt, max);
+}
+
 int decodeFormat( const char* dt, int* fmt_pairs, int max_len )
 {
     int fmt_pair_count = 0;

modules/core/src/persistence.hpp

@@ -91,7 +91,8 @@ char* doubleToString( char* buf, size_t bufSize, double value, bool explicitZero
 
 int calcStructSize( const char* dt, int initial_size );
 int calcElemSize( const char* dt, int initial_size );
-char* encodeFormat( int elem_type, char* dt );
+CV_DEPRECATED char* encodeFormat( int elem_type, char* dt );
+char* encodeFormat( int elem_type, char* dt, size_t dt_len );
 int decodeFormat( const char* dt, int* fmt_pairs, int max_len );
 int decodeSimpleFormat( const char* dt );
 }

modules/core/src/persistence_types.cpp

@@ -10,14 +10,14 @@ namespace cv
 
 void write( FileStorage& fs, const String& name, const Mat& m )
 {
-    char dt[16];
+    char dt[22];
 
     if( m.dims <= 2 )
     {
         fs.startWriteStruct(name, FileNode::MAP, String("opencv-matrix"));
         fs << "rows" << m.rows;
         fs << "cols" << m.cols;
-        fs << "dt" << fs::encodeFormat( m.type(), dt );
+        fs << "dt" << fs::encodeFormat( m.type(), dt, sizeof(dt) );
         fs << "data" << "[:";
         for( int i = 0; i < m.rows; i++ )
             fs.writeRaw(dt, m.ptr(i), m.cols*m.elemSize());
@@ -30,7 +30,7 @@ void write( FileStorage& fs, const String& name, const Mat& m )
         fs << "sizes" << "[:";
         fs.writeRaw( "i", m.size.p, m.dims*sizeof(int) );
         fs << "]";
-        fs << "dt" << fs::encodeFormat( m.type(), dt );
+        fs << "dt" << fs::encodeFormat( m.type(), dt, sizeof(dt) );
         fs << "data" << "[:";
         const Mat* arrays[] = {&m, 0};
         uchar* ptrs[1] = {};
@@ -63,7 +63,7 @@ struct SparseNodeCmp
 
 void write( FileStorage& fs, const String& name, const SparseMat& m )
 {
-    char dt[16];
+    char dt[22];
 
     fs.startWriteStruct(name, FileNode::MAP, String("opencv-sparse-matrix"));
     fs << "sizes" << "[:";
@@ -71,7 +71,7 @@ void write( FileStorage& fs, const String& name, const SparseMat& m )
     if( dims > 0 )
         fs.writeRaw("i", m.hdr->size, dims*sizeof(int) );
     fs << "]";
-    fs << "dt" << fs::encodeFormat( m.type(), dt );
+    fs << "dt" << fs::encodeFormat( m.type(), dt, sizeof(dt) );
     fs << "data" << "[:";
 
     size_t i = 0, n = m.nzcount();

modules/core/src/persistence_xml.cpp

@@ -208,7 +208,7 @@ public:
                     }
                     else
                     {
-                        sprintf( data, "#x%02x", (uchar)c );
+                        snprintf( data, sizeof(buf) - (data - buf), "#x%02x", (uchar)c );
                         data += 4;
                     }
                     *data++ = ';';

modules/core/src/persistence_yml.cpp

@@ -152,7 +152,7 @@ public:
                         *data++ = 't';
                     else
                     {
-                        sprintf( data, "x%02x", c );
+                        snprintf( data, sizeof(buf) - (data - buf), "x%02x", c );
                         data += 3;
                     }
                 }

modules/core/src/precomp.hpp

@@ -108,6 +108,22 @@ extern const uchar g_Saturate8u[];
 #define CV_MIN_8U(a,b)       ((a) - CV_FAST_CAST_8U((a) - (b)))
 #define CV_MAX_8U(a,b)       ((a) + CV_FAST_CAST_8U((b) - (a)))
 
+template<typename T1, typename T2=T1, typename T3=T1> struct OpNop
+{
+    typedef T1 type1;
+    typedef T2 type2;
+    typedef T3 rtype;
+    T3 operator ()(const T1 a) const { return saturate_cast<T3>(a); }
+};
+
+template<typename T1, typename T2=T1, typename T3=T1> struct OpSqr
+{
+    typedef T1 type1;
+    typedef T2 type2;
+    typedef T3 rtype;
+    T3 operator ()(const T1 a) const { return saturate_cast<T3>(a)*saturate_cast<T3>(a); }
+};
+
 template<typename T1, typename T2=T1, typename T3=T1> struct OpAdd
 {
     typedef T1 type1;
@@ -116,6 +132,14 @@ template<typename T1, typename T2=T1, typename T3=T1> struct OpAdd
     T3 operator ()(const T1 a, const T2 b) const { return saturate_cast<T3>(a + b); }
 };
 
+template<typename T1, typename T2=T1, typename T3=T1> struct OpAddSqr
+{
+    typedef T1 type1;
+    typedef T2 type2;
+    typedef T3 rtype;
+    T3 operator ()(const T1 a, const T2 b) const { return saturate_cast<T3>(a + saturate_cast<T3>(b)*saturate_cast<T3>(b)); }
+};
+
 template<typename T1, typename T2=T1, typename T3=T1> struct OpSub
 {
     typedef T1 type1;

modules/core/src/sum.dispatch.cpp

@@ -62,13 +62,13 @@ bool ocl_sum( InputArray _src, Scalar & res, int sum_op, InputArray _mask,
     wgs2_aligned >>= 1;
 
     static const char * const opMap[3] = { "OP_SUM", "OP_SUM_ABS", "OP_SUM_SQR" };
-    char cvt[2][40];
+    char cvt[2][50];
     String opts = format("-D srcT=%s -D srcT1=%s -D dstT=%s -D dstTK=%s -D dstT1=%s -D ddepth=%d -D cn=%d"
                          " -D convertToDT=%s -D %s -D WGS=%d -D WGS2_ALIGNED=%d%s%s%s%s -D kercn=%d%s%s%s -D convertFromU=%s",
                          ocl::typeToStr(CV_MAKE_TYPE(depth, mcn)), ocl::typeToStr(depth),
                          ocl::typeToStr(dtype), ocl::typeToStr(CV_MAKE_TYPE(ddepth, mcn)),
                          ocl::typeToStr(ddepth), ddepth, cn,
-                         ocl::convertTypeStr(depth, ddepth, mcn, cvt[0]),
+                         ocl::convertTypeStr(depth, ddepth, mcn, cvt[0], sizeof(cvt[0])),
                          opMap[sum_op], (int)wgs, wgs2_aligned,
                          doubleSupport ? " -D DOUBLE_SUPPORT" : "",
                          haveMask ? " -D HAVE_MASK" : "",
@@ -76,7 +76,7 @@ bool ocl_sum( InputArray _src, Scalar & res, int sum_op, InputArray _mask,
                          haveMask && _mask.isContinuous() ? " -D HAVE_MASK_CONT" : "", kercn,
                          haveSrc2 ? " -D HAVE_SRC2" : "", calc2 ? " -D OP_CALC2" : "",
                          haveSrc2 && _src2.isContinuous() ? " -D HAVE_SRC2_CONT" : "",
-                         depth <= CV_32S && ddepth == CV_32S ? ocl::convertTypeStr(CV_8U, ddepth, convert_cn, cvt[1]) : "noconvert");
+                         depth <= CV_32S && ddepth == CV_32S ? ocl::convertTypeStr(CV_8U, ddepth, convert_cn, cvt[1], sizeof(cvt[1])) : "noconvert");
 
     ocl::Kernel k("reduce", ocl::core::reduce_oclsrc, opts);
     if (k.empty())

modules/core/src/system.cpp

@@ -42,6 +42,7 @@
 //M*/
 
 #include "precomp.hpp"
+#include <atomic>
 #include <iostream>
 #include <ostream>
 
@@ -58,18 +59,6 @@
 #include <opencv2/core/utils/fp_control_utils.hpp>
 #include <opencv2/core/utils/fp_control.private.hpp>
 
-#ifndef OPENCV_WITH_THREAD_SANITIZER
-  #if defined(__clang__) && defined(__has_feature)
-  #if __has_feature(thread_sanitizer)
-      #define OPENCV_WITH_THREAD_SANITIZER 1
-      #include <atomic>  // assume C++11
-  #endif
-  #endif
-#endif
-#ifndef OPENCV_WITH_THREAD_SANITIZER
-    #define OPENCV_WITH_THREAD_SANITIZER 0
-#endif
-
 namespace cv {
 
 static void _initSystem()
@@ -1487,11 +1476,7 @@ private:
 #endif
 #else // _WIN32
     pthread_key_t  tlsKey;
-#if OPENCV_WITH_THREAD_SANITIZER
     std::atomic<bool> disposed;
-#else
-    bool disposed;
-#endif
 #endif
 };
 

modules/core/src/umatrix.cpp

@@ -1259,12 +1259,12 @@ void UMat::convertTo(OutputArray _dst, int _type, double alpha, double beta) con
     {
         int wdepth = std::max(CV_32F, sdepth), rowsPerWI = 4;
 
-        char cvt[2][40];
+        char cvt[2][50];
         ocl::Kernel k("convertTo", ocl::core::convert_oclsrc,
                       format("-D srcT=%s -D WT=%s -D dstT=%s -D convertToWT=%s -D convertToDT=%s%s%s",
                              ocl::typeToStr(sdepth), ocl::typeToStr(wdepth), ocl::typeToStr(ddepth),
-                             ocl::convertTypeStr(sdepth, wdepth, 1, cvt[0]),
-                             ocl::convertTypeStr(wdepth, ddepth, 1, cvt[1]),
+                             ocl::convertTypeStr(sdepth, wdepth, 1, cvt[0], sizeof(cvt[0])),
+                             ocl::convertTypeStr(wdepth, ddepth, 1, cvt[1], sizeof(cvt[1])),
                              doubleSupport ? " -D DOUBLE_SUPPORT" : "", noScale ? " -D NO_SCALE" : ""));
         if (!k.empty())
         {

modules/core/test/ocl/test_arithm.cpp

@@ -1873,6 +1873,22 @@ OCL_TEST_P(ReduceAvg, Mat)
     }
 }
 
+typedef Reduce ReduceSum2;
+
+OCL_TEST_P(ReduceSum2, Mat)
+{
+    for (int j = 0; j < test_loop_times; j++)
+    {
+        generateTestData();
+
+        OCL_OFF(cv::reduce(src_roi, dst_roi, dim, REDUCE_SUM2, dtype));
+        OCL_ON(cv::reduce(usrc_roi, udst_roi, dim, REDUCE_SUM2, dtype));
+
+        double eps = ddepth <= CV_32S ? 1 : 6e-6;
+        OCL_EXPECT_MATS_NEAR(dst, eps);
+    }
+}
+
 //////////////////////////////////////// Instantiation /////////////////////////////////////////
 
 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Lut, Combine(::testing::Values(CV_8U, CV_8S), OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool(), Bool()));

modules/core/test/test_intrin_utils.hpp

@@ -166,7 +166,7 @@ template <typename R> struct Data
     {
         *this = r;
     }
-    operator R ()
+    operator R () const
     {
         return initializer<VTraits<R>::max_nlanes>().init(*this);
     }
@@ -1736,11 +1736,39 @@ template<typename R> struct TheTest
     }
 #endif
 
-#if CV_SIMD_64F
+    void do_check_cmp64(const Data<R>& dataA, const Data<R>& dataB)
+    {
+        R a = dataA;
+        R b = dataB;
+
+#if CV_SIMD_SCALABLE
+        Data<R> dataEQ = v_eq(a, b);
+        Data<R> dataNE = v_ne(a, b);
+#else
+        Data<R> dataEQ = (a == b);
+        Data<R> dataNE = (a != b);
+#endif
+
+        for (int i = 0; i < VTraits<R>::vlanes(); ++i)
+        {
+            SCOPED_TRACE(cv::format("i=%d", i));
+            if (cvtest::debugLevel > 0) cout << "i=" << i << " ( " << dataA[i] << " vs " << dataB[i] << " ): eq=" << dataEQ[i] << " ne=" << dataNE[i] << endl;
+            EXPECT_NE((LaneType)dataEQ[i], (LaneType)dataNE[i]);
+            if (dataA[i] == dataB[i])
+                EXPECT_EQ((LaneType)-1, (LaneType)dataEQ[i]);
+            else
+                EXPECT_EQ((LaneType)0, (LaneType)dataEQ[i]);
+            if (dataA[i] != dataB[i])
+                EXPECT_EQ((LaneType)-1, (LaneType)dataNE[i]);
+            else
+                EXPECT_EQ((LaneType)0, (LaneType)dataNE[i]);
+        }
+    }
+
     TheTest & test_cmp64()
     {
-        Data<R> dataA, dataB;
-        R a = dataA, b = dataB;
+        Data<R> dataA;
+        Data<R> dataB;
 
         for (int i = 0; i < VTraits<R>::vlanes(); ++i)
         {
@@ -1748,37 +1776,25 @@ template<typename R> struct TheTest
         }
         dataA[0]++;
 
-        a = dataA, b = dataB;
+        do_check_cmp64(dataA, dataB);
+        do_check_cmp64(dataB, dataA);
 
-        Data<R> resC = (a == b);
-        Data<R> resD = (a != b);
+        dataA[0] = dataB[0];
+        dataA[1] += (((LaneType)1) << 32);
+        do_check_cmp64(dataA, dataB);
+        do_check_cmp64(dataB, dataA);
 
-        for (int i = 0; i < VTraits<R>::vlanes(); ++i)
-        {
-            SCOPED_TRACE(cv::format("i=%d", i));
-            EXPECT_EQ(dataA[i] == dataB[i], resC[i] != 0);
-            EXPECT_EQ(dataA[i] != dataB[i], resD[i] != 0);
-        }
+        dataA[0] = (LaneType)-1;
+        dataB[0] = (LaneType)-1;
+        dataA[1] = (LaneType)-1;
+        dataB[1] = (LaneType)2;
 
-        for (int i = 0; i < VTraits<R>::vlanes(); ++i)
-        {
-            dataA[i] = dataB[i] = (LaneType)-1;
-        }
+        do_check_cmp64(dataA, dataB);
+        do_check_cmp64(dataB, dataA);
 
-        a = dataA, b = dataB;
-
-        resC = (a == b);
-        resD = (a != b);
-
-        for (int i = 0; i < VTraits<R>::vlanes(); ++i)
-        {
-            SCOPED_TRACE(cv::format("i=%d", i));
-            EXPECT_EQ(dataA[i] == dataB[i], resC[i] != 0);
-            EXPECT_EQ(dataA[i] != dataB[i], resD[i] != 0);
-        }
         return *this;
     }
-#endif
+
 };
 
 #define DUMP_ENTRY(type) printf("SIMD%d: %s\n", 8*VTraits<v_uint8>::vlanes(), CV__TRACE_FUNCTION);
@@ -2023,9 +2039,8 @@ void test_hal_intrin_uint64()
     TheTest<v_uint64>()
         .test_loadstore()
         .test_addsub()
-#if CV_SIMD_64F
         .test_cmp64()
-#endif
+        //.test_cmp() - not declared as supported
         .test_shift<1>().test_shift<8>()
         .test_logic()
         .test_reverse()
@@ -2043,9 +2058,8 @@ void test_hal_intrin_int64()
     TheTest<v_int64>()
         .test_loadstore()
         .test_addsub()
-#if CV_SIMD_64F
         .test_cmp64()
-#endif
+        //.test_cmp() - not declared as supported
         .test_shift<1>().test_shift<8>()
         .test_logic()
         .test_reverse()
@@ -2128,7 +2142,8 @@ void test_hal_intrin_float64()
         .test_rotate<2>().test_rotate<3>()
 #endif
         ;
-
+#else
+    std::cout << "SKIP: CV_SIMD_64F is not available" << std::endl;
 #endif
 }
 

modules/core/test/test_mat.cpp

@@ -26,7 +26,7 @@ protected:
 };
 
 template<class Type>
-void testReduce( const Mat& src, Mat& sum, Mat& avg, Mat& max, Mat& min, int dim )
+void testReduce( const Mat& src, Mat& sum, Mat& avg, Mat& max, Mat& min, Mat& sum2, int dim )
 {
     CV_Assert( src.channels() == 1 );
     if( dim == 0 ) // row
@@ -34,21 +34,25 @@ void testReduce( const Mat& src, Mat& sum, Mat& avg, Mat& max, Mat& min, int dim
         sum.create( 1, src.cols, CV_64FC1 );
         max.create( 1, src.cols, CV_64FC1 );
         min.create( 1, src.cols, CV_64FC1 );
+        sum2.create( 1, src.cols, CV_64FC1 );
     }
     else
     {
         sum.create( src.rows, 1, CV_64FC1 );
         max.create( src.rows, 1, CV_64FC1 );
         min.create( src.rows, 1, CV_64FC1 );
+        sum2.create( src.rows, 1, CV_64FC1 );
     }
     sum.setTo(Scalar(0));
     max.setTo(Scalar(-DBL_MAX));
     min.setTo(Scalar(DBL_MAX));
+    sum2.setTo(Scalar(0));
 
     const Mat_<Type>& src_ = src;
     Mat_<double>& sum_ = (Mat_<double>&)sum;
     Mat_<double>& min_ = (Mat_<double>&)min;
     Mat_<double>& max_ = (Mat_<double>&)max;
+    Mat_<double>& sum2_ = (Mat_<double>&)sum2;
 
     if( dim == 0 )
     {
@@ -59,6 +63,7 @@ void testReduce( const Mat& src, Mat& sum, Mat& avg, Mat& max, Mat& min, int dim
                 sum_(0, ci) += src_(ri, ci);
                 max_(0, ci) = std::max( max_(0, ci), (double)src_(ri, ci) );
                 min_(0, ci) = std::min( min_(0, ci), (double)src_(ri, ci) );
+                sum2_(0, ci) += ((double)src_(ri, ci))*((double)src_(ri, ci));
             }
         }
     }
@@ -71,6 +76,7 @@ void testReduce( const Mat& src, Mat& sum, Mat& avg, Mat& max, Mat& min, int dim
                 sum_(ri, 0) += src_(ri, ci);
                 max_(ri, 0) = std::max( max_(ri, 0), (double)src_(ri, ci) );
                 min_(ri, 0) = std::min( min_(ri, 0), (double)src_(ri, ci) );
+                sum2_(ri, 0) += ((double)src_(ri, ci))*((double)src_(ri, ci));
             }
         }
     }
@@ -93,7 +99,7 @@ int Core_ReduceTest::checkOp( const Mat& src, int dstType, int opType, const Mat
 {
     int srcType = src.type();
     bool support = false;
-    if( opType == REDUCE_SUM || opType == REDUCE_AVG )
+    if( opType == REDUCE_SUM || opType == REDUCE_AVG || opType == REDUCE_SUM2 )
     {
         if( srcType == CV_8U && (dstType == CV_32S || dstType == CV_32F || dstType == CV_64F) )
             support = true;
@@ -128,7 +134,7 @@ int Core_ReduceTest::checkOp( const Mat& src, int dstType, int opType, const Mat
         return cvtest::TS::OK;
 
     double eps = 0.0;
-    if ( opType == REDUCE_SUM || opType == REDUCE_AVG )
+    if ( opType == REDUCE_SUM || opType == REDUCE_AVG || opType == REDUCE_SUM2 )
     {
         if ( dstType == CV_32F )
             eps = 1.e-5;
@@ -152,10 +158,13 @@ int Core_ReduceTest::checkOp( const Mat& src, int dstType, int opType, const Mat
     if( check )
     {
         char msg[100];
-        const char* opTypeStr = opType == REDUCE_SUM ? "REDUCE_SUM" :
-        opType == REDUCE_AVG ? "REDUCE_AVG" :
-        opType == REDUCE_MAX ? "REDUCE_MAX" :
-        opType == REDUCE_MIN ? "REDUCE_MIN" : "unknown operation type";
+        const char* opTypeStr =
+          opType == REDUCE_SUM ? "REDUCE_SUM" :
+          opType == REDUCE_AVG ? "REDUCE_AVG" :
+          opType == REDUCE_MAX ? "REDUCE_MAX" :
+          opType == REDUCE_MIN ? "REDUCE_MIN" :
+          opType == REDUCE_SUM2 ? "REDUCE_SUM2" :
+          "unknown operation type";
         string srcTypeStr, dstTypeStr;
         getMatTypeStr( src.type(), srcTypeStr );
         getMatTypeStr( dstType, dstTypeStr );
@@ -172,25 +181,25 @@ int Core_ReduceTest::checkOp( const Mat& src, int dstType, int opType, const Mat
 int Core_ReduceTest::checkCase( int srcType, int dstType, int dim, Size sz )
 {
     int code = cvtest::TS::OK, tempCode;
-    Mat src, sum, avg, max, min;
+    Mat src, sum, avg, max, min, sum2;
 
     src.create( sz, srcType );
     randu( src, Scalar(0), Scalar(100) );
 
     if( srcType == CV_8UC1 )
-        testReduce<uchar>( src, sum, avg, max, min, dim );
+        testReduce<uchar>( src, sum, avg, max, min, sum2, dim );
     else if( srcType == CV_8SC1 )
-        testReduce<char>( src, sum, avg, max, min, dim );
+        testReduce<char>( src, sum, avg, max, min, sum2, dim );
     else if( srcType == CV_16UC1 )
-        testReduce<unsigned short int>( src, sum, avg, max, min, dim );
+        testReduce<unsigned short int>( src, sum, avg, max, min, sum2, dim );
     else if( srcType == CV_16SC1 )
-        testReduce<short int>( src, sum, avg, max, min, dim );
+        testReduce<short int>( src, sum, avg, max, min, sum2, dim );
     else if( srcType == CV_32SC1 )
-        testReduce<int>( src, sum, avg, max, min, dim );
+        testReduce<int>( src, sum, avg, max, min, sum2, dim );
     else if( srcType == CV_32FC1 )
-        testReduce<float>( src, sum, avg, max, min, dim );
+        testReduce<float>( src, sum, avg, max, min, sum2, dim );
     else if( srcType == CV_64FC1 )
-        testReduce<double>( src, sum, avg, max, min, dim );
+        testReduce<double>( src, sum, avg, max, min, sum2, dim );
     else
         CV_Assert( 0 );
 
@@ -210,6 +219,10 @@ int Core_ReduceTest::checkCase( int srcType, int dstType, int dim, Size sz )
     tempCode = checkOp( src, dstType, REDUCE_MIN, min, dim );
     code = tempCode != cvtest::TS::OK ? tempCode : code;
 
+    // 5. sum2
+    tempCode = checkOp( src, dstType, REDUCE_SUM2, sum2, dim );
+    code = tempCode != cvtest::TS::OK ? tempCode : code;
+
     return code;
 }
 
@@ -497,7 +510,7 @@ static string idx2string(const int* idx, int dims)
     char* ptr = buf;
     for( int k = 0; k < dims; k++ )
     {
-        sprintf(ptr, "%4d ", idx[k]);
+        snprintf(ptr, sizeof(buf) - (ptr - buf), "%4d ", idx[k]);
         ptr += strlen(ptr);
     }
     ptr[-1] = '\0';
@@ -1563,6 +1576,7 @@ TEST(Reduce, regression_should_fail_bug_4594)
     EXPECT_THROW(cv::reduce(src, dst, 0, REDUCE_MAX, CV_32S), cv::Exception);
     EXPECT_NO_THROW(cv::reduce(src, dst, 0, REDUCE_SUM, CV_32S));
     EXPECT_NO_THROW(cv::reduce(src, dst, 0, REDUCE_AVG, CV_32S));
+    EXPECT_NO_THROW(cv::reduce(src, dst, 0, REDUCE_SUM2, CV_32S));
 }
 
 TEST(Mat, push_back_vector)

modules/core/test/test_math.cpp

@@ -3023,7 +3023,7 @@ TEST(CovariationMatrixVectorOfMatWithMean, accuracy)
     cv::randu(src,cv::Scalar(-128), cv::Scalar(128));
     cv::Mat goldMean;
 
-    cv::reduce(src,goldMean,0 ,REDUCE_AVG, CV_32F);
+    cv::reduce(src, goldMean, 0, REDUCE_AVG, CV_32F);
 
     cv::calcCovarMatrix(src,gold,goldMean,singleMatFlags,CV_32F);
 

modules/dnn/CMakeLists.txt

@@ -2,14 +2,13 @@ if(WINRT)
   ocv_module_disable(dnn)
 endif()
 
-if(NOT HAVE_PROTOBUF)
-  ocv_module_disable(opencv_dnn)
-endif()
-
 set(the_description "Deep neural network module. It allows to load models from different frameworks and to make forward pass")
 
 ocv_add_dispatched_file_force_all("layers/layers_common" AVX AVX2 AVX512_SKX RVV LASX)
 ocv_add_dispatched_file_force_all("int8layers/layers_common" AVX2 AVX512_SKX LASX)
+ocv_add_dispatched_file_force_all("layers/cpu_kernels/conv_block" AVX AVX2)
+ocv_add_dispatched_file_force_all("layers/cpu_kernels/conv_depthwise" AVX AVX2 RVV LASX)
+ocv_add_dispatched_file_force_all("layers/cpu_kernels/conv_winograd_f63" AVX AVX2)
 
 ocv_add_module(dnn opencv_core opencv_imgproc WRAP python java objc js)
 
@@ -101,8 +100,6 @@ if(NOT BUILD_PROTOBUF)
   ocv_target_compile_definitions(${the_module} PRIVATE "OPENCV_DNN_EXTERNAL_PROTOBUF=1")
 endif()
 
-ocv_target_compile_definitions(${the_module} PRIVATE "HAVE_PROTOBUF=1")
-
 #suppress warnings in autogenerated caffe.pb.* files
 ocv_warnings_disable(CMAKE_CXX_FLAGS
     /wd4125 /wd4267 /wd4127 /wd4244 /wd4512 /wd4702
@@ -117,14 +114,33 @@ ocv_warnings_disable(CMAKE_CXX_FLAGS
 set(include_dirs "")
 set(libs "")
 
-if(PROTOBUF_UPDATE_FILES)
-  file(GLOB proto_files "${CMAKE_CURRENT_LIST_DIR}/src/tensorflow/*.proto" "${CMAKE_CURRENT_LIST_DIR}/src/caffe/opencv-caffe.proto" "${CMAKE_CURRENT_LIST_DIR}/src/onnx/opencv-onnx.proto")
-  set(PROTOBUF_GENERATE_CPP_APPEND_PATH ON) # required for tensorflow
-  protobuf_generate_cpp(fw_srcs fw_hdrs ${proto_files})
-else()
-  file(GLOB fw_srcs "${CMAKE_CURRENT_LIST_DIR}/misc/tensorflow/*.cc" "${CMAKE_CURRENT_LIST_DIR}/misc/caffe/opencv-caffe.pb.cc" "${CMAKE_CURRENT_LIST_DIR}/misc/onnx/opencv-onnx.pb.cc")
-  file(GLOB fw_hdrs "${CMAKE_CURRENT_LIST_DIR}/misc/tensorflow/*.h" "${CMAKE_CURRENT_LIST_DIR}/misc/caffe/opencv-caffe.pb.h" "${CMAKE_CURRENT_LIST_DIR}/misc/onnx/opencv-onnx.pb.h")
-  set(fw_inc "${CMAKE_CURRENT_LIST_DIR}/misc/caffe" "${CMAKE_CURRENT_LIST_DIR}/misc/tensorflow" "${CMAKE_CURRENT_LIST_DIR}/misc/onnx")
+if(HAVE_PROTOBUF)
+  ocv_target_compile_definitions(${the_module} PRIVATE "HAVE_PROTOBUF=1")
+
+  if(PROTOBUF_UPDATE_FILES)
+    file(GLOB proto_files "${CMAKE_CURRENT_LIST_DIR}/src/tensorflow/*.proto" "${CMAKE_CURRENT_LIST_DIR}/src/caffe/opencv-caffe.proto" "${CMAKE_CURRENT_LIST_DIR}/src/onnx/opencv-onnx.proto")
+    set(PROTOBUF_GENERATE_CPP_APPEND_PATH ON) # required for tensorflow
+    protobuf_generate_cpp(fw_srcs fw_hdrs ${proto_files})
+  else()
+    file(GLOB fw_srcs "${CMAKE_CURRENT_LIST_DIR}/misc/tensorflow/*.cc" "${CMAKE_CURRENT_LIST_DIR}/misc/caffe/opencv-caffe.pb.cc" "${CMAKE_CURRENT_LIST_DIR}/misc/onnx/opencv-onnx.pb.cc")
+    file(GLOB fw_hdrs "${CMAKE_CURRENT_LIST_DIR}/misc/tensorflow/*.h" "${CMAKE_CURRENT_LIST_DIR}/misc/caffe/opencv-caffe.pb.h" "${CMAKE_CURRENT_LIST_DIR}/misc/onnx/opencv-onnx.pb.h")
+    set(fw_inc "${CMAKE_CURRENT_LIST_DIR}/misc/caffe" "${CMAKE_CURRENT_LIST_DIR}/misc/tensorflow" "${CMAKE_CURRENT_LIST_DIR}/misc/onnx")
+  endif()
+endif()
+
+ocv_option(OPENCV_DNN_TFLITE "Build with TFLite support" (TARGET ocv.3rdparty.flatbuffers))
+if(TARGET ocv.3rdparty.flatbuffers AND OPENCV_DNN_TFLITE)
+  if(NOT HAVE_FLATBUFFERS)
+    message(FATAL_ERROR "DNN: TFLite is not supported without enabled 'flatbuffers'. Check build configuration.")
+  endif()
+  list(APPEND libs ocv.3rdparty.flatbuffers)
+  list(APPEND fw_hdrs "${CMAKE_CURRENT_LIST_DIR}/misc/tflite/schema_generated.h")
+  list(APPEND fw_inc "${CMAKE_CURRENT_LIST_DIR}/misc/tflite")
+
+  # Schema is generated by this command:
+  #add_custom_command(
+  #      OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/schema_generated.h"
+  #      COMMAND flatbuffers::flatc --cpp -o "${CMAKE_CURRENT_BINARY_DIR}" "${CMAKE_CURRENT_LIST_DIR}/src/tflite/schema.fbs")
 endif()
 
 list(APPEND include_dirs ${fw_inc})
@@ -221,6 +237,9 @@ if(TARGET ocv.3rdparty.openvino AND OPENCV_DNN_OPENVINO)
   endif()
 endif()
 
+
+ocv_install_used_external_targets(${libs} ${dnn_runtime_libs})
+
 ocv_glob_module_sources(${sources_options} SOURCES ${fw_srcs} ${webnn_srcs})
 ocv_create_module(${libs} ${dnn_runtime_libs})
 ocv_add_samples()
@@ -280,3 +299,13 @@ if(TARGET ocv.3rdparty.cann AND OPENCV_TEST_DNN_CANN)
     ocv_target_link_libraries(opencv_test_dnn ocv.3rdparty.cann)
   endif()
 endif()
+
+ocv_option(OPENCV_TEST_DNN_TFLITE "Build test with TFLite" (OPENCV_DNN_TFLITE))
+if(OPENCV_TEST_DNN_TFLITE)
+  if(TARGET opencv_test_dnn)
+    ocv_target_compile_definitions(opencv_test_dnn PRIVATE "OPENCV_TEST_DNN_TFLITE=1")
+  endif()
+  if(TARGET opencv_perf_dnn)
+    ocv_target_compile_definitions(opencv_perf_dnn PRIVATE "OPENCV_TEST_DNN_TFLITE=1")
+  endif()
+endif()

modules/dnn/include/opencv2/dnn/all_layers.hpp

@@ -258,7 +258,6 @@ CV__DNN_INLINE_NS_BEGIN
         static Ptr<BaseConvolutionLayer> create(const LayerParams& params);
         bool fusedActivation = false;
         bool fusedAdd = false;
-        bool isConv2D = false; // Should be deleted after fastconv branch support Conv1D and Conv3D.
         bool useWinograd = false; // Flag whether to use Winograd to speed up 3x3 convolution.
     };
 
@@ -346,18 +345,9 @@ CV__DNN_INLINE_NS_BEGIN
     class CV_EXPORTS ReduceLayer : public Layer
     {
     public:
-        int reduceType;
-        // reduceDims contains the dimensions that need to be reduced, targetDims is the target output dimension.
-        std::vector<size_t> reduceDims, targetDims;
         static Ptr<ReduceLayer> create(const LayerParams& params);
     };
 
-    class CV_EXPORTS ReduceLayerInt8 : public ReduceLayer
-    {
-    public:
-        static Ptr<ReduceLayerInt8> create(const LayerParams& params);
-    };
-
     class CV_EXPORTS SoftmaxLayer : public Layer
     {
     public:
@@ -374,6 +364,10 @@ CV__DNN_INLINE_NS_BEGIN
         static Ptr<SoftmaxLayerInt8> create(const LayerParams& params);
     };
 
+    /**
+     * `InnerProduct`, `MatMul` and `Gemm` operations are all implemented by Fully Connected Layer.
+     * Parameter `is_matmul` is used to distinguish `MatMul` and `Gemm` from `InnerProduct`.
+     */
     class CV_EXPORTS InnerProductLayer : public Layer
     {
     public:
@@ -802,6 +796,18 @@ CV__DNN_INLINE_NS_BEGIN
         static Ptr<SeluLayer> create(const LayerParams &params);
     };
 
+    class CV_EXPORTS GeluLayer : public ActivationLayer
+    {
+    public:
+        static Ptr<GeluLayer> create(const LayerParams &params);
+    };
+
+    class CV_EXPORTS GeluApproximationLayer : public ActivationLayer
+    {
+    public:
+        static Ptr<GeluApproximationLayer> create(const LayerParams &params);
+    };
+
     class CV_EXPORTS ThresholdedReluLayer : public ActivationLayer
     {
     public:

modules/dnn/include/opencv2/dnn/dnn.hpp

@@ -106,6 +106,22 @@ CV__DNN_INLINE_NS_BEGIN
         DNN_TARGET_CUDA_FP16,
         DNN_TARGET_HDDL,
         DNN_TARGET_NPU,
+        DNN_TARGET_CPU_FP16, // Only the ARM platform is supported. Low precision computing, accelerate model inference.
+    };
+
+    /**
+     * @brief Enum of data layout for model inference.
+     * @see Image2BlobParams
+     */
+    enum DataLayout
+    {
+        DNN_LAYOUT_UNKNOWN = 0,
+        DNN_LAYOUT_ND = 1,        //!< OpenCV data layout for 2D data.
+        DNN_LAYOUT_NCHW = 2,      //!< OpenCV data layout for 4D data.
+        DNN_LAYOUT_NCDHW = 3,      //!< OpenCV data layout for 5D data.
+        DNN_LAYOUT_NHWC = 4,      //!< Tensorflow-like data layout for 4D data.
+        DNN_LAYOUT_NDHWC = 5,      //!< Tensorflow-like data layout for 5D data.
+        DNN_LAYOUT_PLANAR = 6,     //!< Tensorflow-like data layout, it should only be used at tf or tflite model parsing.
     };
 
     CV_EXPORTS std::vector< std::pair<Backend, Target> > getAvailableBackends();
@@ -314,7 +330,7 @@ CV__DNN_INLINE_NS_BEGIN
 
         virtual Ptr<BackendNode> initNgraph(const std::vector<Ptr<BackendWrapper> > &inputs, const std::vector<Ptr<BackendNode> >& nodes);
 
-        virtual Ptr<BackendNode> initVkCom(const std::vector<Ptr<BackendWrapper> > &inputs);
+        virtual Ptr<BackendNode> initVkCom(const std::vector<Ptr<BackendWrapper> > &inputs, std::vector<Ptr<BackendWrapper> > &outputs);
 
         virtual Ptr<BackendNode> initWebnn(const std::vector<Ptr<BackendWrapper> > &inputs, const std::vector<Ptr<BackendNode> >& nodes);
 
@@ -347,11 +363,13 @@ CV__DNN_INLINE_NS_BEGIN
         /**
          * @brief Returns a CANN backend node
          *
-         * @param   inputsWrapper   layer inputs
-         * @param   index           layer id for op name
-         * @param   nodes           inputs of this node
+         * @param   inputs   input tensors of CANN operator
+         * @param   outputs  output tensors of CANN operator
+         * @param   nodes           nodes of input tensors
          */
-        virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes);
+        virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputs,
+                                          const std::vector<Ptr<BackendWrapper> > &outputs,
+                                          const std::vector<Ptr<BackendNode> >& nodes);
 
        /**
         * @brief Automatic Halide scheduling based on layer hyper-parameters.
@@ -953,6 +971,26 @@ CV__DNN_INLINE_NS_BEGIN
     CV_EXPORTS Net readNetFromTensorflow(const char *bufferModel, size_t lenModel,
                                          const char *bufferConfig = NULL, size_t lenConfig = 0);
 
+    /** @brief Reads a network model stored in <a href="https://www.tensorflow.org/lite">TFLite</a> framework's format.
+      * @param model  path to the .tflite file with binary flatbuffers description of the network architecture
+      * @returns Net object.
+      */
+    CV_EXPORTS_W Net readNetFromTFLite(const String &model);
+
+    /** @brief Reads a network model stored in <a href="https://www.tensorflow.org/lite">TFLite</a> framework's format.
+      * @param bufferModel buffer containing the content of the tflite file
+      * @returns Net object.
+      */
+    CV_EXPORTS_W Net readNetFromTFLite(const std::vector<uchar>& bufferModel);
+
+    /** @brief Reads a network model stored in <a href="https://www.tensorflow.org/lite">TFLite</a> framework's format.
+      * @details This is an overloaded member function, provided for convenience.
+      * It differs from the above function only in what argument(s) it accepts.
+      * @param bufferModel buffer containing the content of the tflite file
+      * @param lenModel length of bufferModel
+      */
+    CV_EXPORTS Net readNetFromTFLite(const char *bufferModel, size_t lenModel);
+
     /**
      *  @brief Reads a network model stored in <a href="http://torch.ch">Torch7</a> framework's format.
      *  @param model    path to the file, dumped from Torch by using torch.save() function.
@@ -1089,10 +1127,10 @@ CV__DNN_INLINE_NS_BEGIN
     /** @brief Creates 4-dimensional blob from image. Optionally resizes and crops @p image from center,
      *  subtract @p mean values, scales values by @p scalefactor, swap Blue and Red channels.
      *  @param image input image (with 1-, 3- or 4-channels).
+     *  @param scalefactor multiplier for @p images values.
      *  @param size spatial size for output image
      *  @param mean scalar with mean values which are subtracted from channels. Values are intended
      *  to be in (mean-R, mean-G, mean-B) order if @p image has BGR ordering and @p swapRB is true.
-     *  @param scalefactor multiplier for @p image values.
      *  @param swapRB flag which indicates that swap first and last channels
      *  in 3-channel image is necessary.
      *  @param crop flag which indicates whether image will be cropped after resize or not
@@ -1101,6 +1139,9 @@ CV__DNN_INLINE_NS_BEGIN
      *  dimension in @p size and another one is equal or larger. Then, crop from the center is performed.
      *  If @p crop is false, direct resize without cropping and preserving aspect ratio is performed.
      *  @returns 4-dimensional Mat with NCHW dimensions order.
+     *
+     * @note
+     * The order and usage of `scalefactor` and `mean` are (input - mean) * scalefactor.
      */
     CV_EXPORTS_W Mat blobFromImage(InputArray image, double scalefactor=1.0, const Size& size = Size(),
                                    const Scalar& mean = Scalar(), bool swapRB=false, bool crop=false,
@@ -1131,6 +1172,9 @@ CV__DNN_INLINE_NS_BEGIN
      *  dimension in @p size and another one is equal or larger. Then, crop from the center is performed.
      *  If @p crop is false, direct resize without cropping and preserving aspect ratio is performed.
      *  @returns 4-dimensional Mat with NCHW dimensions order.
+     *
+     * @note
+     * The order and usage of `scalefactor` and `mean` are (input - mean) * scalefactor.
      */
     CV_EXPORTS_W Mat blobFromImages(InputArrayOfArrays images, double scalefactor=1.0,
                                     Size size = Size(), const Scalar& mean = Scalar(), bool swapRB=false, bool crop=false,
@@ -1145,6 +1189,74 @@ CV__DNN_INLINE_NS_BEGIN
                                    const Scalar& mean = Scalar(), bool swapRB=false, bool crop=false,
                                    int ddepth=CV_32F);
 
+    /**
+     * @brief Enum of image processing mode.
+     * To facilitate the specialization pre-processing requirements of the dnn model.
+     * For example, the `letter box` often used in the Yolo series of models.
+     * @see Image2BlobParams
+     */
+    enum ImagePaddingMode
+    {
+        DNN_PMODE_NULL = 0,        // !< Default. Resize to required input size without extra processing.
+        DNN_PMODE_CROP_CENTER = 1, // !< Image will be cropped after resize.
+        DNN_PMODE_LETTERBOX = 2,   // !< Resize image to the desired size while preserving the aspect ratio of original image.
+    };
+
+    /** @brief Processing params of image to blob.
+     *
+     * It includes all possible image processing operations and corresponding parameters.
+     *
+     * @see blobFromImageWithParams
+     *
+     * @note
+     * The order and usage of `scalefactor` and `mean` are (input - mean) * scalefactor.
+     * The order and usage of `scalefactor`, `size`, `mean`, `swapRB`, and `ddepth` are consistent
+     * with the function of @ref blobFromImage.
+    */
+    struct CV_EXPORTS_W_SIMPLE Image2BlobParams
+    {
+        CV_WRAP Image2BlobParams();
+        CV_WRAP Image2BlobParams(const Scalar& scalefactor, const Size& size = Size(), const Scalar& mean = Scalar(),
+                            bool swapRB = false, int ddepth = CV_32F, DataLayout datalayout = DNN_LAYOUT_NCHW,
+                            ImagePaddingMode mode = DNN_PMODE_NULL);
+
+        CV_PROP_RW Scalar scalefactor; //!< scalefactor multiplier for input image values.
+        CV_PROP_RW Size size;    //!< Spatial size for output image.
+        CV_PROP_RW Scalar mean;  //!< Scalar with mean values which are subtracted from channels.
+        CV_PROP_RW bool swapRB;  //!< Flag which indicates that swap first and last channels
+        CV_PROP_RW int ddepth;   //!< Depth of output blob. Choose CV_32F or CV_8U.
+        CV_PROP_RW DataLayout datalayout; //!< Order of output dimensions. Choose DNN_LAYOUT_NCHW or DNN_LAYOUT_NHWC.
+        CV_PROP_RW ImagePaddingMode paddingmode;   //!< Image padding mode. @see ImagePaddingMode.
+    };
+
+    /** @brief Creates 4-dimensional blob from image with given params.
+     *
+     *  @details This function is an extension of @ref blobFromImage to meet more image preprocess needs.
+     *  Given input image and preprocessing parameters, and function outputs the blob.
+     *
+     *  @param image input image (all with 1-, 3- or 4-channels).
+     *  @param param struct of Image2BlobParams, contains all parameters needed by processing of image to blob.
+     *  @return 4-dimensional Mat.
+     */
+    CV_EXPORTS_W Mat blobFromImageWithParams(InputArray image, const Image2BlobParams& param = Image2BlobParams());
+
+    /** @overload */
+    CV_EXPORTS_W void blobFromImageWithParams(InputArray image, OutputArray blob, const Image2BlobParams& param = Image2BlobParams());
+
+    /** @brief Creates 4-dimensional blob from series of images with given params.
+     *
+     *  @details This function is an extension of @ref blobFromImages to meet more image preprocess needs.
+     *  Given input image and preprocessing parameters, and function outputs the blob.
+     *
+     *  @param images input image (all with 1-, 3- or 4-channels).
+     *  @param param struct of Image2BlobParams, contains all parameters needed by processing of image to blob.
+     *  @returns 4-dimensional Mat.
+     */
+    CV_EXPORTS_W Mat blobFromImagesWithParams(InputArrayOfArrays images, const Image2BlobParams& param = Image2BlobParams());
+
+    /** @overload */
+    CV_EXPORTS_W void blobFromImagesWithParams(InputArrayOfArrays images, OutputArray blob, const Image2BlobParams& param = Image2BlobParams());
+
     /** @brief Parse a 4D blob and output the images it contains as 2D arrays through a simpler data structure
      *  (std::vector<cv::Mat>).
      *  @param[in] blob_ 4 dimensional array (images, channels, height, width) in floating point precision (CV_32F) from
@@ -1311,7 +1423,7 @@ CV__DNN_INLINE_NS_BEGIN
          /** @brief Set scalefactor value for frame.
           *  @param[in] scale Multiplier for frame values.
          */
-         CV_WRAP Model& setInputScale(double scale);
+         CV_WRAP Model& setInputScale(const Scalar& scale);
 
          /** @brief Set flag crop for frame.
           *  @param[in] crop Flag which indicates whether image will be cropped after resize or not.

modules/dnn/misc/objc/gen_dict.json

@@ -8,7 +8,9 @@
             "(Net*)readNetFromONNX:(NSString*)onnxFile" : { "readNetFromONNX" : {"name" : "readNetFromONNXFile"} },
             "(Net*)readNetFromONNX:(ByteVector*)buffer" : { "readNetFromONNX" : {"name" : "readNetFromONNXBuffer"} },
             "(Net*)readNetFromTensorflow:(NSString*)model config:(NSString*)config" : { "readNetFromTensorflow" : {"name" : "readNetFromTensorflowFile"} },
-            "(Net*)readNetFromTensorflow:(ByteVector*)bufferModel bufferConfig:(ByteVector*)bufferConfig" : { "readNetFromTensorflow" : {"name" : "readNetFromTensorflowBuffer"} }
+            "(Net*)readNetFromTensorflow:(ByteVector*)bufferModel bufferConfig:(ByteVector*)bufferConfig" : { "readNetFromTensorflow" : {"name" : "readNetFromTensorflowBuffer"} },
+            "(Net*)readNetFromTFLite:(NSString*)model" : { "readNetFromTFLite" : {"name" : "readNetFromTFLiteFile"} },
+            "(Net*)readNetFromTFLite:(ByteVector*)buffer" : { "readNetFromTFLite" : {"name" : "readNetFromTFLiteBuffer"} }
         },
         "Net": {
             "(void)forward:(NSMutableArray<Mat*>*)outputBlobs outputName:(NSString*)outputName" : { "forward" : {"name" : "forwardOutputBlobs"} },

modules/dnn/misc/python/test/test_dnn.py

@@ -119,7 +119,7 @@ class dnn_test(NewOpenCVTests):
             inp = np.random.standard_normal([1, 2, 10, 11]).astype(np.float32)
             net.setInput(inp)
             net.forward()
-        except BaseException as e:
+        except BaseException:
             return False
         return True
 
@@ -153,6 +153,41 @@ class dnn_test(NewOpenCVTests):
         target = target.transpose(2, 0, 1).reshape(1, 3, height, width)  # to NCHW
         normAssert(self, blob, target)
 
+    def test_blobFromImageWithParams(self):
+        np.random.seed(324)
+
+        width = 6
+        height = 7
+        stddev = np.array([0.2, 0.3, 0.4])
+        scalefactor = 1.0/127.5 * stddev
+        mean = (10, 20, 30)
+
+        # Test arguments names.
+        img = np.random.randint(0, 255, [4, 5, 3]).astype(np.uint8)
+
+        param = cv.dnn.Image2BlobParams()
+        param.scalefactor = scalefactor
+        param.size = (6, 7)
+        param.mean = mean
+        param.swapRB=True
+        param.datalayout = cv.dnn.DNN_LAYOUT_NHWC
+
+        blob = cv.dnn.blobFromImageWithParams(img, param)
+        blob_args = cv.dnn.blobFromImageWithParams(img, cv.dnn.Image2BlobParams(scalefactor=scalefactor, size=(6, 7), mean=mean,
+                                                                      swapRB=True, datalayout=cv.dnn.DNN_LAYOUT_NHWC))
+        normAssert(self, blob, blob_args)
+
+        target2 = cv.resize(img, (width, height), interpolation=cv.INTER_LINEAR).astype(np.float32)
+        target2 = target2[:,:,[2, 1, 0]]  # BGR2RGB
+        target2[:,:,0] -= mean[0]
+        target2[:,:,1] -= mean[1]
+        target2[:,:,2] -= mean[2]
+
+        target2[:,:,0] *= scalefactor[0]
+        target2[:,:,1] *= scalefactor[1]
+        target2[:,:,2] *= scalefactor[2]
+        target2 = target2.reshape(1, height, width, 3)  # to NHWC
+        normAssert(self, blob, target2)
 
     def test_model(self):
         img_path = self.find_dnn_file("dnn/street.png")

modules/dnn/perf/perf_layer.cpp

@@ -55,7 +55,7 @@ struct Layer_Slice : public TestBaseWithParam<tuple<Backend, Target> >
     }
 };
 
-static std::set<std::string> nary_eltwise_cuda_deny_ops = {"add", "equal", "greater", "less", "mean", "mul", "pow", "sub"};
+static std::set<std::string> nary_eltwise_cuda_deny_ops = {"equal", "greater", "less", "mean", "pow", "sub"};
 
 struct Layer_NaryEltwise : public TestBaseWithParam<tuple<Backend, Target> >
 {
@@ -66,8 +66,13 @@ struct Layer_NaryEltwise : public TestBaseWithParam<tuple<Backend, Target> >
 
         if (!isRef && backendId == DNN_BACKEND_CUDA)
         {
-            if (a_shape != b_shape)
-                throw SkipTestException("The test is skipped because inputs with different shapes are not supported.");
+            if (a_shape.size() != b_shape.size())
+                throw SkipTestException("The test is skipped because inputs with different shape size are not supported.");
+
+            for(int i = 0; i < a_shape.size(); i++)
+                if (a_shape[i] != b_shape[i] && a_shape[i] != 1 && b_shape[i] != 1)
+                    throw SkipTestException("The test is skipped because inputs are not supported.");
+
             if (nary_eltwise_cuda_deny_ops.find(op) != nary_eltwise_cuda_deny_ops.end())
                 throw SkipTestException("The operator '" + op + "' is skipped because is not support with cuda currently.");
         }
@@ -215,6 +220,11 @@ PERF_TEST_P_(Layer_NaryEltwise, NHWC_C)
     test_layer({N, H, W, C}, {1, C}, "sum");
 }
 
+PERF_TEST_P_(Layer_NaryEltwise, NHWC_H)
+{
+    test_layer({N, H, W, C}, {1, H, 1, 1}, "sum");
+}
+
 PERF_TEST_P_(Layer_Slice, YOLOv4_tiny_1)
 {
     const int inputShape[4] = {1, 64, 104, 104};

modules/dnn/src/caffe/caffe_importer.cpp

@@ -591,7 +591,23 @@ Net readNetFromCaffe(const std::vector<uchar>& bufferProto, const std::vector<uc
                             bufferModelPtr, bufferModel.size());
 }
 
-#endif //HAVE_PROTOBUF
+#else  // HAVE_PROTOBUF
+
+#define DNN_PROTOBUF_UNSUPPORTED() CV_Error(Error::StsError, "DNN/Caffe: Build OpenCV with Protobuf to import Caffe models")
+
+Net readNetFromCaffe(const String &, const String &) {
+    DNN_PROTOBUF_UNSUPPORTED();
+}
+
+Net readNetFromCaffe(const char *, size_t, const char *, size_t) {
+    DNN_PROTOBUF_UNSUPPORTED();
+}
+
+Net readNetFromCaffe(const std::vector<uchar>&, const std::vector<uchar>&) {
+    DNN_PROTOBUF_UNSUPPORTED();
+}
+
+#endif  // HAVE_PROTOBUF
 
 CV__DNN_INLINE_NS_END
 }} // namespace

modules/dnn/src/cuda/eltwise_ops.cu

@@ -150,7 +150,7 @@ void eltwise_op(const Stream& stream, TensorSpan<T> output, TensorView<T> x, Ten
          */
         for (int r = 0; r < output.rank(); r++)
         {
-            while (x.get_axis_size(r) == 1 && y.get_axis_size(r) == 1) {
+            while (x.rank() > r && y.rank() > r && x.get_axis_size(r) == 1 && y.get_axis_size(r) == 1) {
                 CV_Assert(output.get_axis_size(r) == 1);
 
                 x.squeeze(r);
@@ -183,6 +183,9 @@ void eltwise_op(const Stream& stream, TensorSpan<T> output, TensorView<T> x, Ten
                     auto new_size = inShape1[i] * inShape1[j];
                     inShape1[i] = new_size;
                     inShape2[i] = new_size;
+                    // outShape should be changed after merged
+                    auto output_new_size = outShape[i] * outShape[j];
+                    outShape[i] = output_new_size;
 
                     /* delete axis `j` */
                     inShape1.erase(std::begin(inShape1) + j);

modules/dnn/src/cuda4dnn/primitives/matmul.hpp

@@ -12,6 +12,8 @@
 #include "../csl/tensor.hpp"
 #include "../csl/tensor_ops.hpp"
 
+#include "../kernels/scale_shift.hpp"
+
 #include <opencv2/core.hpp>
 
 #include <utility>
@@ -23,7 +25,7 @@ namespace cv { namespace dnn { namespace cuda4dnn {
     public:
         using wrapper_type = GetCUDABackendWrapperType<T>;
 
-        MatMulOp(csl::Stream stream_, csl::cublas::Handle handle, const Mat& constInp)
+        MatMulOp(csl::Stream stream_, csl::cublas::Handle handle, const Mat& constInp, const Mat& bias, bool _transA, bool _transB)
             : stream(std::move(stream_)), cublasHandle(std::move(handle))
         {
             if (!constInp.empty())
@@ -31,6 +33,15 @@ namespace cv { namespace dnn { namespace cuda4dnn {
                 constTensor = csl::makeTensorHeader<T>(constInp);
                 csl::copyMatToTensor<T>(constInp, constTensor, stream);
             }
+
+            if (!bias.empty())
+            {
+                biasTensor = csl::makeTensorHeader<T>(bias);
+                csl::copyMatToTensor<T>(bias, biasTensor, stream);
+            }
+
+            transA = _transA;
+            transB = _transB;
         }
 
         void forward(
@@ -69,50 +80,72 @@ namespace cv { namespace dnn { namespace cuda4dnn {
                 CV_Assert(input2.get_axis_size(i) == size);
             }
 
-            auto m = input1.get_axis_size(-2);
-            auto n = input1.get_axis_size(-1);
-            auto b = input1.size() / m / n;
-            int k;
-            if (constTensor.empty())
+            int m1, n1, b1, m2, n2, b2;
+            if (transA)
             {
-                k = input2.get_axis_size(-1);
-                CV_Assert(input2.get_axis_size(-2) == n);
+                m1 = input1.get_axis_size(-1);
+                n1 = input1.get_axis_size(-2);
             }
             else
             {
-                k = input2.get_axis_size(-2);
-                CV_Assert(input2.get_axis_size(-1) == n);
+                m1 = input1.get_axis_size(-2);
+                n1 = input1.get_axis_size(-1);
             }
-            CV_Assert(output.get_axis_size(-2) == m);
-            CV_Assert(output.get_axis_size(-1) == k);
+
+            if (transB)
+            {
+                m2 = input2.get_axis_size(-1);
+                n2 = input2.get_axis_size(-2);
+            }
+            else
+            {
+                m2 = input2.get_axis_size(-2);
+                n2 = input2.get_axis_size(-1);
+            }
+
+            b1 = input1.size() / m1 / n1;
+            b2 = input2.size() / m2 / n2;
+            CV_Assert(b1 == b2);
+            CV_Assert(n1 == m2);
+            CV_Assert(output.get_axis_size(-2) == m1);
+            CV_Assert(output.get_axis_size(-1) == n2);
 
             if (get_effective_rank(output) <= 2)
             {
-                CV_Assert(b == 1);
+                CV_Assert(b2 == 1);
                 CV_Assert(get_effective_rank(input1) <= 2);
                 CV_Assert(get_effective_rank(input2) <= 2);
-                csl::tensor_ops::gemm<T>(cublasHandle, 0.0, output, 1.0, false, input1, !constTensor.empty(), input2);
+                csl::tensor_ops::gemm<T>(cublasHandle, 0.0, output, 1.0, transA, input1, transB, input2);
+                // used for GEMM
+                if (!biasTensor.empty())
+                    kernels::biasN<T>(stream, output, output, 1, biasTensor);
             }
             else
             {
                 CV_Assert(rank >= 3);
-                input1.reshape(b, m, n);
-                if (constTensor.empty())
-                    input2.reshape(b, n, k);
+                if (transA)
+                    input1.reshape(b1, n1, m1);
                 else
-                    input2.reshape(b, k, n);
-                output.reshape(b, m, k);
+                    input1.reshape(b1, m1, n1);
+
+                if (transB)
+                    input2.reshape(b2, n2, m2);
+                else
+                    input2.reshape(b2, m2, n2);
+
+                output.reshape(b1, m1, n2);
                 input1.squeeze_to(3);
                 input2.squeeze_to(3);
                 output.squeeze_to(3);
-                csl::tensor_ops::gemmStridedBatched<T>(cublasHandle, 0.0, output, 1.0, false, input1, !constTensor.empty(), input2);
+                csl::tensor_ops::gemmStridedBatched<T>(cublasHandle, 0.0, output, 1.0, transA, input1, transB, input2);
             }
         }
 
     private:
         csl::Stream stream;
         csl::cublas::Handle cublasHandle;
-        csl::Tensor<T> constTensor;
+        csl::Tensor<T> constTensor, biasTensor;
+        bool transA, transB;
     };
 
 }}} /* namespace cv::dnn::cuda4dnn */

modules/dnn/src/dnn_common.hpp

@@ -13,7 +13,8 @@
 namespace cv { namespace dnn {
 CV__DNN_INLINE_NS_BEGIN
 #define IS_DNN_OPENCL_TARGET(id) (id == DNN_TARGET_OPENCL || id == DNN_TARGET_OPENCL_FP16)
-#define IS_DNN_CPU_TARGET(id) (id == DNN_TARGET_CPU) // TODO: add DNN_TARGET_CPU_FP16
+#define IS_DNN_CPU_TARGET(id) (id == DNN_TARGET_CPU || id == DNN_TARGET_CPU_FP16)
+#define IS_DNN_VULKAN_TARGET(id) (id == DNN_TARGET_VULKAN)
 Mutex& getInitializationMutex();
 void initializeLayerFactory();
 
@@ -154,6 +155,21 @@ static inline std::string toString(const Mat& blob, const std::string& name = st
     return ss.str();
 }
 
+// Scalefactor is a common parameter used for data scaling. In OpenCV, we often use Scalar to represent it.
+// Because 0 is meaningless in scalefactor.
+// If the scalefactor is (x, 0, 0, 0), we convert it to (x, x, x, x). The following func will do this hack.
+static inline Scalar_<double> broadcastRealScalar(const Scalar_<double>& _scale)
+{
+    Scalar_<double> scale = _scale;
+    if (scale[1] == 0 && scale[2] == 0 && scale[3] == 0)
+    {
+        CV_Assert(scale[0] != 0 && "Scalefactor of 0 is meaningless.");
+        scale = Scalar_<double>::all(scale[0]);
+    }
+
+    return scale;
+}
+
 
 CV__DNN_INLINE_NS_END
 

modules/dnn/src/dnn_read.cpp

@@ -29,6 +29,10 @@ Net readNet(const String& _model, const String& _config, const String& _framewor
             std::swap(model, config);
         return readNetFromTensorflow(model, config);
     }
+    if (framework == "tflite" || modelExt == "tflite")
+    {
+        return readNetFromTFLite(model);
+    }
     if (framework == "torch" || modelExt == "t7" || modelExt == "net" || configExt == "t7" || configExt == "net")
     {
         return readNetFromTorch(model.empty() ? config : model);
@@ -66,6 +70,8 @@ Net readNet(const String& _framework, const std::vector<uchar>& bufferModel,
         CV_Error(Error::StsNotImplemented, "Reading Torch models from buffers");
     else if (framework == "dldt")
         return readNetFromModelOptimizer(bufferConfig, bufferModel);
+    else if (framework == "tflite")
+        return readNetFromTFLite(bufferModel);
     CV_Error(Error::StsError, "Cannot determine an origin framework with a name " + framework);
 }
 

modules/dnn/src/dnn_utils.cpp

@@ -11,8 +11,17 @@ namespace cv {
 namespace dnn {
 CV__DNN_INLINE_NS_BEGIN
 
+Image2BlobParams::Image2BlobParams():scalefactor(Scalar::all(1.0)), size(Size()), mean(Scalar()), swapRB(false), ddepth(CV_32F),
+                           datalayout(DNN_LAYOUT_NCHW), paddingmode(DNN_PMODE_NULL)
+{}
 
-Mat blobFromImage(InputArray image, double scalefactor, const Size& size,
+Image2BlobParams::Image2BlobParams(const Scalar& scalefactor_, const Size& size_, const Scalar& mean_, bool swapRB_,
+                         int ddepth_, DataLayout datalayout_, ImagePaddingMode mode_):
+        scalefactor(scalefactor_), size(size_), mean(mean_), swapRB(swapRB_), ddepth(ddepth_),
+        datalayout(datalayout_), paddingmode(mode_)
+{}
+
+Mat blobFromImage(InputArray image, const double scalefactor, const Size& size,
         const Scalar& mean, bool swapRB, bool crop, int ddepth)
 {
     CV_TRACE_FUNCTION();
@@ -42,16 +51,55 @@ void blobFromImages(InputArrayOfArrays images_, OutputArray blob_, double scalef
         Size size, const Scalar& mean_, bool swapRB, bool crop, int ddepth)
 {
     CV_TRACE_FUNCTION();
-    CV_CheckType(ddepth, ddepth == CV_32F || ddepth == CV_8U, "Blob depth should be CV_32F or CV_8U");
-    if (ddepth == CV_8U)
-    {
-        CV_CheckEQ(scalefactor, 1.0, "Scaling is not supported for CV_8U blob depth");
-        CV_Assert(mean_ == Scalar() && "Mean subtraction is not supported for CV_8U blob depth");
-    }
+    Image2BlobParams param(Scalar::all(scalefactor), size, mean_, swapRB, ddepth);
+    if (crop)
+        param.paddingmode = DNN_PMODE_CROP_CENTER;
+    blobFromImagesWithParams(images_, blob_, param);
+}
 
+Mat blobFromImageWithParams(InputArray image, const Image2BlobParams& param)
+{
+    CV_TRACE_FUNCTION();
+    Mat blob;
+    blobFromImageWithParams(image, blob, param);
+    return blob;
+}
+
+void blobFromImageWithParams(InputArray image, OutputArray blob, const Image2BlobParams& param)
+{
+    CV_TRACE_FUNCTION();
+    std::vector<Mat> images(1, image.getMat());
+    blobFromImagesWithParams(images, blob, param);
+}
+
+Mat blobFromImagesWithParams(InputArrayOfArrays images, const Image2BlobParams& param)
+{
+    CV_TRACE_FUNCTION();
+    Mat blob;
+    blobFromImagesWithParams(images, blob, param);
+    return blob;
+}
+
+void blobFromImagesWithParams(InputArrayOfArrays images_, OutputArray blob_, const Image2BlobParams& param)
+{
+    CV_TRACE_FUNCTION();
+    CV_CheckType(param.ddepth, param.ddepth == CV_32F || param.ddepth == CV_8U,
+                 "Blob depth should be CV_32F or CV_8U");
+
+    Size size = param.size;
     std::vector<Mat> images;
     images_.getMatVector(images);
     CV_Assert(!images.empty());
+
+    int nch = images[0].channels();
+    Scalar scalefactor = param.scalefactor;
+
+    if (param.ddepth == CV_8U)
+    {
+        CV_Assert(scalefactor == Scalar::all(1.0) && "Scaling is not supported for CV_8U blob depth");
+        CV_Assert(param.mean == Scalar() && "Mean subtraction is not supported for CV_8U blob depth");
+    }
+
     for (size_t i = 0; i < images.size(); i++)
     {
         Size imgSize = images[i].size();
@@ -59,73 +107,122 @@ void blobFromImages(InputArrayOfArrays images_, OutputArray blob_, double scalef
             size = imgSize;
         if (size != imgSize)
         {
-            if (crop)
+            if (param.paddingmode == DNN_PMODE_CROP_CENTER)
             {
                 float resizeFactor = std::max(size.width / (float)imgSize.width,
-                        size.height / (float)imgSize.height);
+                                              size.height / (float)imgSize.height);
                 resize(images[i], images[i], Size(), resizeFactor, resizeFactor, INTER_LINEAR);
                 Rect crop(Point(0.5 * (images[i].cols - size.width),
-                                  0.5 * (images[i].rows - size.height)),
-                        size);
+                                0.5 * (images[i].rows - size.height)),
+                          size);
                 images[i] = images[i](crop);
             }
             else
-                resize(images[i], images[i], size, 0, 0, INTER_LINEAR);
+            {
+                if (param.paddingmode == DNN_PMODE_LETTERBOX)
+                {
+                    float resizeFactor = std::min(size.width / (float)imgSize.width,
+                                                  size.height / (float)imgSize.height);
+                    int rh = int(imgSize.height * resizeFactor);
+                    int rw = int(imgSize.width * resizeFactor);
+                    resize(images[i], images[i], Size(rw, rh), INTER_LINEAR);
+
+                    int top = (size.height - rh)/2;
+                    int bottom = size.height - top - rh;
+                    int left = (size.width - rw)/2;
+                    int right = size.width - left - rw;
+                    copyMakeBorder(images[i], images[i], top, bottom, left, right, BORDER_CONSTANT);
+                }
+                else
+                    resize(images[i], images[i], size, 0, 0, INTER_LINEAR);
+            }
         }
-        if (images[i].depth() == CV_8U && ddepth == CV_32F)
-            images[i].convertTo(images[i], CV_32F);
-        Scalar mean = mean_;
-        if (swapRB)
+
+        Scalar mean = param.mean;
+        if (param.swapRB)
+        {
             std::swap(mean[0], mean[2]);
+            std::swap(scalefactor[0], scalefactor[2]);
+        }
+
+        if (images[i].depth() == CV_8U && param.ddepth == CV_32F)
+            images[i].convertTo(images[i], CV_32F);
 
         images[i] -= mean;
-        images[i] *= scalefactor;
+        multiply(images[i], scalefactor, images[i]);
     }
 
     size_t nimages = images.size();
     Mat image0 = images[0];
-    int nch = image0.channels();
     CV_Assert(image0.dims == 2);
-    if (nch == 3 || nch == 4)
-    {
-        int sz[] = { (int)nimages, nch, image0.rows, image0.cols };
-        blob_.create(4, sz, ddepth);
-        Mat blob = blob_.getMat();
-        Mat ch[4];
 
+    if (param.datalayout == DNN_LAYOUT_NCHW)
+    {
+        if (nch == 3 || nch == 4)
+        {
+            int sz[] = { (int)nimages, nch, image0.rows, image0.cols };
+            blob_.create(4, sz, param.ddepth);
+            Mat blob = blob_.getMat();
+            Mat ch[4];
+
+            for (size_t i = 0; i < nimages; i++)
+            {
+                const Mat& image = images[i];
+                CV_Assert(image.depth() == blob_.depth());
+                nch = image.channels();
+                CV_Assert(image.dims == 2 && (nch == 3 || nch == 4));
+                CV_Assert(image.size() == image0.size());
+
+                for (int j = 0; j < nch; j++)
+                    ch[j] = Mat(image.rows, image.cols, param.ddepth, blob.ptr((int)i, j));
+                if (param.swapRB)
+                    std::swap(ch[0], ch[2]);
+                split(image, ch);
+            }
+        }
+        else
+        {
+            CV_Assert(nch == 1);
+            int sz[] = { (int)nimages, 1, image0.rows, image0.cols };
+            blob_.create(4, sz, param.ddepth);
+            Mat blob = blob_.getMat();
+
+            for (size_t i = 0; i < nimages; i++)
+            {
+                const Mat& image = images[i];
+                CV_Assert(image.depth() == blob_.depth());
+                nch = image.channels();
+                CV_Assert(image.dims == 2 && (nch == 1));
+                CV_Assert(image.size() == image0.size());
+
+                image.copyTo(Mat(image.rows, image.cols, param.ddepth, blob.ptr((int)i, 0)));
+            }
+        }
+    }
+    else if (param.datalayout == DNN_LAYOUT_NHWC)
+    {
+        int sz[] = { (int)nimages, image0.rows, image0.cols, nch};
+        blob_.create(4, sz, param.ddepth);
+        Mat blob = blob_.getMat();
+        int subMatType = CV_MAKETYPE(param.ddepth, nch);
         for (size_t i = 0; i < nimages; i++)
         {
             const Mat& image = images[i];
             CV_Assert(image.depth() == blob_.depth());
-            nch = image.channels();
-            CV_Assert(image.dims == 2 && (nch == 3 || nch == 4));
+            CV_Assert(image.channels() == image0.channels());
             CV_Assert(image.size() == image0.size());
-
-            for (int j = 0; j < nch; j++)
-                ch[j] = Mat(image.rows, image.cols, ddepth, blob.ptr((int)i, j));
-            if (swapRB)
-                std::swap(ch[0], ch[2]);
-            split(image, ch);
+            if (param.swapRB)
+            {
+                Mat tmpRB;
+                cvtColor(image, tmpRB, COLOR_BGR2RGB);
+                tmpRB.copyTo(Mat(tmpRB.rows, tmpRB.cols, subMatType, blob.ptr((int)i, 0)));
+            }
+            else
+                image.copyTo(Mat(image.rows, image.cols, subMatType, blob.ptr((int)i, 0)));
         }
     }
     else
-    {
-        CV_Assert(nch == 1);
-        int sz[] = { (int)nimages, 1, image0.rows, image0.cols };
-        blob_.create(4, sz, ddepth);
-        Mat blob = blob_.getMat();
-
-        for (size_t i = 0; i < nimages; i++)
-        {
-            const Mat& image = images[i];
-            CV_Assert(image.depth() == blob_.depth());
-            nch = image.channels();
-            CV_Assert(image.dims == 2 && (nch == 1));
-            CV_Assert(image.size() == image0.size());
-
-            image.copyTo(Mat(image.rows, image.cols, ddepth, blob.ptr((int)i, 0)));
-        }
-    }
+        CV_Error(Error::StsUnsupportedFormat, "Unsupported data layout in blobFromImagesWithParams function.");
 }
 
 void imagesFromBlob(const cv::Mat& blob_, OutputArrayOfArrays images_)

modules/dnn/src/init.cpp

@@ -42,7 +42,7 @@
 #include "precomp.hpp"
 #include <opencv2/dnn/layer.details.hpp>
 
-#if !defined(BUILD_PLUGIN)
+#if defined(HAVE_PROTOBUF) && !defined(BUILD_PLUGIN)
 #include <google/protobuf/stubs/common.h>
 #endif
 
@@ -60,7 +60,7 @@ Mutex& getInitializationMutex()
 // force initialization (single-threaded environment)
 Mutex* __initialization_mutex_initializer = &getInitializationMutex();
 
-#if !defined(BUILD_PLUGIN)
+#if defined(HAVE_PROTOBUF) && !defined(BUILD_PLUGIN)
 namespace {
 using namespace google::protobuf;
 class ProtobufShutdown {
@@ -80,7 +80,7 @@ void initializeLayerFactory()
 {
     CV_TRACE_FUNCTION();
 
-#if !defined(BUILD_PLUGIN)
+#if defined(HAVE_PROTOBUF) && !defined(BUILD_PLUGIN)
     static ProtobufShutdown protobufShutdown; CV_UNUSED(protobufShutdown);
 #endif
 
@@ -145,6 +145,8 @@ void initializeLayerFactory()
     CV_DNN_REGISTER_LAYER_CLASS(HardSigmoid,    HardSigmoidLayer);
     CV_DNN_REGISTER_LAYER_CLASS(Selu,           SeluLayer);
     CV_DNN_REGISTER_LAYER_CLASS(ThresholdedRelu,ThresholdedReluLayer);
+    CV_DNN_REGISTER_LAYER_CLASS(Gelu,           GeluLayer);
+    CV_DNN_REGISTER_LAYER_CLASS(GeluApproximation, GeluApproximationLayer);
     CV_DNN_REGISTER_LAYER_CLASS(BatchNorm,      BatchNormLayer);
     CV_DNN_REGISTER_LAYER_CLASS(MaxUnpool,      MaxUnpoolLayer);
     CV_DNN_REGISTER_LAYER_CLASS(Dropout,        BlankLayer);
@@ -192,7 +194,6 @@ void initializeLayerFactory()
     CV_DNN_REGISTER_LAYER_CLASS(ConvolutionInt8,  ConvolutionLayerInt8);
     CV_DNN_REGISTER_LAYER_CLASS(InnerProductInt8, InnerProductLayerInt8);
     CV_DNN_REGISTER_LAYER_CLASS(PoolingInt8,      PoolingLayerInt8);
-    CV_DNN_REGISTER_LAYER_CLASS(ReduceInt8,       ReduceLayerInt8);
     CV_DNN_REGISTER_LAYER_CLASS(EltwiseInt8,      EltwiseLayerInt8);
     CV_DNN_REGISTER_LAYER_CLASS(BatchNormInt8,    BatchNormLayerInt8);
     CV_DNN_REGISTER_LAYER_CLASS(ScaleInt8,        ScaleLayerInt8);

modules/dnn/src/int8layers/convolution_layer.cpp

@@ -87,11 +87,11 @@ public:
         CV_Assert(inputs[0].dims == outputs[0].dims);
         if (weightShape.dims() == 3)
         {
-            kernel_size.assign(1, kernel_size[0]);
-            strides.assign(1, strides[0]);
-            dilations.assign(1, dilations[0]);
-            pads_begin.assign(1, pads_begin[0]);
-            pads_end.assign(1, pads_end[0]);
+            kernel_size.resize(1, kernel_size[0]);
+            strides.resize(1, strides[0]);
+            dilations.resize(1, dilations[0]);
+            pads_begin.resize(1, pads_begin[0]);
+            pads_end.resize(1, pads_end[0]);
         }
         CV_Assert(weightShape.dims() == kernel_size.size() + 2);
         for (int i = 0; i < kernel_size.size(); i++) {

modules/dnn/src/int8layers/pooling_layer.cpp

@@ -89,10 +89,10 @@ public:
         if (inputs[0].dims == 3)
         {
             // Pool1D
-            kernel_size.assign(1, kernel_size[0]);
-            strides.assign(1, strides[0]);
-            pads_begin.assign(1, pads_begin[0]);
-            pads_end.assign(1, pads_end[0]);
+            kernel_size.resize(1, kernel_size[0]);
+            strides.resize(1, strides[0]);
+            pads_begin.resize(1, pads_begin[0]);
+            pads_end.resize(1, pads_end[0]);
         }
     }
 

modules/dnn/src/int8layers/reduce_layer.cpp

@@ -1,234 +0,0 @@
-// 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 "../precomp.hpp"
-#include "layers_common.hpp"
-
-#include <algorithm>
-#include <stdlib.h>
-#include <numeric>
-
-namespace cv
-{
-namespace dnn
-{
-
-class ReduceLayerInt8Impl CV_FINAL : public ReduceLayerInt8
-{
-public:
-    ReduceLayerInt8Impl(const LayerParams& params)
-    {
-        // Set reduce type
-        CV_Assert(params.has("reduce"));
-        String typeString = toLowerCase(params.get<String>("reduce"));
-        if (typeString == "max")
-            reduceType = MAX;
-        else if (typeString == "min")
-            reduceType = MIN;
-        else
-            CV_Error(Error::StsBadArg, "Unknown reduce type \"" + typeString + "\"");
-
-        // Set deleted dims
-        CV_Assert(params.has("deleted_dims"));
-        DictValue tempDims = params.get("deleted_dims");
-        int i, n = tempDims.size();
-        reduceDims.resize(n);
-        for (i = 0; i < n; i++)
-        {
-            reduceDims[i] = tempDims.get<int>(i);
-        }
-
-        CV_Assert(params.has("target_dims"));
-        tempDims = params.get("target_dims");
-        n = tempDims.size();
-        targetDims.resize(n);
-        for (i = 0; i < n; i++)
-        {
-            targetDims[i] = tempDims.get<int>(i);
-        }
-    }
-
-    virtual bool supportBackend(int backendId) CV_OVERRIDE
-    {
-        if (backendId == DNN_BACKEND_OPENCV)
-        {
-            return true;
-        }
-        return false;
-    }
-
-    // reduceType == MIN
-    struct ReduceOpMIN
-    {
-        int8_t apply(const int8_t* first, const int8_t* last)
-        {
-            return std::accumulate(first, last, *first,
-                                   [](int8_t a, int8_t b)
-                                   {
-                                       return std::min(a, b);
-                                   });
-        }
-    };
-
-    // reduceType == MAX
-    struct ReduceOpMAX
-    {
-        int8_t apply(const int8_t* first, const int8_t* last)
-        {
-            return std::accumulate(first, last, *first,
-                                   [](int8_t a, int8_t b)
-                                   {
-                                       return std::max(a, b);
-                                   });
-        }
-    };
-
-    template<typename Func>
-    class ReduceInvoker : public ParallelLoopBody
-    {
-    public:
-        const Mat* src;
-        Mat *dst;
-        std::vector<size_t> reduceDims;
-        int nstripes;
-        int reduceType;
-        Ptr<Func> func;
-
-        ReduceInvoker() : src(0), dst(0), nstripes(0), reduceType(MAX), func(makePtr<Func>()) {}
-
-        static void run(const Mat& src, Mat& dst, std::vector<size_t> reduceDims, int reduceType, int nstripes)
-        {
-            CV_Assert_N(src.isContinuous(), dst.isContinuous(), src.type() == CV_8S, src.type() == dst.type());
-
-            ReduceInvoker<Func> p;
-
-            p.src = &src;
-            p.dst = &dst;
-
-            p.reduceDims = reduceDims;
-            p.nstripes = nstripes;
-            p.reduceType = reduceType;
-
-            parallel_for_(Range(0, nstripes), p, nstripes);
-        }
-
-        void operator()(const Range& r) const CV_OVERRIDE
-        {
-            size_t total = dst->total();
-            size_t stripeSize = (total + nstripes - 1)/nstripes;
-            size_t stripeStart = r.start*stripeSize;
-            size_t stripeEnd = std::min(r.end*stripeSize, total);
-            size_t totalDeleted = std::accumulate(reduceDims.begin(), reduceDims.end(), 1, std::multiplies<size_t>());
-
-            int8_t *dstData = (int8_t *)dst->data;
-            int8_t *srcData = (int8_t *)src->data;
-
-            for (size_t ofs = stripeStart; ofs < stripeEnd;)
-            {
-                const int8_t* first = srcData + ofs * totalDeleted;
-                const int8_t* last = srcData + (ofs + 1) * totalDeleted;
-
-                dstData[ofs] = func->apply(first, last);
-                ofs += 1;
-            }
-        }
-    };
-
-    void forward(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr, OutputArrayOfArrays internals_arr) CV_OVERRIDE
-    {
-        CV_TRACE_FUNCTION();
-        CV_TRACE_ARG_VALUE(name, "name", name.c_str());
-
-        std::vector<Mat> inputs, outputs;
-        inputs_arr.getMatVector(inputs);
-        outputs_arr.getMatVector(outputs);
-        CV_Assert(inputs.size() == 1);
-        const int nstripes = getNumThreads();
-
-        switch (reduceType)
-        {
-            case MIN:
-            {
-                ReduceInvoker<ReduceOpMIN>::run(inputs[0], outputs[0], reduceDims, reduceType, nstripes);
-                break;
-            }
-            case MAX:
-            {
-                ReduceInvoker<ReduceOpMAX>::run(inputs[0], outputs[0], reduceDims, reduceType, nstripes);
-                break;
-            }
-            default:
-                CV_Error(Error::StsNotImplemented, "Not implemented");
-                break;
-        }
-    }
-
-    bool getMemoryShapes(const std::vector<MatShape> &inputs,
-                         const int requiredOutputs,
-                         std::vector<MatShape> &outputs,
-                         std::vector<MatShape> &internals) const CV_OVERRIDE
-    {
-        CV_Assert(inputs.size() > 0);
-        CV_Assert( reduceDims.size() !=0 && targetDims.size() != 0 && inputs[0].size() >= reduceDims.size());
-
-        // outShapeTmp can save the right number of `total(outShapeTmp)`. And the outShape is used as the final output shape.
-        std::vector<int> outShapeTmp, outShape;
-        outShape.assign(targetDims.begin(), targetDims.end());
-        if (inputs[0].size() == reduceDims.size())
-            outShapeTmp.push_back(1);
-        else
-        {
-            for (int i = 0; i < inputs[0].size() - reduceDims.size(); i++)
-            {
-                outShapeTmp.push_back(inputs[0][i]);
-            }
-        }
-
-        // Support dynamic shape of Batch size.
-        // Note that: when there are multiple dynamic inputs, we will give an error.
-        if (total(outShape) != total(outShapeTmp))
-        {
-            if (outShape[0] != outShapeTmp[0])
-                outShape[0] = outShapeTmp[0];
-        }
-
-        CV_Assert(total(outShape) == total(outShapeTmp));
-        outputs.assign(1, outShape);
-
-        return false;
-    }
-
-    virtual bool tryQuantize(const std::vector<std::vector<float> > &scales,
-                             const std::vector<std::vector<int> > &zeropoints, LayerParams& params) CV_OVERRIDE
-    {
-        return false;
-    }
-
-    virtual int64 getFLOPS(const std::vector<MatShape> &inputs,
-                           const std::vector<MatShape> &outputs) const CV_OVERRIDE
-    {
-        CV_UNUSED(inputs); // suppress unused variable warning
-        long flops = 0;
-        size_t totalDeleted = std::accumulate(reduceDims.begin(), reduceDims.end(), 1, std::multiplies<size_t>());
-        for (int i = 0; i < outputs.size(); i++)
-        {
-            flops += total(outputs[i])*(totalDeleted);
-        }
-        return flops;
-    }
-private:
-    enum Type
-    {
-        MAX,
-        MIN
-    };
-};
-
-Ptr<ReduceLayerInt8> ReduceLayerInt8::create(const LayerParams& params)
-{
-    return Ptr<ReduceLayerInt8>(new ReduceLayerInt8Impl(params));
-}
-
-}
-}

modules/dnn/src/int8layers/softmax_layer.cpp

@@ -22,15 +22,29 @@ public:
 
     SoftMaxLayerInt8Impl(const LayerParams& params)
     {
-        axisRaw = params.get<int>("axis", 1);
+        setParamsFrom(params);
+
+        axis = params.get<int>("axis", 1);
         logSoftMax = params.get<bool>("log_softmax", false);
+        coerced_2d = params.get<bool>("coerced_2d", false);
 
         input_sc = params.get<float>("input_scale");
         input_zp = params.get<int>("input_zeropoint");
 
         output_sc = params.get<float>("scales");
         output_zp = params.get<int>("zeropoints");
-        setParamsFrom(params);
+
+        if (blobs.empty()) // if no lookUpTable is found
+        {
+            Mat lookUpTable(1, 256, CV_32F);
+            float* table = lookUpTable.ptr<float>();
+            for (int i = -128; i < 128; i++)
+            {
+                float x = input_sc * (i - 127); // ensures exp(x) is always between (0, 1)
+                table[i + 128] = std::exp(x);
+            }
+            blobs.push_back(lookUpTable);
+        }
     }
 
     bool getMemoryShapes(const std::vector<MatShape> &inputs,
@@ -40,12 +54,39 @@ public:
     {
         bool inplace = Layer::getMemoryShapes(inputs, requiredOutputs, outputs, internals);
         MatShape shape = inputs[0];
-        int cAxis = normalize_axis(axisRaw, shape.size());
-        shape[cAxis] = 1;
         internals.assign(1, shape);
         return inplace;
     }
 
+    virtual void finalize(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr) CV_OVERRIDE {
+        std::vector<Mat> inputs;
+        inputs_arr.getMatVector(inputs);
+        auto src = inputs[0];
+        auto dims_src = src.dims;
+        auto shape_src = shape(src);
+        axis = normalize_axis(axis, dims_src);
+
+        if (!coerced_2d) {
+            is_transpose_needed = (axis == dims_src - 1) ? false : true;
+            if (is_transpose_needed) {
+                permutation.resize(dims_src);
+                std::iota(permutation.begin(), permutation.end(), 0);
+                permutation[axis] = dims_src - 1;
+                permutation[dims_src - 1] = axis;
+
+                transposed_shape.resize(dims_src);
+                std::transform(permutation.begin(), permutation.end(), transposed_shape.begin(), [&shape_src](int axis) { return shape_src[axis]; });
+                N = std::accumulate(transposed_shape.begin(), transposed_shape.end() - 1, 1, std::multiplies<int>());
+                D = transposed_shape.back();
+
+                return;
+            }
+        }
+
+        N = src.total(0, axis);
+        D = src.total(axis);
+    }
+
     virtual bool supportBackend(int backendId) CV_OVERRIDE
     {
         return backendId == DNN_BACKEND_OPENCV ||
@@ -80,8 +121,7 @@ public:
         const Mat &src = inputWrapper->getMat();
 
         // convert axis from OpenCV NCHW toTimVX WHCN.
-        int axis = normalize_axis(axisRaw, src.dims);
-        int tvAxis = src.dims - 1 - axis;
+        int tvAxis = src.dims - 1 - normalize_axis(axis, src.dims);
         if(tvAxis < 0)
             tvAxis = 0; // default value is 0.
 
@@ -154,103 +194,188 @@ public:
         return Ptr<BackendNode>();
     }
 
+    template <bool with_log>
+    class SoftmaxInt8Invoker : public ParallelLoopBody {
+    public:
+        const Mat& src_;
+        Mat& dst_;
+
+        const Mat& lookup_table_;
+
+        int N_;
+        int D_;
+
+        float y_scale_;
+        int y_zero_point_;
+
+        int threads;
+        int cost_per_thread;
+
+        SoftmaxInt8Invoker(const Mat& src, Mat& dst, const Mat& lookup_table, int N, int D, float y_scale, int y_zero_point)
+            : src_(src), dst_(dst), lookup_table_(lookup_table), N_(N), D_(D), y_scale_(1.f / y_scale), y_zero_point_(y_zero_point) {
+            threads = N_;
+            cost_per_thread = D_;
+        }
+
+        static void run(const Mat& src, Mat& dst, const Mat& lookup_table, int N, int D, float y_scale, int y_zero_point) {
+            CV_Assert(src.isContinuous());
+            CV_Assert(dst.isContinuous());
+            CV_CheckTypeEQ(src.type(), CV_8S, "DNN/SoftmaxInt8: type of input must be int8");
+            CV_CheckTypeEQ(dst.type(), CV_8S, "DNN/SoftmaxInt8: type of output must be int8");
+
+            SoftmaxInt8Invoker p(src, dst, lookup_table, N, D, y_scale, y_zero_point);
+
+            double nstripes = ((size_t)p.threads * p.cost_per_thread) * (1 / 1024.0);
+            parallel_for_(Range(0, p.threads), p, nstripes);
+        }
+
+        void operator()(const Range& r) const CV_OVERRIDE {
+            int start = r.start;
+            int end = r.end;
+
+            const int8_t* p_src = src_.ptr<int8_t>();
+            int8_t* p_dst = dst_.ptr<int8_t>();
+            const float* table = lookup_table_.ptr<float>();
+
+            for (int i = start; i < end; ++i) {
+                const int8_t* x = p_src + i * D_;
+                int8_t* y = p_dst + i * D_;
+
+                float vsum = 0;
+                for (int j = 0; j < D_; ++j) {
+                    const uint8_t idx = uint8_t((*x++) + 128);
+                    vsum += table[idx];
+                }
+
+                // FIXME: avoid divide by vsum==0
+
+                x = p_src + i * D_;
+                if (with_log) {
+                    for (int j = 0; j < D_; ++j) {
+                        const uint8_t idx = uint8_t((*x++) + 128);
+                        const float v = table[idx];
+                        *y++ = saturate_cast<int8_t>(std::nearbyintf(y_scale_ * std::log(v / vsum)) + y_zero_point_);
+                    }
+                } else {
+                    for (int j = 0; j < D_; ++j) {
+                        const uint8_t idx = uint8_t((*x++) + 128);
+                        const float v = table[idx];
+                        *y++ = saturate_cast<int8_t>(std::nearbyintf(y_scale_ * v / vsum) + y_zero_point_);
+                    }
+                }
+            }
+        }
+    };
+
+    template <bool with_log>
+    class SoftmaxInt8OutputFloatInvoker : public ParallelLoopBody {
+    public:
+        const Mat& src_;
+        Mat& dst_;
+
+        const Mat& lookup_table_;
+
+        int N_;
+        int D_;
+
+        int threads;
+        int cost_per_thread;
+
+        SoftmaxInt8OutputFloatInvoker(const Mat& src, Mat& dst, const Mat& lookup_table, int N, int D)
+            : src_(src), dst_(dst), lookup_table_(lookup_table), N_(N), D_(D) {
+            threads = N_;
+            cost_per_thread = D_;
+        }
+
+        static void run(const Mat& src, Mat& dst, const Mat& lookup_table, int N, int D) {
+            CV_Assert(src.isContinuous());
+            CV_Assert(dst.isContinuous());
+            CV_CheckTypeEQ(src.type(), CV_8S, "DNN/SoftmaxInt8: type of input must be int8");
+            CV_CheckTypeEQ(dst.type(), CV_32F, "DNN/SoftmaxInt8: type of input must be float32 since Dequantization is fused");
+
+            SoftmaxInt8OutputFloatInvoker p(src, dst, lookup_table, N, D);
+
+            double nstripes = ((size_t)p.threads * p.cost_per_thread) * (1 / 1024.0);
+            parallel_for_(Range(0, p.threads), p, nstripes);
+        }
+
+        void operator()(const Range& r) const CV_OVERRIDE {
+            int start = r.start;
+            int end = r.end;
+
+            const int8_t* p_src = src_.ptr<int8_t>();
+            float* p_dst = dst_.ptr<float>();
+            const float* table = lookup_table_.ptr<float>();
+
+            for (int i = start; i < end; ++i) {
+                const int8_t* x = p_src + i * D_;
+                float* y = p_dst + i * D_;
+
+                float vsum = 0;
+                for (int j = 0; j < D_; ++j) {
+                    const uint8_t idx = uint8_t((*x++) + 128);
+                    vsum += table[idx];
+                }
+
+                // FIXME: avoid divide by vsum==0
+
+                x = p_src + i * D_;
+                if (with_log) {
+                    for (int j = 0; j < D_; ++j) {
+                        const uint8_t idx = uint8_t((*x++) + 128);
+                        const float v = table[idx];
+                        *y++ = std::log(v / vsum);
+                    }
+                } else {
+                    for (int j = 0; j < D_; ++j) {
+                        const uint8_t idx = uint8_t((*x++) + 128);
+                        const float v = table[idx];
+                        *y++ = v / vsum;
+                    }
+                }
+            }
+        }
+    };
+
     void forward(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr, OutputArrayOfArrays internals_arr) CV_OVERRIDE
     {
         CV_TRACE_FUNCTION();
         CV_TRACE_ARG_VALUE(name, "name", name.c_str());
 
-        std::vector<Mat> inputs, outputs, internals;
+        std::vector<Mat> inputs, outputs;
         inputs_arr.getMatVector(inputs);
         outputs_arr.getMatVector(outputs);
-        internals_arr.getMatVector(internals);
 
-        const Mat &src = inputs[0];
-        Mat &dst = outputs[0];
+        Mat src, dst;
 
-        int axis = normalize_axis(axisRaw, src.dims);
-        size_t outerSize = src.total(0, axis), channels = src.size[axis],
-               innerSize = src.total(axis + 1);
-
-        CV_Assert(src.type() == CV_8S && (dst.type() == CV_8S || dst.type() == CV_32F));
-        CV_Assert(src.isContinuous() && dst.isContinuous());
-
-        size_t outerStep = src.total(axis);
-        size_t cnStep = src.total(axis + 1);
-        const int8_t *srcPtr = src.ptr<int8_t>();
-        const float *expPtr = blobs[0].ptr<float>();
-
-        if (dst.type() == CV_32F)
-        {
-            float *dstPtr = dst.ptr<float>();
-            for (size_t outerDim = 0; outerDim < outerSize; outerDim++)
-            {
-                size_t srcOffset = outerDim * outerStep;
-                std::vector<float> expSum(innerSize, 0.f);
-
-                // sum exp along axis
-                for (size_t cnDim = 0; cnDim < channels; cnDim++)
-                {
-                    const int offset = srcOffset + cnDim * cnStep;
-                    for (size_t i = 0; i < innerSize; i++)
-                        expSum[i] += expPtr[srcPtr[offset + i] + 128];
-                }
-
-                // divide by computed sum
-                for (size_t cnDim = 0; cnDim < channels; cnDim++)
-                {
-                    const int offset = srcOffset + cnDim * cnStep;
-                    for (size_t i = 0; i < innerSize; i++)
-                        dstPtr[offset + i] = expPtr[srcPtr[offset + i] + 128]/expSum[i];
-                }
-
-                if (logSoftMax)
-                {
-                    for (size_t cnDim = 0; cnDim < channels; cnDim++)
-                    {
-                        const int offset = srcOffset + cnDim * cnStep;
-                        for (size_t i = 0; i < innerSize; i++)
-                            dstPtr[offset + i] = log(dstPtr[offset + i]);
-                    }
-                }
-            }
+        if (!coerced_2d && is_transpose_needed) {
+            transposeND(inputs[0], permutation, src);
+            dst = Mat::zeros(transposed_shape.size(), transposed_shape.data(), outputs[0].type());
+        } else {
+            src = inputs[0];
+            dst = outputs[0];
         }
-        else
-        {
-            const float inv_scale = 1.f/output_sc;
-            int8_t *dstPtr = dst.ptr<int8_t>();
-            for (size_t outerDim = 0; outerDim < outerSize; outerDim++)
-            {
-                size_t srcOffset = outerDim * outerStep;
-                std::vector<float> expSum(innerSize, 0.f);
 
-                // sum exp along axis
-                for (size_t cnDim = 0; cnDim < channels; cnDim++)
-                {
-                    const int offset = srcOffset + cnDim * cnStep;
-                    for (size_t i = 0; i < innerSize; i++)
-                        expSum[i] += expPtr[srcPtr[offset + i] + 128];
+        switch (dst.type()) {
+            case CV_8S: {
+                if (logSoftMax) {
+                    SoftmaxInt8Invoker<true>::run(src, dst, blobs[0], N, D, output_sc, output_zp);
+                } else {
+                    SoftmaxInt8Invoker<false>::run(src, dst, blobs[0], N, D, output_sc, output_zp);
                 }
+            } break;
+            case CV_32F: {
+                if (logSoftMax) {
+                    SoftmaxInt8OutputFloatInvoker<true>::run(src, dst, blobs[0], N, D);
+                } else {
+                    SoftmaxInt8OutputFloatInvoker<false>::run(src, dst, blobs[0], N, D);
+                }
+            } break;
+            default: CV_Error(cv::Error::BadDepth, "DNN/SoftmaxInt8: Unsupported output type");
+        }
 
-                // divide by computed sum and quantize to int8
-                if (logSoftMax)
-                {
-                    for (size_t cnDim = 0; cnDim < channels; cnDim++)
-                    {
-                        const int offset = srcOffset + cnDim * cnStep;
-                        for (size_t i = 0; i < innerSize; i++)
-                            dstPtr[offset + i] = saturate_cast<int8_t>(output_zp + std::round(inv_scale*log(expPtr[srcPtr[offset + i] + 128]/expSum[i])));
-                    }
-                }
-                else
-                {
-                    for (size_t cnDim = 0; cnDim < channels; cnDim++)
-                    {
-                        const int offset = srcOffset + cnDim * cnStep;
-                        for (size_t i = 0; i < innerSize; i++)
-                            dstPtr[offset + i] = saturate_cast<int8_t>(output_zp + std::round(inv_scale*(expPtr[srcPtr[offset + i] + 128]/expSum[i])));
-                    }
-                }
-            }
+        if (!coerced_2d && is_transpose_needed) {
+            transposeND(dst, permutation, outputs[0]);
         }
     }
 
@@ -268,7 +393,14 @@ public:
         return flops;
     }
 
-    int axisRaw;
+private:
+    int axis;
+    int N;
+    int D;
+    bool coerced_2d;
+    bool is_transpose_needed;
+    std::vector<int> permutation;
+    std::vector<int> transposed_shape;
 };
 
 Ptr<SoftmaxLayerInt8> SoftmaxLayerInt8::create(const LayerParams& params)

modules/dnn/src/layer.cpp

@@ -50,7 +50,8 @@ Ptr<BackendNode> Layer::initCUDA(
     return Ptr<BackendNode>();
 }
 
-Ptr<BackendNode> Layer::initVkCom(const std::vector<Ptr<BackendWrapper>>&)
+Ptr<BackendNode> Layer::initVkCom(const std::vector<Ptr<BackendWrapper> > &inputs,
+                                  std::vector<Ptr<BackendWrapper> > &outputs)
 {
     CV_Error(Error::StsNotImplemented, "VkCom pipeline of " + type + " layers is not defined.");
     return Ptr<BackendNode>();
@@ -84,7 +85,9 @@ Ptr<BackendNode> Layer::initTimVX(void* timVxInfo,
     return Ptr<BackendNode>();
 }
 
-Ptr<BackendNode> Layer::initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes)
+Ptr<BackendNode> Layer::initCann(const std::vector<Ptr<BackendWrapper> > &inputs,
+                                 const std::vector<Ptr<BackendWrapper> > &outputs,
+                                 const std::vector<Ptr<BackendNode> >& nodes)
 {
     CV_Error(Error::StsNotImplemented, "CANN pipeline of " + type + " layers is not defined.");
     return Ptr<BackendNode>();

modules/dnn/src/layers/batch_norm_layer.cpp

@@ -392,17 +392,18 @@ public:
 #endif  // HAVE_HALIDE
 
 #ifdef HAVE_CANN
-    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
+    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputs,
+                                      const std::vector<Ptr<BackendWrapper> > &outputs,
+                                      const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
     {
         CV_Assert(nodes.size() == 1);
         CV_Assert(blobs.size() == 4); // must have scale, offset, mean and variance
 
-        auto x = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
+        auto x = inputs[0].dynamicCast<CannBackendWrapper>();
         auto channel = x->host->size[1];
 
         // create operator
-        std::string op_name = cv::format("bn_%d", index);
-        auto op = std::make_shared<ge::op::BatchNorm>(op_name);
+        auto op = std::make_shared<ge::op::BatchNorm>(name);
 
         // set attributes
         op->set_attr_epsilon(epsilon);
@@ -412,24 +413,24 @@ public:
         // set inputs
         // set inputs : x
         auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
-        op->set_input_x_by_name(*op_x, "y");
+        op->set_input_x_by_name(*op_x, x->name.c_str());
         auto x_desc = x->getTensorDesc();
         op->update_input_desc_x(*x_desc);
         // set inputs : scale (blobs[2])
         std::vector<int> shape_{channel};
-        auto op_const_scale = std::make_shared<CannConstOp>(blobs[2].data, blobs[2].type(), shape_, cv::format("%s_scale", op_name.c_str()));
+        auto op_const_scale = std::make_shared<CannConstOp>(blobs[2].data, blobs[2].type(), shape_, cv::format("%s_scale", name.c_str()));
         op->set_input_scale(*(op_const_scale->getOp()));
         op->update_input_desc_scale(*(op_const_scale->getTensorDesc()));
         // set inputs : offset (blobs[3])
-        auto op_const_offset = std::make_shared<CannConstOp>(blobs[3].data, blobs[3].type(), shape_, cv::format("%s_offset", op_name.c_str()));
+        auto op_const_offset = std::make_shared<CannConstOp>(blobs[3].data, blobs[3].type(), shape_, cv::format("%s_offset", name.c_str()));
         op->set_input_offset(*(op_const_offset->getOp()));
         op->update_input_desc_offset(*(op_const_offset->getTensorDesc()));
         // set inputs : mean (blobs[0])
-        auto op_const_mean = std::make_shared<CannConstOp>(blobs[0].data, blobs[0].type(), shape_, cv::format("%s_mean", op_name.c_str()));
+        auto op_const_mean = std::make_shared<CannConstOp>(blobs[0].data, blobs[0].type(), shape_, cv::format("%s_mean", name.c_str()));
         op->set_input_mean(*(op_const_mean->getOp()));
         op->update_input_desc_mean(*(op_const_mean->getTensorDesc()));
         // set inputs : variance (blobs[1])
-        auto op_const_var = std::make_shared<CannConstOp>(blobs[1].data, blobs[1].type(), shape_, cv::format("%s_var", op_name.c_str()));
+        auto op_const_var = std::make_shared<CannConstOp>(blobs[1].data, blobs[1].type(), shape_, cv::format("%s_var", name.c_str()));
         op->set_input_variance(*(op_const_var->getOp()));
         op->update_input_desc_variance(*(op_const_var->getTensorDesc()));
 

modules/dnn/src/layers/blank_layer.cpp

@@ -121,19 +121,20 @@ public:
     }
 
 #ifdef HAVE_CANN
-    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
+    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputs,
+                                      const std::vector<Ptr<BackendWrapper> > &outputs,
+                                      const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
     {
-        auto x = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
+        auto x = inputs[0].dynamicCast<CannBackendWrapper>();
         auto x_desc = x->getTensorDesc();
         auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
         auto output_desc = std::make_shared<ge::TensorDesc>(ge::Shape(), ge::FORMAT_NCHW, ge::DT_FLOAT);
 
         // create operator
-        std::string op_name = cv::format("identity_%d", index);
-        auto op = std::make_shared<ge::op::Identity>(op_name);
+        auto op = std::make_shared<ge::op::Identity>(name);
 
         // set inputs
-        op->set_input_x_by_name(*op_x, "y");
+        op->set_input_x_by_name(*op_x, x->name.c_str());
         op->update_input_desc_x(*x_desc);
 
         // set output

modules/dnn/src/layers/concat_layer.cpp

@@ -141,7 +141,6 @@ public:
                backendId == DNN_BACKEND_CUDA ||
                (backendId == DNN_BACKEND_HALIDE && haveHalide() && axis == 1 && !padding) ||  // By channels
                (backendId == DNN_BACKEND_WEBNN && !padding) ||
-               (backendId == DNN_BACKEND_VKCOM && haveVulkan() && !padding) ||
                (backendId == DNN_BACKEND_CANN && !padding);
     }
 
@@ -332,17 +331,6 @@ public:
     }
 #endif
 
-    virtual Ptr<BackendNode> initVkCom(const std::vector<Ptr<BackendWrapper> > &input) CV_OVERRIDE
-    {
-#ifdef HAVE_VULKAN
-        vkcom::Tensor in = VkComTensor(input[0]);
-        int cAxis = normalize_axis(axis, in.dimNum());
-        std::shared_ptr<vkcom::OpBase> op(new vkcom::OpConcat(cAxis));
-        return Ptr<BackendNode>(new VkComBackendNode(input, op));
-#endif // HAVE_VULKAN
-        return Ptr<BackendNode>();
-    }
-
     virtual Ptr<BackendNode> initHalide(const std::vector<Ptr<BackendWrapper> > &input) CV_OVERRIDE
     {
 #ifdef HAVE_HALIDE
@@ -367,16 +355,17 @@ public:
     }
 
 #ifdef HAVE_CANN
-    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
+    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputs,
+                                      const std::vector<Ptr<BackendWrapper> > &outputs,
+                                      const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
     {
-        CV_Assert(inputsWrapper.size() == nodes.size());
+        CV_Assert(inputs.size() == nodes.size());
 
         // create operator
-        std::string op_name = cv::format("concat_%d", index);
-        auto op = std::make_shared<ge::op::ConcatD>(op_name);
+        auto op = std::make_shared<ge::op::ConcatD>(name);
 
         // set attributes
-        int N = inputsWrapper.size();
+        int N = inputs.size();
         op->set_attr_concat_dim(axis);
         op->set_attr_N(N);
 
@@ -384,10 +373,10 @@ public:
         op->create_dynamic_input_x(N);
         for (int i = 0; i < N; i++)
         {
-            auto x_i = inputsWrapper[i].dynamicCast<CannBackendWrapper>();
+            auto x_i = inputs[i].dynamicCast<CannBackendWrapper>();
             auto x_i_desc = x_i->getTensorDesc();
             auto op_x_i = nodes[i].dynamicCast<CannBackendNode>()->getOp();
-            op->set_dynamic_input_x(i, *op_x_i, "y");
+            op->set_dynamic_input_x(i, *op_x_i, x_i->name.c_str());
             op->update_dynamic_input_desc_x(i, *x_i_desc);
         }
 

modules/dnn/src/layers/const_layer.cpp

@@ -84,7 +84,9 @@ public:
     }
 
 #ifdef HAVE_CANN
-    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
+    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputs,
+                                      const std::vector<Ptr<BackendWrapper> > &outputs,
+                                      const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
     {
         auto mat_shape = shape(blobs[0]);
         std::vector<int64_t> mat_shape_{mat_shape.begin(), mat_shape.end()};
@@ -110,8 +112,7 @@ public:
         ge_tensor->SetTensorDesc(*desc);
         ge_tensor->SetData(blobs[0].data, ge_shape.GetShapeSize() * size_of_type);
 
-        std::string op_name = cv::format("const_%d", index);
-        auto op = std::make_shared<ge::op::Const>(op_name);
+        auto op = std::make_shared<ge::op::Const>(name);
         op->set_attr_value(*ge_tensor);
 
         return Ptr<BackendNode>(new CannBackendNode(op));

modules/dnn/src/layers/convolution_layer.cpp

@@ -72,7 +72,7 @@ using namespace cv::dnn::ocl4dnn;
 using namespace cv::dnn::cuda4dnn;
 #endif
 
-#include "fast_convolution/fast_convolution.hpp"
+#include "cpu_kernels/convolution.hpp"
 
 namespace cv
 {
@@ -116,9 +116,6 @@ public:
 
         fusedWeights = false;
         fusedBias = false;
-
-        if (kernel_size.size() == 2)
-            isConv2D = true;
     }
 
     virtual void finalize(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr) CV_OVERRIDE
@@ -134,11 +131,11 @@ public:
         CV_Assert(inputs[0].dims == outputs[0].dims);
         if (weightShape.dims() == 3)
         {
-            kernel_size.assign(1, kernel_size[0]);
-            strides.assign(1, strides[0]);
-            dilations.assign(1, dilations[0]);
-            pads_begin.assign(1, pads_begin[0]);
-            pads_end.assign(1, pads_end[0]);
+            kernel_size.resize(1, kernel_size[0]);
+            strides.resize(1, strides[0]);
+            dilations.resize(1, dilations[0]);
+            pads_begin.resize(1, pads_begin[0]);
+            pads_end.resize(1, pads_end[0]);
         }
         CV_Assert(weightShape.dims() == kernel_size.size() + 2);
         for (int i = 0; i < kernel_size.size(); i++) {
@@ -428,7 +425,6 @@ public:
     virtual void finalize(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr) CV_OVERRIDE
     {
         BaseConvolutionLayerImpl::finalize(inputs_arr, outputs_arr);
-
         std::vector<Mat> inputs;
         inputs_arr.getMatVector(inputs);
         // prepare weightsMat where each row is aligned and has enough zero padding on the right to
@@ -606,7 +602,8 @@ public:
         if(IS_DNN_CUDA_TARGET(preferableTarget))
         {
             Ptr<EltwiseLayer> eltwise = top.dynamicCast<EltwiseLayer>();
-            if (!eltwise.empty()) // && eltwise->op == EltwiseLayer::SUM && eltwise->coeffs.empty())
+            Ptr<NaryEltwiseLayer> naryEltwise = top.dynamicCast<NaryEltwiseLayer>();
+            if (!eltwise.empty() || !naryEltwise.empty())
             {
                 /* we also need to check that the eltwise input does not require shortcut mechanism
                  * it's difficult to verify it here but we hope that `fuseLayers` has done the check already
@@ -665,68 +662,50 @@ public:
         biasvec[outCn] = biasvec[outCn+1] = biasvec[outCn-1];
     }
 
-    virtual Ptr<BackendNode> initVkCom(const std::vector<Ptr<BackendWrapper> > &inputs) CV_OVERRIDE
+    virtual Ptr<BackendNode> initVkCom(const std::vector<Ptr<BackendWrapper> > &inputs, std::vector<Ptr<BackendWrapper> > &outputs) CV_OVERRIDE
     {
 #ifdef HAVE_VULKAN
-        CV_Assert(!blobs.empty());
-        int out_channel = blobs[0].size[0];
-        bool has_bias = hasBias() || fusedBias;
-        int filter_size[2] = {kernel.height, kernel.width};
-        int pad_size[2] = {pad.height, pad.width};
-        int stride_size[2] = {stride.height, stride.width};
-        int dilation_size[2] = {dilation.height, dilation.width};
-        int activation = 0;
-        vkcom::Tensor input_tensor = VkComTensor(inputs[0]);
-        int in_channel = input_tensor.dimSize(1);
-        int group = in_channel / blobs[0].size[1];
+        int activationType = transFusedActivType(activ);
 
-        // TODO: support group > 1
-        if (group != 1)
+        CV_Assert(inputs.size() == 1 && outputs.size() == 1);
+        Ptr<VkComBackendWrapper> inputWrap = inputs[0].dynamicCast<VkComBackendWrapper>();
+        Ptr<VkComBackendWrapper> outputWrap = outputs[0].dynamicCast<VkComBackendWrapper>();
+        CV_Assert(inputWrap && outputWrap);
+
+        MatShape inpShape = shape(*inputWrap->getMat());
+        MatShape outShape = shape(*outputWrap->getMat());
+
+        CV_Assert(inpShape.size() == 4 && inpShape.size() == outShape.size());
+
+        if (activationType == -1)
+        {
+            CV_LOG_WARNING(NULL, "Unsupported fused Active type in Conv layer!!!");
+            return Ptr<BackendNode>();
+        }
+
+        const int inpGroupCn = blobs[0].size[1];
+        int ngroups = inpShape[1] / inpGroupCn;
+        CV_Assert(outShape[1] % ngroups == 0);
+        if (ngroups != 1)
             return Ptr<BackendNode>();
 
-        int padding_mode;
-        if (padMode.empty())
-        {
-            padding_mode = vkcom::kPaddingModeCaffe;
-        }
-        else if (padMode == "VALID")
-        {
-            padding_mode = vkcom::kPaddingModeValid;
-        }
-        else if (padMode == "SAME")
-        {
-            padding_mode = vkcom::kPaddingModeSame;
-        }
-        else
-            CV_Error(Error::StsError, "Unsupported padding mode " + padMode);
-
-        std::shared_ptr<vkcom::OpBase> op(new vkcom::OpConv(out_channel, has_bias,
-                    filter_size, pad_size,
-                    stride_size, dilation_size,
-                    activation, group,
-                    padding_mode));
-
-        std::vector<Ptr<BackendWrapper> > blobsWrapper;
-
+        Mat weightVK;
         if (fusedWeights)
         {
-            Mat wm;
-            weightsMat.copyTo(wm); // to handle the case of isContinuous() == false
-            wm = wm.reshape(1, blobs[0].dims, blobs[0].size);
-            blobsWrapper.push_back(Ptr<BackendWrapper>(new VkComBackendWrapper(wm)));
+            weightsMat.copyTo(weightVK); // to handle the case of isContinuous() == false
+            weightVK = weightVK.reshape(1, blobs[0].dims, blobs[0].size);
         }
         else
-        {
-            blobsWrapper.push_back(Ptr<BackendWrapper>(new VkComBackendWrapper(blobs[0])));
-        }
+            weightVK = blobs[0];
 
-        if (has_bias)
-        {
-            Mat biasesMat({out_channel}, CV_32F, &biasvec[0]);
-            blobsWrapper.push_back(Ptr<BackendWrapper>(new VkComBackendWrapper(biasesMat)));
-        }
+        CV_Assert(weightVK.isContinuous());
+        CV_Assert(pads_begin.size() == 2);
+        CV_Assert(fusedAdd == false && "Vulkan Backend can not support the Conv_Add optimization.");
+        Ptr<vkcom::OpBase> op(new vkcom::OpConv(weightVK, biasvec, activationType, ngroups, outShape[1], inpShape[1],
+                                                            kernel.height, kernel.width, stride.height, stride.width,
+                                                            dilation.height, dilation.width, pads_begin[1], pads_begin[0]));
 
-        return Ptr<BackendNode>(new VkComBackendNode(inputs, op, blobsWrapper));
+        return Ptr<BackendNode>(new VkComBackendNode(inputs, op, outputs));
 #endif  // HAVE_VULKAN
         return Ptr<BackendNode>();
     }
@@ -781,27 +760,46 @@ public:
     }
 
 #ifdef HAVE_CANN
-    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
+    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputs,
+                                      const std::vector<Ptr<BackendWrapper> > &outputs,
+                                      const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
     {
         CV_Assert(!blobs.empty());
-        CV_Assert(inputsWrapper.size() == 1);
+        CV_Assert(inputs.size() == 1);
         CV_Assert(nodes.size() == 1);
 
         bool has_bias = hasBias() || fusedBias;
 
-        auto x = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
-        const int x_in_channel = x->host->size[1];
+        auto x = inputs[0].dynamicCast<CannBackendWrapper>();
+        const auto shape_x = x->host->size; // [b, c, h, w]
         const int filter_out_channel = blobs[0].size[1];
-        const int groups = x_in_channel / filter_out_channel;
+        const int groups = shape_x[1] / filter_out_channel;
 
         // create operator
-        std::string op_name = cv::format("conv2d_%d", index);
-        auto op = std::make_shared<ge::op::Conv2D>(op_name);
+        auto op = std::make_shared<ge::op::Conv2D>(name);
 
         // set attributes
         op->set_attr_strides(ge::Operator::OpListInt(
             {1, 1, (int64_t)strides[0], (int64_t)strides[1]}
         ));
+        // recalculate pads in case of "SAME" padMode with odd pads
+        // since in 'getConvPoolPaddings' pads are divided equally
+        // leading to the loss of one pad
+        if (padMode == "SAME")
+        {
+            for (int i = 0; i < pads_begin.size(); i++) {
+                if (strides[i] <= kernel_size[i])
+                {
+                    int pads_at_i = kernel_size[i] - 1 - (shape_x[i+2] - 1 + strides[i]) % strides[i];
+                    pads_begin[i] = pads_at_i / 2;
+                    // if odd, add extra padding to the end for SAME_UPPER
+                    // or to the beginning for SAME_LOWER. Since here we cannot
+                    // identity SAME_UPPER and SAME_LOWER, extra padding is always
+                    // added to the end.
+                    pads_end[i] = pads_at_i - pads_begin[i];
+                }
+            }
+        }
         op->set_attr_pads(ge::Operator::OpListInt(
             {(int64_t)pads_begin[1], (int64_t)pads_end[1], (int64_t)pads_begin[0], (int64_t)pads_end[0]}
         ));
@@ -814,12 +812,12 @@ public:
         // set inputs
         // set inputs : x
         auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
-        op->set_input_x_by_name(*op_x, "y");
+        op->set_input_x_by_name(*op_x, x->name.c_str());
         auto x_desc = x->getTensorDesc();
         op->update_input_desc_x(*x_desc);
         // set inputs : weight
         const Mat& w_mat = blobs[0];
-        auto op_const_weight = std::make_shared<CannConstOp>(w_mat.data, w_mat.type(), shape(w_mat), cv::format("%s_w", op_name.c_str()));
+        auto op_const_weight = std::make_shared<CannConstOp>(w_mat.data, w_mat.type(), shape(w_mat), cv::format("%s_w", name.c_str()));
         op->set_input_filter(*(op_const_weight->getOp()));
         op->update_input_desc_filter(*(op_const_weight->getTensorDesc()));
         // set inputs : bias
@@ -829,7 +827,7 @@ public:
             Mat b_mat({out_channel}, CV_32F, &biasvec[0]);
 
             std::vector<int> bias_shape{out_channel};
-            auto op_const_bias = std::make_shared<CannConstOp>(b_mat.data, b_mat.type(), bias_shape, cv::format("%s_b", op_name.c_str()));
+            auto op_const_bias = std::make_shared<CannConstOp>(b_mat.data, b_mat.type(), bias_shape, cv::format("%s_b", name.c_str()));
             op->set_input_bias(*(op_const_bias->getOp()));
             op->update_input_desc_bias(*(op_const_bias->getTensorDesc()));
         }
@@ -1385,7 +1383,8 @@ public:
 
                 CV_Assert(outputs[0].size[1] % ngroups == 0);
                 fastConvImpl = initFastConv(weightsMat, &biasvec[0], ngroups, K, C, kernel_size, strides,
-                                            dilations, pads_begin, pads_end, conv_dim, canUseWinograd);
+                                            dilations, pads_begin, pads_end, conv_dim,
+                                            preferableTarget == DNN_TARGET_CPU_FP16, canUseWinograd);
             }
 
             runFastConv(inputs[0], outputs[0], fastConvImpl, nstripes, activ, reluslope, fusedAdd);
@@ -1592,7 +1591,8 @@ public:
 #endif  // HAVE_INF_ENGINE
         {
             return backendId == DNN_BACKEND_CUDA ||
-            (kernel_size.size() == 2 && (backendId == DNN_BACKEND_OPENCV || backendId == DNN_BACKEND_HALIDE));
+            (kernel_size.size() == 2 && (backendId == DNN_BACKEND_OPENCV || backendId == DNN_BACKEND_HALIDE)) ||
+            (kernel_size.size() == 2 && backendId == DNN_BACKEND_CANN);
         }
     }
 
@@ -2253,6 +2253,79 @@ public:
         return Ptr<BackendNode>();
     }
 
+#ifdef HAVE_CANN
+    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputs,
+                                      const std::vector<Ptr<BackendWrapper> > &outputs,
+                                      const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
+    {
+        CV_Assert(!blobs.empty());
+        CV_Assert(inputs.size() == 1);
+        CV_Assert(nodes.size() == 1);
+
+        bool has_bias = hasBias() || fusedBias;
+
+        auto x = inputs[0].dynamicCast<CannBackendWrapper>();
+        auto y = outputs[0].dynamicCast<CannBackendWrapper>();
+        const auto shape_x = x->host->size; // [N, C, H, W]
+        const auto shape_y = y->host->size; // [N, C, H, W]
+        const int filter_out_channel = blobs[0].size[0];
+        const int groups = shape_x[1] / filter_out_channel;
+
+        // create operator
+        auto op = std::make_shared<ge::op::Conv2DTransposeD>(name);
+
+        // set attributes
+        op->set_attr_input_size(
+            ge::Operator::OpListInt({(int64_t)shape_y[0],
+                                     (int64_t)shape_y[1],
+                                     (int64_t)shape_y[2],
+                                     (int64_t)shape_y[3],})
+        );
+        op->set_attr_strides(
+            ge::Operator::OpListInt({1, 1, (int64_t)strides[0], (int64_t)strides[1]})
+        );
+        op->set_attr_pads(ge::Operator::OpListInt(
+            {(int64_t)pads_begin[1], (int64_t)pads_end[1], (int64_t)pads_begin[0], (int64_t)pads_end[0]}
+        ));
+        op->set_attr_dilations(ge::Operator::OpListInt(
+            {1, 1, (int64_t)dilations[0], (int64_t)dilations[1]}
+        ));
+        op->set_attr_groups(groups);
+        op->set_attr_data_format("NCHW");
+        op->set_attr_output_padding(
+            ge::Operator::OpListInt({0, 0, (int64_t)adjust_pads[0], (int64_t)adjust_pads[1]}) // adjust_pads: [height, width]
+        );
+
+        // set inputs
+        // set inputs : x
+        auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
+        op->set_input_x_by_name(*op_x, x->name.c_str());
+        auto desc_x = x->getTensorDesc();
+        op->update_input_desc_x(*desc_x);
+        // set inputs : weight
+        const Mat& mat_w = blobs[0];
+        auto op_const_w = std::make_shared<CannConstOp>(mat_w.data, mat_w.type(), shape(mat_w), cv::format("%s_w", name.c_str()));
+        op->set_input_filter(*(op_const_w->getOp()));
+        op->update_input_desc_filter(*(op_const_w->getTensorDesc()));
+        // set inputs : bias
+        if (has_bias)
+        {
+            int out_channel = blobs[0].size[0];
+            const Mat& mat_b = blobs[1];
+
+            std::vector<int> shape_b{out_channel};
+            auto op_const_b = std::make_shared<CannConstOp>(mat_b.data, mat_b.type(), shape_b, cv::format("%s_b", name.c_str()));
+            op->set_input_bias(*(op_const_b->getOp()));
+            op->update_input_desc_bias(*(op_const_b->getTensorDesc()));
+        }
+
+        // set outputs
+        auto desc_output = std::make_shared<ge::TensorDesc>(ge::Shape(), ge::FORMAT_NCHW, ge::DT_FLOAT);
+        op->update_output_desc_y(*desc_output);
+
+        return Ptr<BackendNode>(new CannBackendNode(op));
+    }
+#endif // HAVE_CANN
 
 #ifdef HAVE_DNN_NGRAPH
     virtual Ptr<BackendNode> initNgraph(const std::vector<Ptr<BackendWrapper> > &inputs,

modules/dnn/src/layers/cpu_kernels/conv_block.simd.hpp

@@ -0,0 +1,759 @@
+// 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 "opencv2/core/hal/intrin.hpp"
+
+namespace cv {
+namespace dnn {
+CV_CPU_OPTIMIZATION_NAMESPACE_BEGIN
+
+void convBlock(int np, const float* a, const float* b, float* c, int ldc, bool init_c, int width, const int convMR, const int convNR);
+
+#if !defined(CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY) && CV_AVX
+
+#if !CV_FMA3 // AVX workaround
+#undef _mm256_fmadd_ps
+#define _mm256_fmadd_ps(a, b, c) _mm256_add_ps(c, _mm256_mul_ps(a, b))
+#endif
+
+void convBlock(int np, const float* a, const float* b, float* c, int ldc, bool init_c, int width, const int convMR, const int convNR)
+{
+    CV_Assert(convMR == 4 && convNR == 24);
+    __m256 c00 = _mm256_set1_ps(0.f), c01 = c00, c02 = c00;
+    __m256 c10 = c00, c11 = c00, c12 = c00;
+    __m256 c20 = c00, c21 = c00, c22 = c00;
+    __m256 c30 = c00, c31 = c00, c32 = c00;
+
+    __m256 a0 = _mm256_setzero_ps(), a1 = _mm256_setzero_ps();
+    __m256 b0 = _mm256_setzero_ps(), b1 = _mm256_setzero_ps(), b2 = _mm256_setzero_ps();
+
+    if (width > 16)
+    {
+        for (int p = 0; p < np; p++, a += convMR, b += convNR)
+        {
+            a0 = _mm256_set1_ps(a[0]), a1 = _mm256_set1_ps(a[1]);
+            b0 = _mm256_load_ps(b), b1 = _mm256_load_ps(b + 8), b2 = _mm256_load_ps(b + 16);
+
+            c00 = _mm256_fmadd_ps(b0, a0, c00);
+            c01 = _mm256_fmadd_ps(b1, a0, c01);
+            c02 = _mm256_fmadd_ps(b2, a0, c02);
+
+            c10 = _mm256_fmadd_ps(b0, a1, c10);
+            c11 = _mm256_fmadd_ps(b1, a1, c11);
+            c12 = _mm256_fmadd_ps(b2, a1, c12);
+
+            a0 = _mm256_set1_ps(a[2]), a1 = _mm256_set1_ps(a[3]);
+
+            c20 = _mm256_fmadd_ps(b0, a0, c20);
+            c21 = _mm256_fmadd_ps(b1, a0, c21);
+            c22 = _mm256_fmadd_ps(b2, a0, c22);
+
+            c30 = _mm256_fmadd_ps(b0, a1, c30);
+            c31 = _mm256_fmadd_ps(b1, a1, c31);
+            c32 = _mm256_fmadd_ps(b2, a1, c32);
+        }
+    }
+    else if (width > 8)
+    {
+        for (int p = 0; p < np; p++, a += convMR, b += convNR)
+        {
+            a0 = _mm256_set1_ps(a[0]), a1 = _mm256_set1_ps(a[1]);
+            b0 = _mm256_load_ps(b), b1 = _mm256_load_ps(b + 8);
+
+            c00 = _mm256_fmadd_ps(b0, a0, c00);
+            c01 = _mm256_fmadd_ps(b1, a0, c01);
+
+            c10 = _mm256_fmadd_ps(b0, a1, c10);
+            c11 = _mm256_fmadd_ps(b1, a1, c11);
+
+            a0 = _mm256_set1_ps(a[2]), a1 = _mm256_set1_ps(a[3]);
+
+            c20 = _mm256_fmadd_ps(b0, a0, c20);
+            c21 = _mm256_fmadd_ps(b1, a0, c21);
+
+            c30 = _mm256_fmadd_ps(b0, a1, c30);
+            c31 = _mm256_fmadd_ps(b1, a1, c31);
+        }
+    }
+    else
+    {
+        for (int p = 0; p < np; p++, a += convMR, b += convNR)
+        {
+            a0 = _mm256_set1_ps(a[0]), a1 = _mm256_set1_ps(a[1]);
+            b0 = _mm256_load_ps(b);
+
+            c00 = _mm256_fmadd_ps(b0, a0, c00);
+            c10 = _mm256_fmadd_ps(b0, a1, c10);
+
+            a0 = _mm256_set1_ps(a[2]), a1 = _mm256_set1_ps(a[3]);
+
+            c20 = _mm256_fmadd_ps(b0, a0, c20);
+            c30 = _mm256_fmadd_ps(b0, a1, c30);
+        }
+    }
+
+
+
+    if (!init_c)
+    {
+        c00 = _mm256_add_ps(c00, _mm256_load_ps(c));
+        c01 = _mm256_add_ps(c01, _mm256_load_ps(c + 8));
+        c02 = _mm256_add_ps(c02, _mm256_load_ps(c + 16));
+
+        c10 = _mm256_add_ps(c10, _mm256_load_ps(c + ldc));
+        c11 = _mm256_add_ps(c11, _mm256_load_ps(c + ldc + 8));
+        c12 = _mm256_add_ps(c12, _mm256_load_ps(c + ldc + 16));
+
+        c20 = _mm256_add_ps(c20, _mm256_load_ps(c + ldc*2));
+        c21 = _mm256_add_ps(c21, _mm256_load_ps(c + ldc*2 + 8));
+        c22 = _mm256_add_ps(c22, _mm256_load_ps(c + ldc*2 + 16));
+
+        c30 = _mm256_add_ps(c30, _mm256_load_ps(c + ldc*3));
+        c31 = _mm256_add_ps(c31, _mm256_load_ps(c + ldc*3 + 8));
+        c32 = _mm256_add_ps(c32, _mm256_load_ps(c + ldc*3 + 16));
+    }
+
+    _mm256_storeu_ps(c, c00), _mm256_storeu_ps(c+8, c01), _mm256_storeu_ps(c+16, c02);
+    _mm256_storeu_ps(c + ldc, c10), _mm256_storeu_ps(c + ldc + 8, c11), _mm256_storeu_ps(c + ldc + 16, c12);
+    _mm256_storeu_ps(c + ldc*2, c20), _mm256_storeu_ps(c + ldc*2 + 8, c21), _mm256_storeu_ps(c + ldc*2 + 16, c22);
+    _mm256_storeu_ps(c + ldc*3, c30), _mm256_storeu_ps(c + ldc*3 + 8, c31), _mm256_storeu_ps(c + ldc*3 + 16, c32);
+    _mm256_zeroupper();
+}
+
+#endif // CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY
+
+CV_CPU_OPTIMIZATION_NAMESPACE_END
+
+// NEON code work around.
+namespace opt_NEON
+{
+#if !defined(CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY) && CV_NEON
+
+void convBlock(int np, const float* a, const float* b, float* c, int ldc, bool init_c, int width, const int convMR, const int convNR)
+{
+#if CV_NEON_AARCH64
+    if (convMR == 4 && convNR == 28) // AARCH64
+    {
+        float32x4_t c00 = vdupq_n_f32(0.f), c01 = c00, c02 = c00, c03 = c00, c04 = c00, c05 = c00, c06 = c00;
+        float32x4_t c10 = vdupq_n_f32(0.f), c11 = c10, c12 = c10, c13 = c10, c14 = c10, c15 = c10, c16 = c10;
+        float32x4_t c20 = vdupq_n_f32(0.f), c21 = c20, c22 = c20, c23 = c20, c24 = c20, c25 = c20, c26 = c20;
+        float32x4_t c30 = vdupq_n_f32(0.f), c31 = c30, c32 = c30, c33 = c30, c34 = c30, c35 = c30, c36 = c30;
+
+        if (width > 16)
+        {
+            for( int p = 0; p < np; p++, a += convMR, b += convNR )
+            {
+                float32x4_t a0 = vld1q_f32(a), b0, b1, b2;
+                b0 = vld1q_f32(b); b1 = vld1q_f32(b + 4); b2 = vld1q_f32(b + 8);
+
+                c00 = vfmaq_laneq_f32(c00, b0, a0, 0);
+                c01 = vfmaq_laneq_f32(c01, b1, a0, 0);
+                c02 = vfmaq_laneq_f32(c02, b2, a0, 0);
+                c10 = vfmaq_laneq_f32(c10, b0, a0, 1);
+                c11 = vfmaq_laneq_f32(c11, b1, a0, 1);
+                c12 = vfmaq_laneq_f32(c12, b2, a0, 1);
+                c20 = vfmaq_laneq_f32(c20, b0, a0, 2);
+                c21 = vfmaq_laneq_f32(c21, b1, a0, 2);
+                c22 = vfmaq_laneq_f32(c22, b2, a0, 2);
+                c30 = vfmaq_laneq_f32(c30, b0, a0, 3);
+                c31 = vfmaq_laneq_f32(c31, b1, a0, 3);
+                c32 = vfmaq_laneq_f32(c32, b2, a0, 3);
+
+                b0 = vld1q_f32(b + 12); b1 = vld1q_f32(b + 16); b2 = vld1q_f32(b + 20);
+
+                c03 = vfmaq_laneq_f32(c03, b0, a0, 0);
+                c04 = vfmaq_laneq_f32(c04, b1, a0, 0);
+                c05 = vfmaq_laneq_f32(c05, b2, a0, 0);
+                c13 = vfmaq_laneq_f32(c13, b0, a0, 1);
+                c14 = vfmaq_laneq_f32(c14, b1, a0, 1);
+                c15 = vfmaq_laneq_f32(c15, b2, a0, 1);
+                c23 = vfmaq_laneq_f32(c23, b0, a0, 2);
+                c24 = vfmaq_laneq_f32(c24, b1, a0, 2);
+                c25 = vfmaq_laneq_f32(c25, b2, a0, 2);
+                c33 = vfmaq_laneq_f32(c33, b0, a0, 3);
+                c34 = vfmaq_laneq_f32(c34, b1, a0, 3);
+                c35 = vfmaq_laneq_f32(c35, b2, a0, 3);
+
+                b0 = vld1q_f32(b + 24);
+                c06 = vfmaq_laneq_f32(c06, b0, a0, 0);
+                c16 = vfmaq_laneq_f32(c16, b0, a0, 1);
+                c26 = vfmaq_laneq_f32(c26, b0, a0, 2);
+                c36 = vfmaq_laneq_f32(c36, b0, a0, 3);
+            }
+        }
+        else if (width > 8)
+        {
+            for( int p = 0; p < np; p++, a += convMR, b += convNR )
+            {
+                float32x4_t a0 = vld1q_f32(a), b0, b1, b2;
+                b0 = vld1q_f32(b); b1 = vld1q_f32(b + 4); b2 = vld1q_f32(b + 8);
+
+                c00 = vfmaq_laneq_f32(c00, b0, a0, 0);
+                c01 = vfmaq_laneq_f32(c01, b1, a0, 0);
+                c02 = vfmaq_laneq_f32(c02, b2, a0, 0);
+                c10 = vfmaq_laneq_f32(c10, b0, a0, 1);
+                c11 = vfmaq_laneq_f32(c11, b1, a0, 1);
+                c12 = vfmaq_laneq_f32(c12, b2, a0, 1);
+                c20 = vfmaq_laneq_f32(c20, b0, a0, 2);
+                c21 = vfmaq_laneq_f32(c21, b1, a0, 2);
+                c22 = vfmaq_laneq_f32(c22, b2, a0, 2);
+                c30 = vfmaq_laneq_f32(c30, b0, a0, 3);
+                c31 = vfmaq_laneq_f32(c31, b1, a0, 3);
+                c32 = vfmaq_laneq_f32(c32, b2, a0, 3);
+
+                b0 = vld1q_f32(b + 12);
+
+                c03 = vfmaq_laneq_f32(c03, b0, a0, 0);
+                c13 = vfmaq_laneq_f32(c13, b0, a0, 1);
+                c23 = vfmaq_laneq_f32(c23, b0, a0, 2);
+                c33 = vfmaq_laneq_f32(c33, b0, a0, 3);
+            }
+        }
+        else if (width > 4)
+        {
+            for( int p = 0; p < np; p++, a += convMR, b += convNR )
+            {
+                float32x4_t a0 = vld1q_f32(a), b0, b1;
+                b0 = vld1q_f32(b); b1 = vld1q_f32(b + 4);
+
+                c00 = vfmaq_laneq_f32(c00, b0, a0, 0);
+                c01 = vfmaq_laneq_f32(c01, b1, a0, 0);
+                c10 = vfmaq_laneq_f32(c10, b0, a0, 1);
+                c11 = vfmaq_laneq_f32(c11, b1, a0, 1);
+                c20 = vfmaq_laneq_f32(c20, b0, a0, 2);
+                c21 = vfmaq_laneq_f32(c21, b1, a0, 2);
+                c30 = vfmaq_laneq_f32(c30, b0, a0, 3);
+                c31 = vfmaq_laneq_f32(c31, b1, a0, 3);
+            }
+        }
+        else
+        {
+            for( int p = 0; p < np; p++, a += convMR, b += convNR )
+            {
+                float32x4_t a0 = vld1q_f32(a), b0;
+                b0 = vld1q_f32(b);
+
+                c00 = vfmaq_laneq_f32(c00, b0, a0, 0);
+                c10 = vfmaq_laneq_f32(c10, b0, a0, 1);
+                c20 = vfmaq_laneq_f32(c20, b0, a0, 2);
+                c30 = vfmaq_laneq_f32(c30, b0, a0, 3);
+            }
+        }
+
+        if (!init_c)
+        {
+            c00 = vaddq_f32(c00, vld1q_f32(c));
+            c01 = vaddq_f32(c01, vld1q_f32(c + 4));
+            c02 = vaddq_f32(c02, vld1q_f32(c + 8));
+            c03 = vaddq_f32(c03, vld1q_f32(c + 12));
+            c04 = vaddq_f32(c04, vld1q_f32(c + 16));
+            c05 = vaddq_f32(c05, vld1q_f32(c + 20));
+            c06 = vaddq_f32(c06, vld1q_f32(c + 24));
+
+            c10 = vaddq_f32(c10, vld1q_f32(c + ldc));
+            c11 = vaddq_f32(c11, vld1q_f32(c + ldc + 4));
+            c12 = vaddq_f32(c12, vld1q_f32(c + ldc + 8));
+            c13 = vaddq_f32(c13, vld1q_f32(c + ldc + 12));
+            c14 = vaddq_f32(c14, vld1q_f32(c + ldc + 16));
+            c15 = vaddq_f32(c15, vld1q_f32(c + ldc + 20));
+            c16 = vaddq_f32(c16, vld1q_f32(c + ldc + 24));
+
+            c20 = vaddq_f32(c20, vld1q_f32(c + ldc*2));
+            c21 = vaddq_f32(c21, vld1q_f32(c + ldc*2 + 4));
+            c22 = vaddq_f32(c22, vld1q_f32(c + ldc*2 + 8));
+            c23 = vaddq_f32(c23, vld1q_f32(c + ldc*2 + 12));
+            c24 = vaddq_f32(c24, vld1q_f32(c + ldc*2 + 16));
+            c25 = vaddq_f32(c25, vld1q_f32(c + ldc*2 + 20));
+            c26 = vaddq_f32(c26, vld1q_f32(c + ldc*2 + 24));
+
+            c30 = vaddq_f32(c30, vld1q_f32(c + ldc*3));
+            c31 = vaddq_f32(c31, vld1q_f32(c + ldc*3 + 4));
+            c32 = vaddq_f32(c32, vld1q_f32(c + ldc*3 + 8));
+            c33 = vaddq_f32(c33, vld1q_f32(c + ldc*3 + 12));
+            c34 = vaddq_f32(c34, vld1q_f32(c + ldc*3 + 16));
+            c35 = vaddq_f32(c35, vld1q_f32(c + ldc*3 + 20));
+            c36 = vaddq_f32(c36, vld1q_f32(c + ldc*3 + 24));
+        }
+
+        vst1q_f32(c, c00); vst1q_f32(c+4, c01);
+        vst1q_f32(c+8, c02); vst1q_f32(c+12, c03);
+        vst1q_f32(c+16, c04); vst1q_f32(c+20, c05);
+        vst1q_f32(c+24, c06);
+
+        vst1q_f32(c+ldc, c10); vst1q_f32(c+ldc+4, c11);
+        vst1q_f32(c+ldc+8, c12); vst1q_f32(c+ldc+12, c13);
+        vst1q_f32(c+ldc+16, c14); vst1q_f32(c+ldc+20, c15);
+        vst1q_f32(c+ldc+24, c16);
+
+        vst1q_f32(c+ldc*2, c20); vst1q_f32(c+ldc*2+4, c21);
+        vst1q_f32(c+ldc*2+8, c22); vst1q_f32(c+ldc*2+12, c23);
+        vst1q_f32(c+ldc*2+16, c24); vst1q_f32(c+ldc*2+20, c25);
+        vst1q_f32(c+ldc*2+24, c26);
+
+        vst1q_f32(c+ldc*3, c30); vst1q_f32(c+ldc*3+4, c31);
+        vst1q_f32(c+ldc*3+8, c32); vst1q_f32(c+ldc*3+12, c33);
+        vst1q_f32(c+ldc*3+16, c34); vst1q_f32(c+ldc*3+20, c35);
+        vst1q_f32(c+ldc*3+24, c36);
+    }
+    else
+#endif
+    if (convMR == 4 && convNR == 12) // ARMv7
+    {
+        float32x4_t c0 = vdupq_n_f32(0.f), c1 = c0, c2 = c0;
+        float32x4_t c3 = vdupq_n_f32(0.f), c4 = c3, c5 = c3;
+        float32x4_t c6 = vdupq_n_f32(0.f), c7 = c6, c8 = c6;
+        float32x4_t c9 = vdupq_n_f32(0.f), c10 = c9, c11 = c9;
+
+        float32x2_t a0 = vdup_n_f32(0.0f), a1 = a0;
+        float32x4_t b0 = vdupq_n_f32(0.0f), b1 = vdupq_n_f32(0.0f), b2 = vdupq_n_f32(0.0f);
+
+        if (width > 8)
+        {
+            for (int p = 0; p < np; p++, a += convMR, b += convNR)
+            {
+                a0 = vld1_f32(a), a1 = vld1_f32(a+2);
+                b0 = vld1q_f32(b), b1 = vld1q_f32(b + 4), b2 = vld1q_f32(b + 8);
+
+                c0 = vmlaq_lane_f32(c0, b0, a0, 0);
+                c1 = vmlaq_lane_f32(c1, b1, a0, 0);
+                c2 = vmlaq_lane_f32(c2, b2, a0, 0);
+
+                c3 = vmlaq_lane_f32(c3, b0, a0, 1);
+                c4 = vmlaq_lane_f32(c4, b1, a0, 1);
+                c5 = vmlaq_lane_f32(c5, b2, a0, 1);
+
+                c6 = vmlaq_lane_f32(c6, b0, a1, 0);
+                c7 = vmlaq_lane_f32(c7, b1, a1, 0);
+                c8 = vmlaq_lane_f32(c8, b2, a1, 0);
+
+                c9  = vmlaq_lane_f32(c9 , b0, a1, 1);
+                c10 = vmlaq_lane_f32(c10, b1, a1, 1);
+                c11 = vmlaq_lane_f32(c11, b2, a1, 1);
+            }
+        }
+        else if (width > 4)
+        {
+            for (int p = 0; p < np; p++, a += convMR, b += convNR)
+            {
+                a0 = vld1_f32(a), a1 = vld1_f32(a+2);
+                b0 = vld1q_f32(b), b1 = vld1q_f32(b + 4);
+
+                c0 = vmlaq_lane_f32(c0, b0, a0, 0);
+                c1 = vmlaq_lane_f32(c1, b1, a0, 0);
+
+                c3 = vmlaq_lane_f32(c3, b0, a0, 1);
+                c4 = vmlaq_lane_f32(c4, b1, a0, 1);
+
+                c6 = vmlaq_lane_f32(c6, b0, a1, 0);
+                c7 = vmlaq_lane_f32(c7, b1, a1, 0);
+
+                c9  = vmlaq_lane_f32(c9 , b0, a1, 1);
+                c10 = vmlaq_lane_f32(c10, b1, a1, 1);
+            }
+        }
+        else
+        {
+            for (int p = 0; p < np; p++, a += convMR, b += convNR)
+            {
+                a0 = vld1_f32(a), a1 = vld1_f32(a+2);
+                b0 = vld1q_f32(b);
+
+                c0 = vmlaq_lane_f32(c0, b0, a0, 0);
+                c3 = vmlaq_lane_f32(c3, b0, a0, 1);
+                c6 = vmlaq_lane_f32(c6, b0, a1, 0);
+                c9  = vmlaq_lane_f32(c9 , b0, a1, 1);
+            }
+        }
+
+        if (!init_c)
+        {
+            c0 = vaddq_f32(c0, vld1q_f32(c));
+            c1 = vaddq_f32(c1, vld1q_f32(c + 4));
+            c2 = vaddq_f32(c2, vld1q_f32(c + 8));
+
+            c3 = vaddq_f32(c3, vld1q_f32(c + ldc));
+            c4 = vaddq_f32(c4, vld1q_f32(c + ldc + 4));
+            c5 = vaddq_f32(c5, vld1q_f32(c + ldc + 8));
+
+            c6 = vaddq_f32(c6, vld1q_f32(c + ldc * 2));
+            c7 = vaddq_f32(c7, vld1q_f32(c + ldc * 2 + 4));
+            c8 = vaddq_f32(c8, vld1q_f32(c + ldc * 2 + 8));
+
+            c9  = vaddq_f32(c9 , vld1q_f32(c + ldc * 3));
+            c10 = vaddq_f32(c10, vld1q_f32(c + ldc * 3 + 4));
+            c11 = vaddq_f32(c11, vld1q_f32(c + ldc * 3 + 8));
+        }
+
+        vst1q_f32(c, c0), vst1q_f32(c+4, c1), vst1q_f32(c+8, c2);
+        vst1q_f32(c + ldc, c3), vst1q_f32(c + ldc + 4, c4), vst1q_f32(c + ldc + 8, c5);
+        vst1q_f32(c + ldc*2, c6), vst1q_f32(c + ldc*2 + 4, c7), vst1q_f32(c + ldc*2 + 8, c8);
+        vst1q_f32(c + ldc*3, c9), vst1q_f32(c + ldc*3 + 4, c10), vst1q_f32(c + ldc*3 + 8, c11);
+    }
+    else
+        CV_Error(Error::StsNotImplemented, "Unsupported convMR and/or convNR in opt_NEON::convBlock");
+}
+
+void convBlockMR1_F32(int np, const float * a, const float * b, float *c, const float bias, bool init_c,
+                  const float minval, const float maxval, bool ifMinMaxAct, const int width, const int convNR)
+{
+    CV_Assert(convNR == 28);
+    float32x4_t c0 = vdupq_n_f32(bias), c1 = c0, c2 = c0;
+    float32x4_t c3 = c0, c4 = c0, c5 = c0, c6 = c0;
+
+    if (width > 16)
+    {
+        for (int p = 0; p < np; p++, a++, b += convNR)
+        {
+            float32x4_t b0 = vld1q_f32(b), b1 = vld1q_f32(b + 4), b2 = vld1q_f32(b + 8);
+            float32x4_t b3 = vld1q_f32(b + 12), b4 = vld1q_f32(b + 16), b5 = vld1q_f32(b + 20);
+            float32x4_t b6 = vld1q_f32(b + 24);
+
+            c0 = vmlaq_n_f32(c0, b0, a[0]);
+            c1 = vmlaq_n_f32(c1, b1, a[0]);
+            c2 = vmlaq_n_f32(c2, b2, a[0]);
+            c3 = vmlaq_n_f32(c3, b3, a[0]);
+            c4 = vmlaq_n_f32(c4, b4, a[0]);
+            c5 = vmlaq_n_f32(c5, b5, a[0]);
+            c6 = vmlaq_n_f32(c6, b6, a[0]);
+        }
+    }
+    else if (width > 8)
+    {
+        for (int p = 0; p < np; p++, a++, b += convNR)
+        {
+            float32x4_t b0 = vld1q_f32(b), b1 = vld1q_f32(b + 4), b2 = vld1q_f32(b + 8);
+            float32x4_t b3 = vld1q_f32(b + 12);
+
+            c0 = vmlaq_n_f32(c0, b0, a[0]);
+            c1 = vmlaq_n_f32(c1, b1, a[0]);
+            c2 = vmlaq_n_f32(c2, b2, a[0]);
+            c3 = vmlaq_n_f32(c3, b3, a[0]);
+        }
+    }
+    else if (width > 4)
+    {
+        for (int p = 0; p < np; p++, a++, b += convNR)
+        {
+            float32x4_t b0 = vld1q_f32(b), b1 = vld1q_f32(b + 4);
+
+            c0 = vmlaq_n_f32(c0, b0, a[0]);
+            c1 = vmlaq_n_f32(c1, b1, a[0]);
+        }
+    }
+    else
+    {
+        for (int p = 0; p < np; p++, a++, b += convNR)
+        {
+            float32x4_t b0 = vld1q_f32(b);
+            c0 = vmlaq_n_f32(c0, b0, a[0]);
+        }
+    }
+
+    if (init_c)
+    {
+        c0 += vld1q_f32(c);
+        c1 += vld1q_f32(c + 4);
+        c2 += vld1q_f32(c + 8);
+        c3 += vld1q_f32(c + 12);
+        c4 += vld1q_f32(c + 16);
+        c5 += vld1q_f32(c + 20);
+        c6 += vld1q_f32(c + 24);
+    }
+
+    if (ifMinMaxAct)
+    {
+        float32x4_t v_minval = vdupq_n_f32(minval), v_maxval = vdupq_n_f32(maxval);
+
+        c0 = vminq_f32(vmaxq_f32(c0, v_minval), v_maxval);
+        c1 = vminq_f32(vmaxq_f32(c1, v_minval), v_maxval);
+        c2 = vminq_f32(vmaxq_f32(c2, v_minval), v_maxval);
+        c3 = vminq_f32(vmaxq_f32(c3, v_minval), v_maxval);
+        c4 = vminq_f32(vmaxq_f32(c4, v_minval), v_maxval);
+        c5 = vminq_f32(vmaxq_f32(c5, v_minval), v_maxval);
+        c6 = vminq_f32(vmaxq_f32(c6, v_minval), v_maxval);
+    }
+
+    vst1q_f32(c, c0);
+    vst1q_f32(c + 4, c1);
+    vst1q_f32(c + 8, c2);
+    vst1q_f32(c + 12, c3);
+    vst1q_f32(c + 16, c4);
+    vst1q_f32(c + 20, c5);
+    vst1q_f32(c + 24, c6);
+}
+
+#if CV_NEON_AARCH64 && defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)
+// Fix conflict between float16_t in arm_neon.h and float16_t in cvdef.h.
+typedef __fp16 float16_t;
+
+#ifndef __ARM_FEATURE_FMA // Work around without FMA support.
+#define vfmaq_f16(a, b, c) (a + b * c)
+#endif
+void convBlock_FP16(int np, const char * _a, const char * _b, char * _c, int ldc, bool init_c, int width,
+                    const int convMR_fp16, const int convNR_fp16)
+{
+#if 1
+    const float16_t* a = (const float16_t*)_a;
+    const float16_t* b = (const float16_t*)_b;
+    float16_t* c = (float16_t*)_c;
+
+    CV_Assert(convMR_fp16 == 8 && convNR_fp16 == 24);
+
+    float16x8_t c00 = vdupq_n_f16(0), c01 = c00, c02 = c00;
+    float16x8_t c10 = c00, c11 = c00, c12 = c00;
+    float16x8_t c20 = c00, c21 = c00, c22 = c00;
+    float16x8_t c30 = c00, c31 = c00, c32 = c00;
+    float16x8_t c40 = c00, c41 = c00, c42 = c00;
+    float16x8_t c50 = c00, c51 = c00, c52 = c00;
+    float16x8_t c60 = c00, c61 = c00, c62 = c00;
+    float16x8_t c70 = c00, c71 = c00, c72 = c00;
+
+    float16x8_t b0 = c00, b1 = c00, b2 = c00;
+
+    if (width > 16)
+    {
+        for (int p = 0; p < np; p++, a += convMR_fp16, b += convNR_fp16)
+        {
+            float16x4_t a0 = vld1_f16(a), a1 = vld1_f16(a + 4);
+            b0 = vld1q_f16(b), b1 = vld1q_f16(b + 8), b2 = vld1q_f16(b + 16);
+
+            c00 = vfmaq_lane_f16(c00, b0, a0, 0);
+            c01 = vfmaq_lane_f16(c01, b1, a0, 0);
+            c02 = vfmaq_lane_f16(c02, b2, a0, 0);
+
+            c10 = vfmaq_lane_f16(c10, b0, a0, 1);
+            c11 = vfmaq_lane_f16(c11, b1, a0, 1);
+            c12 = vfmaq_lane_f16(c12, b2, a0, 1);
+
+            c20 = vfmaq_lane_f16(c20, b0, a0, 2);
+            c21 = vfmaq_lane_f16(c21, b1, a0, 2);
+            c22 = vfmaq_lane_f16(c22, b2, a0, 2);
+
+            c30 = vfmaq_lane_f16(c30, b0, a0, 3);
+            c31 = vfmaq_lane_f16(c31, b1, a0, 3);
+            c32 = vfmaq_lane_f16(c32, b2, a0, 3);
+
+            c40 = vfmaq_lane_f16(c40, b0, a1, 0);
+            c41 = vfmaq_lane_f16(c41, b1, a1, 0);
+            c42 = vfmaq_lane_f16(c42, b2, a1, 0);
+
+            c50 = vfmaq_lane_f16(c50, b0, a1, 1);
+            c51 = vfmaq_lane_f16(c51, b1, a1, 1);
+            c52 = vfmaq_lane_f16(c52, b2, a1, 1);
+
+            c60 = vfmaq_lane_f16(c60, b0, a1, 2);
+            c61 = vfmaq_lane_f16(c61, b1, a1, 2);
+            c62 = vfmaq_lane_f16(c62, b2, a1, 2);
+
+            c70 = vfmaq_lane_f16(c70, b0, a1, 3);
+            c71 = vfmaq_lane_f16(c71, b1, a1, 3);
+            c72 = vfmaq_lane_f16(c72, b2, a1, 3);
+        }
+    }
+    else if (width > 8)
+    {
+        for( int p = 0; p < np; p++, a += convMR_fp16, b += convNR_fp16)
+        {
+            float16x4_t a0 = vld1_f16(a), a1 = vld1_f16(a + 4);
+            float16x8_t b0 = vld1q_f16(b), b1 = vld1q_f16(b + 8);
+
+            c00 = vfmaq_lane_f16(c00, b0, a0, 0);
+            c01 = vfmaq_lane_f16(c01, b1, a0, 0);
+
+            c10 = vfmaq_lane_f16(c10, b0, a0, 1);
+            c11 = vfmaq_lane_f16(c11, b1, a0, 1);
+
+            c20 = vfmaq_lane_f16(c20, b0, a0, 2);
+            c21 = vfmaq_lane_f16(c21, b1, a0, 2);
+
+            c30 = vfmaq_lane_f16(c30, b0, a0, 3);
+            c31 = vfmaq_lane_f16(c31, b1, a0, 3);
+
+            c40 = vfmaq_lane_f16(c40, b0, a1, 0);
+            c41 = vfmaq_lane_f16(c41, b1, a1, 0);
+
+            c50 = vfmaq_lane_f16(c50, b0, a1, 1);
+            c51 = vfmaq_lane_f16(c51, b1, a1, 1);
+
+            c60 = vfmaq_lane_f16(c60, b0, a1, 2);
+            c61 = vfmaq_lane_f16(c61, b1, a1, 2);
+
+            c70 = vfmaq_lane_f16(c70, b0, a1, 3);
+            c71 = vfmaq_lane_f16(c71, b1, a1, 3);
+        }
+    }
+    else
+    {
+        for( int p = 0; p < np; p++, a += convMR_fp16, b += convNR_fp16)
+        {
+            float16x4_t a0 = vld1_f16(a), a1 = vld1_f16(a + 4);
+            float16x8_t b0 = vld1q_f16(b);
+
+            c00 = vfmaq_lane_f16(c00, b0, a0, 0);
+            c10 = vfmaq_lane_f16(c10, b0, a0, 1);
+            c20 = vfmaq_lane_f16(c20, b0, a0, 2);
+            c30 = vfmaq_lane_f16(c30, b0, a0, 3);
+            c40 = vfmaq_lane_f16(c40, b0, a1, 0);
+            c50 = vfmaq_lane_f16(c50, b0, a1, 1);
+            c60 = vfmaq_lane_f16(c60, b0, a1, 2);
+            c70 = vfmaq_lane_f16(c70, b0, a1, 3);
+        }
+    }
+
+    if (!init_c)
+    {
+#undef _FX_UPDATE_CBUF_ROW
+#define _FX_UPDATE_CBUF_ROW(row) \
+        c##row##0 = c##row##0 + vld1q_f16(c + row*ldc); \
+        c##row##1 = c##row##1 + vld1q_f16(c + row*ldc + 8); \
+        c##row##2 = c##row##2 + vld1q_f16(c + row*ldc + 16)
+
+        _FX_UPDATE_CBUF_ROW(0);
+        _FX_UPDATE_CBUF_ROW(1);
+        _FX_UPDATE_CBUF_ROW(2);
+        _FX_UPDATE_CBUF_ROW(3);
+        _FX_UPDATE_CBUF_ROW(4);
+        _FX_UPDATE_CBUF_ROW(5);
+        _FX_UPDATE_CBUF_ROW(6);
+        _FX_UPDATE_CBUF_ROW(7);
+    }
+
+#undef _FX_STORE_CBUF_ROW
+#define _FX_STORE_CBUF_ROW(row) \
+    vst1q_f16(c + row*ldc, c##row##0); \
+    vst1q_f16(c + row*ldc + 8, c##row##1); \
+    vst1q_f16(c + row*ldc + 16, c##row##2)
+
+    _FX_STORE_CBUF_ROW(0);
+    _FX_STORE_CBUF_ROW(1);
+    _FX_STORE_CBUF_ROW(2);
+    _FX_STORE_CBUF_ROW(3);
+    _FX_STORE_CBUF_ROW(4);
+    _FX_STORE_CBUF_ROW(5);
+    _FX_STORE_CBUF_ROW(6);
+    _FX_STORE_CBUF_ROW(7);
+#else
+    // reference only.
+    const float16_t* a = (const float16_t*)_a;
+    const float16_t* b = (const float16_t*)_b;
+    float16_t* c = (float16_t*)_c;
+    float cbuf[convMR_fp16*convNR_fp16];
+    memset(cbuf, 0, sizeof(cbuf));
+
+    for( int p = 0; p < np; p++ )
+    {
+        for( int i = 0; i < convMR_fp16; i++ )
+        {
+            float ai = float(a[convMR_fp16*p + i]);
+                for( int j = 0; j < convNR_fp16; j++ )
+                    cbuf[i*convNR_fp16+j] += float(b[convNR_fp16*p + j]) * ai;
+        }
+    }
+
+    if (!init_c)
+    {
+    for(int i = 0; i < convMR_fp16; i++)
+        {
+            for(int j = 0; j < convNR_fp16; j++)
+                c[i*ldc + j] = float16_t(float(c[i*ldc + j]) + cbuf[i*convNR_fp16 + j]);
+        }
+    }
+    else
+    {
+        for(int i = 0; i < convMR_fp16; i++)
+        {
+            for(int j = 0; j < convNR_fp16; j++)
+                c[i*ldc + j] = (float16_t)(cbuf[i*convNR_fp16 + j]);
+        }
+    }
+#endif
+}
+
+void convBlockMR1_FP16(int np, const char* _a, const char* _b, float *c, const float _bias, bool init_c,
+                            const float minval, const float maxval, bool ifMinMaxAct, const int width, const int convNR_FP16)
+{
+    CV_Assert(convNR_FP16 == 24); // CONV_NR_FP16 = 24
+    const float16_t* a = (const float16_t*)_a;
+    const float16_t* b = (const float16_t*)_b;
+
+    const float16_t bias = (float16_t)_bias;
+
+    float16x8_t c0 = vdupq_n_f16(bias), c1 = c0, c2 = c0;
+
+    if (width > 16)
+    {
+        for (int p = 0; p < np; p++, a++, b += convNR_FP16)
+        {
+            float16x8_t a0= vdupq_n_f16(a[0]);
+            float16x8_t b0 = vld1q_f16(b), b1 = vld1q_f16(b + 8), b2 = vld1q_f16(b + 16);
+
+            c0 = vfmaq_f16(c0, a0, b0);
+            c1 = vfmaq_f16(c1, a0, b1);
+            c2 = vfmaq_f16(c2, a0, b2);
+        }
+    }
+    else if (width > 8)
+    {
+        for (int p = 0; p < np; p++, a++, b += convNR_FP16)
+        {
+            float16x8_t a0= vdupq_n_f16(a[0]);
+            float16x8_t b0 = vld1q_f16(b), b1 = vld1q_f16(b + 8);
+
+            c0 = vfmaq_f16(c0, a0, b0);
+            c1 = vfmaq_f16(c1, a0, b1);
+        }
+    }
+    else
+    {
+        for (int p = 0; p < np; p++, a++, b += convNR_FP16)
+        {
+            float16x8_t a0= vdupq_n_f16(a[0]);
+            float16x8_t b0 = vld1q_f16(b);
+
+            c0 = vfmaq_f16(c0, a0, b0);
+        }
+    }
+
+    // convert FP 16 to FP 32.
+    float32x4_t c00 = vcvt_f32_f16(vget_low_f16(c0));
+    float32x4_t c01 = vcvt_f32_f16(vget_high_f16(c0));
+    float32x4_t c10 = vcvt_f32_f16(vget_low_f16(c1));
+    float32x4_t c11 = vcvt_f32_f16(vget_high_f16(c1));
+    float32x4_t c20 = vcvt_f32_f16(vget_low_f16(c2));
+    float32x4_t c21 = vcvt_f32_f16(vget_high_f16(c2));
+
+    if (init_c)
+    {
+        c00 += vld1q_f32(c);
+        c01 += vld1q_f32(c + 4);
+        c10 += vld1q_f32(c + 8);
+        c11 += vld1q_f32(c + 12);
+        c20 += vld1q_f32(c + 16);
+        c21 += vld1q_f32(c + 20);
+    }
+
+    if (ifMinMaxAct)
+    {
+        float32x4_t v_minval = vdupq_n_f32(minval), v_maxval = vdupq_n_f32(maxval);
+
+        c00 = vminq_f32(vmaxq_f32(c00, v_minval), v_maxval);
+        c01 = vminq_f32(vmaxq_f32(c01, v_minval), v_maxval);
+        c10 = vminq_f32(vmaxq_f32(c10, v_minval), v_maxval);
+        c11 = vminq_f32(vmaxq_f32(c11, v_minval), v_maxval);
+        c20 = vminq_f32(vmaxq_f32(c20, v_minval), v_maxval);
+        c21 = vminq_f32(vmaxq_f32(c21, v_minval), v_maxval);
+    }
+
+    vst1q_f32(c, c00);
+    vst1q_f32(c + 4, c01);
+    vst1q_f32(c + 8, c10);
+    vst1q_f32(c + 12, c11);
+    vst1q_f32(c + 16, c20);
+    vst1q_f32(c + 20, c21);
+}
+#endif
+
+#endif
+}
+}} // namespace cv::dnn

modules/dnn/src/layers/cpu_kernels/conv_depthwise.cpp

@@ -2,20 +2,147 @@
 // 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.
 
-// This file is modified from the ficus (https://github.com/vpisarev/ficus/blob/master/lib/NN/OpConv.fx).
-// Here is the original license:
-/*
-    This file is a part of ficus language project.
-    See ficus/LICENSE for the licensing terms
-*/
-
 #include "../../precomp.hpp"
-#include "fast_convolution.hpp"
-#include "../layers_common.hpp"
+#include "convolution.hpp"
+
+#include "conv_depthwise.simd.hpp"
+#include "layers/cpu_kernels/conv_depthwise.simd_declarations.hpp" // defines CV_CPU_DISPATCH_MODES_ALL=AVX2,...,BASELINE based on CMakeLists.txt content
 
 namespace cv { namespace dnn {
 
-static void depthWiseBlockConv2D(const float* wptr,
+void depthWiseBlockConv2D(const float* wptr,
+                                 int kernel_h, int kernel_w,
+                                 int stride_h, int stride_w,
+                                 int dilation_h, int dilation_w,
+                                 int pad_t, int pad_l,
+                                 const float* biasptr, const float* relu,
+                                 const float* inptr_,
+                                 int height, int width,
+                                 float* outptr_,
+                                 int out_d, int outH, int outW, bool fusedAdd);
+
+void depthWiseBlockConv1D(const float* wptr,
+                                 int kernel_w, int stride_w, int dilation_w, int pad_l,
+                                 const float* biasptr, const float* relu,
+                                 const float* inptr_, int width,
+                                 float* outptr_,
+                                 int out_d, int outW, bool fusedAdd);
+
+void runDepthwise(InputArray _input, OutputArray _output, const Ptr<FastConv>& conv, ActivationLayer* activ_,
+                  const std::vector<float>& reluslope, bool fusedAdd)
+{
+    Mat input = _input.getMat();
+    Mat output = _output.getMat();
+    MatShape inputShape = shape(input);
+    MatShape outputShape = shape(output);
+
+    CV_Assert(inputShape.size() == 3 || inputShape.size() == 4);
+    CV_Assert(inputShape.size() == outputShape.size());
+
+    int conv_dim = conv->conv_dim;
+    CV_Assert((conv_dim == CONV_2D || conv_dim == CONV_1D) &&
+            "DNN: Currently we do not support depth-wise for Convolution 3D!");
+
+    ActivationLayer* activ = reluslope.empty() ? activ_ : nullptr;
+    int N = inputShape[0], C = inputShape[1];
+
+    int Hi = conv_dim == CONV_1D ? 1 : inputShape[inputShape.size() - 2];
+    int Wi = inputShape[inputShape.size() - 1];
+
+    int K = conv->K, Hk = conv->Hk, Wk = conv->Wk;
+
+    int H0 = conv_dim == CONV_1D ? 1 : outputShape[outputShape.size() - 2];
+    int W0 = outputShape[outputShape.size() - 1];
+    int ngroups = conv->ngroups;
+
+    const size_t inp_planesize = (size_t) Hi * Wi;
+    const size_t out_planesize = (size_t) H0 * W0;
+
+    CV_Assert(ngroups > 1 && ngroups == K && ngroups == C);
+
+    int stride_h = conv->stride_h, stride_w = conv->stride_w;
+    int dilation_h = conv->dilation_h, dilation_w = conv->dilation_w;
+
+    int pad_top = conv->pad_top, pad_bottom = conv->pad_bottom;
+    int pad_left = conv->pad_left, pad_right = conv->pad_right;
+
+    int ksize = Hk * Wk;
+
+    const int VEC_NLANES = 32;
+    int padded_ksize = ((ksize + VEC_NLANES-1) / VEC_NLANES) * VEC_NLANES;
+
+    const float *inp = input.ptr<float>();
+    float *out = output.ptr<float>();
+
+#if CV_TRY_AVX2 || CV_TRY_AVX || CV_TRY_RVV
+    // TODO: remove the following limitation, need change code in conv_depthwise.simd.hpp.
+    bool canRunOpt = Wi >= 16 + dilation_w*(Wk - 1) && !fusedAdd;
+#endif
+    std::vector<int> ofstab_(3 * ksize, 0);
+    int *ofstab = ofstab_.data();
+    int *yxtab = ofstab + ksize;
+
+    for (int k = 0; k < ksize; k++)
+    {
+        int y = k < ksize ? k / Wk : 0;
+        int x = k < ksize ? k % Wk : 0;
+        int dy = y * dilation_h, dx = x * dilation_w;
+        yxtab[k * 2] = dy;
+        yxtab[k * 2 + 1] = dx;
+        ofstab[k] = dy * Wi + dx;
+    }
+
+    const float *weights0 = conv->weightsBufPtr, *bias = conv->biasBuf.data();
+    const float* relu = reluslope.data();
+    CV_Assert(ksize > 1 || (pad_left == 0 && pad_right == 0 && pad_top == 0 && pad_bottom == 0));
+
+    parallel_for_(Range(0, N * C), [&](const Range &r0) {
+    for (int nc = r0.start; nc < r0.end; nc++)
+    {
+        int c = nc % C;
+        const float *inptr0 = inp + inp_planesize * nc;
+        float *outptr0 = out + out_planesize * nc;
+
+        const float *weights = weights0 + c * padded_ksize;
+
+        if (conv_dim == CONV_2D)
+        {
+#if CV_TRY_AVX2
+            if(canRunOpt && conv->useAVX2)
+                opt_AVX2::fastDepthwiseConv(weights, Hk, Wk, stride_h, stride_w, dilation_h, dilation_w,
+                                            pad_top, pad_left, bias, relu, inptr0, Hi, Wi, outptr0, c, H0, W0);
+            else
+#endif
+#if CV_TRY_AVX
+            if(canRunOpt && conv->useAVX)
+                opt_AVX::fastDepthwiseConv(weights, Hk, Wk, stride_h, stride_w, dilation_h, dilation_w,
+                                            pad_top, pad_left, bias, relu, inptr0, Hi, Wi, outptr0, c, H0, W0);
+            else
+#endif
+#if CV_TRY_RVV
+            if(canRunOpt && conv->useRVV)
+                opt_RVV::fastDepthwiseConv(weights, Hk, Wk, stride_h, stride_w, dilation_h, dilation_w,
+                                            pad_top, pad_left, bias, relu, inptr0, Hi, Wi, outptr0, c, H0, W0);
+            else
+#endif
+            depthWiseBlockConv2D(weights, Hk, Wk, stride_h, stride_w, dilation_h, dilation_w,
+                                 pad_top, pad_left, bias, relu, inptr0, Hi, Wi, outptr0, c, H0, W0, fusedAdd);
+        }
+        else // conv_dim == CONV_1D, spatial branch for depth-wise Conv1D.
+        {
+            depthWiseBlockConv1D(weights, Wk, stride_w, dilation_w, pad_left, bias, relu, inptr0, Wi, outptr0, c, W0, fusedAdd);
+        }
+
+        if (activ)
+            activ->forwardSlice(outptr0, outptr0, (int) out_planesize, out_planesize, c, c+1);
+    }});
+}
+
+/****************************************************************************************\
+                                    SIMD and no-SIMD code for depthWiseBlockConv
+\****************************************************************************************/
+
+void depthWiseBlockConv2D(const float* wptr,
                                  int kernel_h, int kernel_w,
                                  int stride_h, int stride_w,
                                  int dilation_h, int dilation_w,
@@ -199,7 +326,7 @@ static void depthWiseBlockConv2D(const float* wptr,
     }
 }
 
-static void depthWiseBlockConv1D(const float* wptr,
+void depthWiseBlockConv1D(const float* wptr,
                                  int kernel_w, int stride_w, int dilation_w, int pad_l,
                                  const float* biasptr, const float* relu,
                                  const float* inptr_, int width,
@@ -332,114 +459,5 @@ static void depthWiseBlockConv1D(const float* wptr,
     }
 }
 
-void runDepthwise(InputArray _input, OutputArray _output, const Ptr<FastConv>& conv, ActivationLayer* activ_,
-                  const std::vector<float>& reluslope, bool fusedAdd)
-{
-    Mat input = _input.getMat();
-    Mat output = _output.getMat();
-    MatShape inputShape = shape(input);
-    MatShape outputShape = shape(output);
-
-    CV_Assert(inputShape.size() == 3 || inputShape.size() == 4);
-    CV_Assert(inputShape.size() == outputShape.size());
-
-    int conv_dim = conv->conv_dim;
-    CV_Assert((conv_dim == CONV_2D || conv_dim == CONV_1D) &&
-            "DNN: Currently we do not support depth-wise for Convolution 3D!");
-
-    ActivationLayer* activ = reluslope.empty() ? activ_ : nullptr;
-    int N = inputShape[0], C = inputShape[1];
-
-    int Hi = conv_dim == CONV_1D ? 1 : inputShape[inputShape.size() - 2];
-    int Wi = inputShape[inputShape.size() - 1];
-
-    int K = conv->K, Hk = conv->Hk, Wk = conv->Wk;
-
-    int H0 = conv_dim == CONV_1D ? 1 : outputShape[outputShape.size() - 2];
-    int W0 = outputShape[outputShape.size() - 1];
-    int ngroups = conv->ngroups;
-
-    const size_t inp_planesize = (size_t) Hi * Wi;
-    const size_t out_planesize = (size_t) H0 * W0;
-
-    CV_Assert(ngroups > 1 && ngroups == K && ngroups == C);
-
-    int stride_h = conv->stride_h, stride_w = conv->stride_w;
-    int dilation_h = conv->dilation_h, dilation_w = conv->dilation_w;
-
-    int pad_top = conv->pad_top, pad_bottom = conv->pad_bottom;
-    int pad_left = conv->pad_left, pad_right = conv->pad_right;
-
-    int ksize = Hk * Wk;
-
-    const int VEC_NLANES = 32;
-    int padded_ksize = ((ksize + VEC_NLANES-1) / VEC_NLANES) * VEC_NLANES;
-
-    const float *inp = input.ptr<float>();
-    float *out = output.ptr<float>();
-
-#if CV_TRY_AVX2 || CV_TRY_AVX || CV_TRY_RVV
-    // TODO: remove the following limitation, need change code in layers_common.simd.hpp.
-    bool canRunOpt = Wi >= 16 + dilation_w*(Wk - 1) && !fusedAdd;
-#endif
-    std::vector<int> ofstab_(3 * ksize, 0);
-    int *ofstab = ofstab_.data();
-    int *yxtab = ofstab + ksize;
-
-    for (int k = 0; k < ksize; k++)
-    {
-        int y = k < ksize ? k / Wk : 0;
-        int x = k < ksize ? k % Wk : 0;
-        int dy = y * dilation_h, dx = x * dilation_w;
-        yxtab[k * 2] = dy;
-        yxtab[k * 2 + 1] = dx;
-        ofstab[k] = dy * Wi + dx;
-    }
-
-    const float *weights0 = conv->weightsBufPtr, *bias = conv->biasBuf.data();
-    const float* relu = reluslope.data();
-    CV_Assert(ksize > 1 || (pad_left == 0 && pad_right == 0 && pad_top == 0 && pad_bottom == 0));
-
-    parallel_for_(Range(0, N * C), [&](const Range &r0) {
-    for (int nc = r0.start; nc < r0.end; nc++)
-    {
-        int c = nc % C;
-        const float *inptr0 = inp + inp_planesize * nc;
-        float *outptr0 = out + out_planesize * nc;
-
-        const float *weights = weights0 + c * padded_ksize;
-
-        if (conv_dim == CONV_2D)
-        {
-#if CV_TRY_AVX2
-            if(canRunOpt && conv->useAVX2)
-                opt_AVX2::fastDepthwiseConv(weights, Hk, Wk, stride_h, stride_w, dilation_h, dilation_w,
-                                            pad_top, pad_left, bias, relu, inptr0, Hi, Wi, outptr0, c, H0, W0);
-            else
-#endif
-#if CV_TRY_AVX
-            if(canRunOpt && conv->useAVX)
-                opt_AVX::fastDepthwiseConv(weights, Hk, Wk, stride_h, stride_w, dilation_h, dilation_w,
-                                            pad_top, pad_left, bias, relu, inptr0, Hi, Wi, outptr0, c, H0, W0);
-            else
-#endif
-#if CV_TRY_RVV
-            if(canRunOpt && conv->useRVV)
-                opt_RVV::fastDepthwiseConv(weights, Hk, Wk, stride_h, stride_w, dilation_h, dilation_w,
-                                            pad_top, pad_left, bias, relu, inptr0, Hi, Wi, outptr0, c, H0, W0);
-            else
-#endif
-            depthWiseBlockConv2D(weights, Hk, Wk, stride_h, stride_w, dilation_h, dilation_w,
-                                 pad_top, pad_left, bias, relu, inptr0, Hi, Wi, outptr0, c, H0, W0, fusedAdd);
-        }
-        else // conv_dim == CONV_1D, spatial branch for depth-wise Conv1D.
-        {
-            depthWiseBlockConv1D(weights, Wk, stride_w, dilation_w, pad_left, bias, relu, inptr0, Wi, outptr0, c, W0, fusedAdd);
-        }
-
-        if (activ)
-            activ->forwardSlice(outptr0, outptr0, (int) out_planesize, out_planesize, c, c+1);
-    }});
-}
 
 }} // namespace cv::dnn

modules/dnn/src/layers/cpu_kernels/conv_depthwise.simd.hpp

@@ -0,0 +1,591 @@
+// 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 "opencv2/core/hal/intrin.hpp"
+
+namespace cv {
+namespace dnn {
+CV_CPU_OPTIMIZATION_NAMESPACE_BEGIN
+
+void fastDepthwiseConv(const float* weights,
+                        int kernel_h, int kernel_w,
+                        int stride_h, int stride_w,
+                        int dilation_h, int dilation_w,
+                        int pad_t, int pad_l,
+                        const float* bias, const float* relu,
+                        const float* inptr,
+                        int height, int width,
+                        float* outptr,
+                        int out_d, int outH, int outW);
+
+#if !defined(CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY) && CV_AVX
+
+#if !CV_FMA3 // AVX workaround
+#undef _mm256_fmadd_ps
+#define _mm256_fmadd_ps(a, b, c) _mm256_add_ps(c, _mm256_mul_ps(a, b))
+#endif
+
+static inline void _mm256_load_deinterleave(const float* ptr, __m256& a, __m256& b)
+{
+    __m256 t0 = _mm256_loadu_ps(ptr);
+    __m256 t1 = _mm256_loadu_ps(ptr + 8);
+
+    __m256 lo = _mm256_permute2f128_ps(t0, t1, 0+2*16);
+    __m256 hi = _mm256_permute2f128_ps(t0, t1, 1+3*16);
+    a = _mm256_shuffle_ps(lo, hi, 0x88);
+    b = _mm256_shuffle_ps(lo, hi, 0xdd);
+}
+
+void fastDepthwiseConv( const float* wptr,
+                     int kernel_h, int kernel_w,
+                     int stride_h, int stride_w,
+                     int dilation_h, int dilation_w,
+                     int pad_t, int pad_l,
+                     const float* biasptr, const float* relu,
+                     const float* inptr_,
+                     int height, int width,
+                     float* outptr_,
+                     int out_d, int outH, int outW )
+{
+    const float w00_ = wptr[0], w01_ = wptr[1], w02_ = wptr[2],
+                w10 = wptr[3], w11 = wptr[4], w12 = wptr[5],
+                w20_ = wptr[6], w21_ = wptr[7], w22_ = wptr[8];
+    int outW1 = min(outW, (width - dilation_w*(kernel_w - 1) + pad_l)/stride_w);
+    float relu_coeff = relu ? relu[out_d] : 1.f, bias = biasptr[out_d];
+
+    for (int out_i = 0; out_i < outH; out_i++)
+    {
+        int in_i = out_i * stride_h - pad_t, out_j = 0;
+        const float* imgptr0 = inptr_ + in_i*width;
+        const float* imgptr1 = imgptr0 + dilation_h*width;
+        const float* imgptr2 = imgptr0 + (dilation_h*2)*width;
+        float out, w00 = w00_, w01 = w01_, w02 = w02_;
+        float w20 = w20_, w21 = w21_, w22 = w22_;
+        if (in_i < 0)
+        {
+            w00 = w01 = w02 = 0.f;
+            imgptr0 = imgptr1;
+        }
+        else if (in_i + dilation_h*(kernel_h-1) >= height)
+        {
+            w20 = w21 = w22 = 0.f;
+            imgptr2 = imgptr1;
+        }
+        float* outptr = outptr_ + out_i*outW;
+        if (pad_l > 0)
+        {
+            out = imgptr0[0]*w01 + imgptr0[dilation_w]*w02 +
+                  imgptr1[0]*w11 + imgptr1[dilation_w]*w12 +
+                  imgptr2[0]*w21 + imgptr2[dilation_w]*w22 + bias;
+            if (relu)
+                out = out > 0.f ? out : out*relu_coeff;
+            outptr[0] = out;
+            out_j = 1;
+        }
+
+        if (stride_w == 1 || (stride_w == 2 && dilation_w == 1))
+        {
+            const int VECSZ = 8;
+            __m256 vw00 = _mm256_set1_ps(w00), vw01 = _mm256_set1_ps(w01), vw02 = _mm256_set1_ps(w02),
+                      vw10 = _mm256_set1_ps(w10), vw11 = _mm256_set1_ps(w11), vw12 = _mm256_set1_ps(w12),
+                      vw20 = _mm256_set1_ps(w20), vw21 = _mm256_set1_ps(w21), vw22 = _mm256_set1_ps(w22);
+            __m256 z = _mm256_setzero_ps(), vbias = _mm256_set1_ps(bias), vrc = _mm256_set1_ps(relu_coeff);
+
+            if( stride_w == 1 )
+                for( ; out_j < outW1; out_j += VECSZ )
+                {
+                    if (out_j + VECSZ > outW1 && out_j > pad_l)
+                        out_j = outW1 - VECSZ;
+                    int in_j = out_j * stride_w - pad_l;
+                    __m256 v00 = _mm256_loadu_ps(imgptr0 + in_j),
+                           v01 = _mm256_loadu_ps(imgptr0 + in_j + dilation_w),
+                           v02 = _mm256_loadu_ps(imgptr0 + in_j + dilation_w*2),
+                           v10 = _mm256_loadu_ps(imgptr1 + in_j),
+                           v11 = _mm256_loadu_ps(imgptr1 + in_j + dilation_w),
+                           v12 = _mm256_loadu_ps(imgptr1 + in_j + dilation_w*2),
+                           v20 = _mm256_loadu_ps(imgptr2 + in_j),
+                           v21 = _mm256_loadu_ps(imgptr2 + in_j + dilation_w),
+                           v22 = _mm256_loadu_ps(imgptr2 + in_j + dilation_w*2);
+
+                    __m256 vout0 = _mm256_fmadd_ps(v00, vw00, vbias);
+                    __m256 vout1 = _mm256_mul_ps(v01, vw01);
+                    __m256 vout2 = _mm256_mul_ps(v02, vw02);
+
+                    vout0 = _mm256_fmadd_ps(v10, vw10, vout0);
+                    vout1 = _mm256_fmadd_ps(v11, vw11, vout1);
+                    vout2 = _mm256_fmadd_ps(v12, vw12, vout2);
+
+                    vout0 = _mm256_fmadd_ps(v20, vw20, vout0);
+                    vout1 = _mm256_fmadd_ps(v21, vw21, vout1);
+                    vout2 = _mm256_fmadd_ps(v22, vw22, vout2);
+
+                    vout0 = _mm256_add_ps(_mm256_add_ps(vout0, vout1), vout2);
+                    if (relu)
+                    {
+                        __m256 m = _mm256_cmp_ps(vout0, z, _CMP_GT_OQ);
+                        vout0 = _mm256_blendv_ps(_mm256_mul_ps(vout0, vrc), vout0, m);
+                    }
+                    _mm256_storeu_ps(outptr + out_j, vout0);
+                }
+            else
+                for( ; out_j < outW1; out_j += VECSZ )
+                {
+                    if (out_j + VECSZ > outW1 && out_j > pad_l)
+                        out_j = outW1 - VECSZ;
+                    int in_j = out_j * stride_w - pad_l;
+                    __m256 v00, v01, v02, v10, v11, v12, v20, v21, v22, unused;
+                    _mm256_load_deinterleave(imgptr0 + in_j, v00, v01);
+                    _mm256_load_deinterleave(imgptr0 + in_j + 2, v02, unused);
+                    _mm256_load_deinterleave(imgptr1 + in_j, v10, v11);
+                    _mm256_load_deinterleave(imgptr1 + in_j + 2, v12, unused);
+                    _mm256_load_deinterleave(imgptr2 + in_j, v20, v21);
+                    _mm256_load_deinterleave(imgptr2 + in_j + 2, v22, unused);
+
+                    __m256 vout0 = _mm256_fmadd_ps(v00, vw00, vbias);
+                    __m256 vout1 = _mm256_mul_ps(v01, vw01);
+                    __m256 vout2 = _mm256_mul_ps(v02, vw02);
+
+                    vout0 = _mm256_fmadd_ps(v10, vw10, vout0);
+                    vout1 = _mm256_fmadd_ps(v11, vw11, vout1);
+                    vout2 = _mm256_fmadd_ps(v12, vw12, vout2);
+
+                    vout0 = _mm256_fmadd_ps(v20, vw20, vout0);
+                    vout1 = _mm256_fmadd_ps(v21, vw21, vout1);
+                    vout2 = _mm256_fmadd_ps(v22, vw22, vout2);
+
+                    vout0 = _mm256_add_ps(_mm256_add_ps(vout0, vout1), vout2);
+                    if (relu)
+                    {
+                        __m256 m = _mm256_cmp_ps(vout0, z, _CMP_GT_OQ);
+                        vout0 = _mm256_blendv_ps(_mm256_mul_ps(vout0, vrc), vout0, m);
+                    }
+                    _mm256_storeu_ps(outptr + out_j, vout0);
+                }
+        }
+
+        for (; out_j < outW1; out_j++)
+        {
+            int in_j = out_j * stride_w - pad_l;
+            out = imgptr0[in_j]*w00 + imgptr0[in_j + dilation_w]*w01 + imgptr0[in_j + dilation_w*2]*w02 +
+                  imgptr1[in_j]*w10 + imgptr1[in_j + dilation_w]*w11 + imgptr1[in_j + dilation_w*2]*w12 +
+                  imgptr2[in_j]*w20 + imgptr2[in_j + dilation_w]*w21 + imgptr2[in_j + dilation_w*2]*w22 + bias;
+            if (relu)
+                out = out > 0.f ? out : out*relu_coeff;
+            outptr[out_j] = out;
+        }
+
+        for (; out_j < outW; out_j++ )
+        {
+            int in_j0 = out_j * stride_w - pad_l, in_j1 = in_j0 + dilation_w, in_j2 = in_j0 + dilation_w*2;
+            float s0 = 1.f, s1 = 1.f, s2 = 1.f;
+            if (in_j0 >= width)
+            {
+                in_j0 = 0;
+                s0 = 0.f;
+            }
+            if (in_j1 >= width)
+            {
+                in_j1 = 0;
+                s1 = 0.f;
+            }
+            if (in_j2 >= width)
+            {
+                in_j2 = 0;
+                s2 = 0.f;
+            }
+            out = imgptr0[in_j0]*w00*s0 + imgptr0[in_j1]*w01*s1 + imgptr0[in_j2]*w02*s2 +
+                  imgptr1[in_j0]*w10*s0 + imgptr1[in_j1]*w11*s1 + imgptr1[in_j2]*w12*s2 +
+                  imgptr2[in_j0]*w20*s0 + imgptr2[in_j1]*w21*s1 + imgptr2[in_j2]*w22*s2 + bias;
+            if (relu)
+                out = out > 0.f ? out : out*relu_coeff;
+            outptr[out_j] = out;
+        }
+    }
+    _mm256_zeroupper();
+}
+
+#endif // CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY
+
+#if !defined(CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY) && CV_RVV
+
+/*
+Example for load_deinterleave:
+    input: ptr[16] = {1,2,3, ... ,14,15,16}
+    output: a = {1, 3, 5, 7, 9, 11, 13, 15}
+    output: b = {2, 4, 6, 8,10, 12, 14, 16}
+*/
+static inline void vfloat32m2_load_deinterleave(const float* ptr, vfloat32m2_t& a, vfloat32m2_t& b, int vl)
+{
+    vuint64m4_t mask = vmv_v_x_u64m4(1,vl*2);
+    vuint32m4_t mask_re = vreinterpret_v_u64m4_u32m4(mask);
+    vbool8_t mask0 = vmseq_vx_u32m4_b8 (mask_re, 1, vl*2);
+    vbool8_t mask1 = vmseq_vx_u32m4_b8 (mask_re, 0, vl*2);
+    vfloat32m4_t tempa = vundefined_f32m4(), tempb = vundefined_f32m4();
+    vfloat32m4_t vw = vle32_v_f32m4(ptr, vl*2);
+    tempa = vcompress_vm_f32m4(mask0, tempa, vw, vl*2);
+    tempb = vcompress_vm_f32m4(mask1, tempb, vw, vl*2);
+    /* The following instructions have not to be supported by the GNU toolchain.
+       So we temporarily use store and load instead.
+    // a = vlmul_trunc_v_f32m4_f32m2(tempa);
+    // b = vlmul_trunc_v_f32m4_f32m2(tempb);
+    */
+    cv::AutoBuffer<float> cvBuffer(sizeof(float)*vl*2);
+    float* buffer = (float*)cvBuffer.data();
+    vse32_v_f32m4(buffer, tempa, vl);
+    a = vle32_v_f32m2(buffer, vl);
+    vse32_v_f32m4(buffer, tempb, vl);
+    b = vle32_v_f32m2(buffer, vl);
+}
+
+void fastDepthwiseConv( const float* wptr,
+                     int kernel_h, int kernel_w,
+                     int stride_h, int stride_w,
+                     int dilation_h, int dilation_w,
+                     int pad_t, int pad_l,
+                     const float* biasptr, const float* relu,
+                     const float* inptr_,
+                     int height, int width,
+                     float* outptr_,
+                     int out_d, int outH, int outW )
+{
+    int vl;
+    const float w00_ = wptr[0], w01_ = wptr[1], w02_ = wptr[2],
+                w10 = wptr[3], w11 = wptr[4], w12 = wptr[5],
+                w20_ = wptr[6], w21_ = wptr[7], w22_ = wptr[8];
+    int outW1 = std::min(outW, (width - dilation_w*(kernel_w - 1) + pad_l)/stride_w);
+    float relu_coeff = relu ? relu[out_d] : 1.f, bias = biasptr[out_d];
+
+    for (int out_i = 0; out_i < outH; out_i++)
+    {
+        int in_i = out_i * stride_h - pad_t, out_j = 0;
+        const float* imgptr0 = inptr_ + in_i*width;
+        const float* imgptr1 = imgptr0 + dilation_h*width;
+        const float* imgptr2 = imgptr0 + (dilation_h*2)*width;
+        float out, w00 = w00_, w01 = w01_, w02 = w02_;
+        float w20 = w20_, w21 = w21_, w22 = w22_;
+        if (in_i < 0)
+        {
+            w00 = w01 = w02 = 0.f;
+            imgptr0 = imgptr1;
+        }
+        else if (in_i + dilation_h*(kernel_h-1) >= height)
+        {
+            w20 = w21 = w22 = 0.f;
+            imgptr2 = imgptr1;
+        }
+        float* outptr = outptr_ + out_i*outW;
+        if (pad_l > 0)
+        {
+            out = imgptr0[0]*w01 + imgptr0[dilation_w]*w02 +
+                  imgptr1[0]*w11 + imgptr1[dilation_w]*w12 +
+                  imgptr2[0]*w21 + imgptr2[dilation_w]*w22 + bias;
+            if (relu)
+                out = out > 0.f ? out : out*relu_coeff;
+            outptr[0] = out;
+            out_j = 1;
+        }
+
+        if (stride_w == 1 || (stride_w == 2 && dilation_w == 1))
+        {
+            int avl = outW1 - out_j;
+            if( stride_w == 1 )
+                for( ; out_j < outW1; out_j += vl, avl -= vl)
+                {
+                    vl = vsetvl_e32m2(avl);
+                    int in_j = out_j * stride_w - pad_l;
+                    vfloat32m2_t v00 = vle32_v_f32m2(imgptr0 + in_j, vl),
+                           v01 = vle32_v_f32m2(imgptr0 + in_j + dilation_w, vl),
+                           v02 = vle32_v_f32m2(imgptr0 + in_j + dilation_w*2, vl),
+                           v10 = vle32_v_f32m2(imgptr1 + in_j, vl),
+                           v11 = vle32_v_f32m2(imgptr1 + in_j + dilation_w, vl),
+                           v12 = vle32_v_f32m2(imgptr1 + in_j + dilation_w*2, vl),
+                           v20 = vle32_v_f32m2(imgptr2 + in_j, vl),
+                           v21 = vle32_v_f32m2(imgptr2 + in_j + dilation_w, vl),
+                           v22 = vle32_v_f32m2(imgptr2 + in_j + dilation_w*2, vl);
+
+                    vfloat32m2_t vout0 = vfmul_vf_f32m2(v00, w00, vl);
+                    vfloat32m2_t vout1 = vfmul_vf_f32m2(v01, w01, vl);
+                    vfloat32m2_t vout2 = vfmul_vf_f32m2(v02, w02, vl);
+                    vout0 = vfadd_vf_f32m2(vout0, bias, vl);
+
+                    vout0 = vfmacc_vf_f32m2(vout0, w10, v10, vl);
+                    vout1 = vfmacc_vf_f32m2(vout1, w11, v11, vl);
+                    vout2 = vfmacc_vf_f32m2(vout2, w12, v12, vl);
+
+                    vout0 = vfmacc_vf_f32m2(vout0, w20, v20, vl);
+                    vout1 = vfmacc_vf_f32m2(vout1, w21, v21, vl);
+                    vout2 = vfmacc_vf_f32m2(vout2, w22, v22, vl);
+
+                    vout0 = vfadd_vv_f32m2(vfadd_vv_f32m2(vout0, vout1, vl), vout2, vl);
+                    if (relu)
+                    {
+                        vbool16_t m = vmfgt_vf_f32m2_b16(vout0, 0, vl);
+                        vout0 = vmerge_vvm_f32m2(m, vfmul_vf_f32m2(vout0, relu_coeff, vl), vout0, vl);
+                    }
+                    vse32_v_f32m2(outptr + out_j, vout0, vl);
+                }
+            else //stride_w == 2 && dilation_w == 1
+                for( ; out_j < outW1; out_j += vl, avl -= vl)
+                {
+                    vl = vsetvl_e32m2(avl);
+                    int in_j = out_j * stride_w - pad_l;
+                    vfloat32m2_t v00, v01, v02, v10, v11, v12, v20, v21, v22, unused;
+                    vfloat32m2_load_deinterleave(imgptr0 + in_j, v00, v01, vl);
+                    vfloat32m2_load_deinterleave(imgptr0 + in_j + 2, v02, unused, vl);
+                    vfloat32m2_load_deinterleave(imgptr1 + in_j, v10, v11, vl);
+                    vfloat32m2_load_deinterleave(imgptr1 + in_j + 2, v12, unused, vl);
+                    vfloat32m2_load_deinterleave(imgptr2 + in_j, v20, v21, vl);
+                    vfloat32m2_load_deinterleave(imgptr2 + in_j + 2, v22, unused, vl);
+
+                    vfloat32m2_t vout0 = vfmul_vf_f32m2(v00, w00, vl);
+                    vfloat32m2_t vout1 = vfmul_vf_f32m2(v01, w01, vl);
+                    vfloat32m2_t vout2 = vfmul_vf_f32m2(v02, w02, vl);
+                    vout0 = vfadd_vf_f32m2(vout0, bias, vl);
+
+                    vout0 = vfmacc_vf_f32m2(vout0, w10, v10, vl);
+                    vout1 = vfmacc_vf_f32m2(vout1, w11, v11, vl);
+                    vout2 = vfmacc_vf_f32m2(vout2, w12, v12, vl);
+
+                    vout0 = vfmacc_vf_f32m2(vout0, w20, v20, vl);
+                    vout1 = vfmacc_vf_f32m2(vout1, w21, v21, vl);
+                    vout2 = vfmacc_vf_f32m2(vout2, w22, v22, vl);
+
+                    vout0 = vfadd_vv_f32m2(vfadd_vv_f32m2(vout0, vout1, vl), vout2, vl);
+                    if (relu)
+                    {
+                        vbool16_t m = vmfgt_vf_f32m2_b16(vout0, 0, vl);
+                        vout0 = vmerge_vvm_f32m2(m, vfmul_vf_f32m2(vout0, relu_coeff, vl), vout0, vl);
+                    }
+                    vse32_v_f32m2(outptr + out_j, vout0, vl);
+                }
+        }
+
+        for (; out_j < outW1; out_j++)
+        {
+            int in_j = out_j * stride_w - pad_l;
+            out = imgptr0[in_j]*w00 + imgptr0[in_j + dilation_w]*w01 + imgptr0[in_j + dilation_w*2]*w02 +
+                  imgptr1[in_j]*w10 + imgptr1[in_j + dilation_w]*w11 + imgptr1[in_j + dilation_w*2]*w12 +
+                  imgptr2[in_j]*w20 + imgptr2[in_j + dilation_w]*w21 + imgptr2[in_j + dilation_w*2]*w22 + bias;
+            if (relu)
+                out = out > 0.f ? out : out*relu_coeff;
+            outptr[out_j] = out;
+        }
+
+        for (; out_j < outW; out_j++ )
+        {
+            int in_j0 = out_j * stride_w - pad_l, in_j1 = in_j0 + dilation_w, in_j2 = in_j0 + dilation_w*2;
+            float s0 = 1.f, s1 = 1.f, s2 = 1.f;
+            if (in_j0 >= width)
+            {
+                in_j0 = 0;
+                s0 = 0.f;
+            }
+            if (in_j1 >= width)
+            {
+                in_j1 = 0;
+                s1 = 0.f;
+            }
+            if (in_j2 >= width)
+            {
+                in_j2 = 0;
+                s2 = 0.f;
+            }
+            out = imgptr0[in_j0]*w00*s0 + imgptr0[in_j1]*w01*s1 + imgptr0[in_j2]*w02*s2 +
+                  imgptr1[in_j0]*w10*s0 + imgptr1[in_j1]*w11*s1 + imgptr1[in_j2]*w12*s2 +
+                  imgptr2[in_j0]*w20*s0 + imgptr2[in_j1]*w21*s1 + imgptr2[in_j2]*w22*s2 + bias;
+            if (relu)
+                out = out > 0.f ? out : out*relu_coeff;
+            outptr[out_j] = out;
+        }
+    }
+}
+
+#endif // CV_RVV
+
+#if !defined(CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY) && CV_LASX
+
+static inline void _v256_load_deinterleave(const float* ptr, __m256& a, __m256& b)
+{
+    __m256 t0 = (__m256)__lasx_xvld(ptr, 0);
+    __m256 t1 = (__m256)__lasx_xvld(ptr, 8*4);
+
+    __m256 lo = (__m256)__lasx_xvpermi_q(t0, t1, 2+0*16);
+    __m256 hi = (__m256)__lasx_xvpermi_q(t0, t1, 3+1*16);
+
+    a = (__m256)__lasx_xvpermi_w(hi, lo, 0x88);
+    b = (__m256)__lasx_xvpermi_w(hi, lo, 0xdd);
+}
+
+void fastDepthwiseConv( const float* wptr,
+                     int kernel_h, int kernel_w,
+                     int stride_h, int stride_w,
+                     int dilation_h, int dilation_w,
+                     int pad_t, int pad_l,
+                     const float* biasptr, const float* relu,
+                     const float* inptr_,
+                     int height, int width,
+                     float* outptr_,
+                     int out_d, int outH, int outW )
+{
+    const float w00_ = wptr[0], w01_ = wptr[1], w02_ = wptr[2],
+                w10 = wptr[3], w11 = wptr[4], w12 = wptr[5],
+                w20_ = wptr[6], w21_ = wptr[7], w22_ = wptr[8];
+    int outW1 = min(outW, (width - dilation_w*(kernel_w - 1) + pad_l)/stride_w);
+    float relu_coeff = relu ? relu[out_d] : 1.f, bias = biasptr[out_d];
+
+    for (int out_i = 0; out_i < outH; out_i++)
+    {
+        int in_i = out_i * stride_h - pad_t, out_j = 0;
+        const float* imgptr0 = inptr_ + in_i*width;
+        const float* imgptr1 = imgptr0 + dilation_h*width;
+        const float* imgptr2 = imgptr0 + (dilation_h*2)*width;
+        float out, w00 = w00_, w01 = w01_, w02 = w02_;
+        float w20 = w20_, w21 = w21_, w22 = w22_;
+        if (in_i < 0)
+        {
+            w00 = w01 = w02 = 0.f;
+            imgptr0 = imgptr1;
+        }
+        else if (in_i + dilation_h*(kernel_h-1) >= height)
+        {
+            w20 = w21 = w22 = 0.f;
+            imgptr2 = imgptr1;
+        }
+        float* outptr = outptr_ + out_i*outW;
+        if (pad_l > 0)
+        {
+            out = imgptr0[0]*w01 + imgptr0[dilation_w]*w02 +
+                  imgptr1[0]*w11 + imgptr1[dilation_w]*w12 +
+                  imgptr2[0]*w21 + imgptr2[dilation_w]*w22 + bias;
+            if (relu)
+                out = out > 0.f ? out : out*relu_coeff;
+            outptr[0] = out;
+            out_j = 1;
+        }
+
+        if (stride_w == 1 || (stride_w == 2 && dilation_w == 1))
+        {
+            const int VECSZ = 8;
+            __m256 vw00 = _v256_setall_ps(w00), vw01 = _v256_setall_ps(w01), vw02 = _v256_setall_ps(w02),
+                   vw10 = _v256_setall_ps(w10), vw11 = _v256_setall_ps(w11), vw12 = _v256_setall_ps(w12),
+                   vw20 = _v256_setall_ps(w20), vw21 = _v256_setall_ps(w21), vw22 = _v256_setall_ps(w22);
+            __m256 z = (__m256)__lasx_xvxor_v((__m256i)vw00, (__m256i)vw00),
+            vbias = _v256_setall_ps(bias), vrc = _v256_setall_ps(relu_coeff);
+
+            if( stride_w == 1 )
+                for( ; out_j < outW1; out_j += VECSZ )
+                {
+                    if (out_j + VECSZ > outW1 && out_j > pad_l)
+                        out_j = outW1 - VECSZ;
+                    int in_j = out_j * stride_w - pad_l;
+                    __m256 v00 = (__m256)__lasx_xvld(imgptr0 + in_j, 0),
+                           v01 = (__m256)__lasx_xvld(imgptr0 + in_j + dilation_w, 0),
+                           v02 = (__m256)__lasx_xvld(imgptr0 + in_j + dilation_w*2, 0),
+                           v10 = (__m256)__lasx_xvld(imgptr1 + in_j, 0),
+                           v11 = (__m256)__lasx_xvld(imgptr1 + in_j + dilation_w, 0),
+                           v12 = (__m256)__lasx_xvld(imgptr1 + in_j + dilation_w*2, 0),
+                           v20 = (__m256)__lasx_xvld(imgptr2 + in_j, 0),
+                           v21 = (__m256)__lasx_xvld(imgptr2 + in_j + dilation_w, 0),
+                           v22 = (__m256)__lasx_xvld(imgptr2 + in_j + dilation_w*2, 0);
+
+                    __m256 vout0 = __lasx_xvfmadd_s(v00, vw00, vbias);
+                    __m256 vout1 = __lasx_xvfmul_s(v01, vw01);
+                    __m256 vout2 = __lasx_xvfmul_s(v02, vw02);
+
+                    vout0 = __lasx_xvfmadd_s(v10, vw10, vout0);
+                    vout1 = __lasx_xvfmadd_s(v11, vw11, vout1);
+                    vout2 = __lasx_xvfmadd_s(v12, vw12, vout2);
+
+                    vout0 = __lasx_xvfmadd_s(v20, vw20, vout0);
+                    vout1 = __lasx_xvfmadd_s(v21, vw21, vout1);
+                    vout2 = __lasx_xvfmadd_s(v22, vw22, vout2);
+
+                    vout0 = __lasx_xvfadd_s(__lasx_xvfadd_s(vout0, vout1), vout2);
+                    if (relu)
+                    {
+                        __m256i m = __lasx_xvfcmp_clt_s(z, vout0);
+                        vout0 = (__m256)__lasx_xvbitsel_v((__m256i)__lasx_xvfmul_s(vout0, vrc), (__m256i)vout0, m);
+                    }
+                    __lasx_xvst(vout0, outptr + out_j, 0);
+                }
+            else
+                for( ; out_j < outW1; out_j += VECSZ )
+                {
+                    if (out_j + VECSZ > outW1 && out_j > pad_l)
+                        out_j = outW1 - VECSZ;
+                    int in_j = out_j * stride_w - pad_l;
+                    __m256 v00, v01, v02, v10, v11, v12, v20, v21, v22, unused;
+                    _v256_load_deinterleave(imgptr0 + in_j, v00, v01);
+                    _v256_load_deinterleave(imgptr0 + in_j + 2, v02, unused);
+                    _v256_load_deinterleave(imgptr1 + in_j, v10, v11);
+                    _v256_load_deinterleave(imgptr1 + in_j + 2, v12, unused);
+                    _v256_load_deinterleave(imgptr2 + in_j, v20, v21);
+                    _v256_load_deinterleave(imgptr2 + in_j + 2, v22, unused);
+
+                    __m256 vout0 = __lasx_xvfmadd_s(v00, vw00, vbias);
+                    __m256 vout1 = __lasx_xvfmul_s(v01, vw01);
+                    __m256 vout2 = __lasx_xvfmul_s(v02, vw02);
+
+                    vout0 = __lasx_xvfmadd_s(v10, vw10, vout0);
+                    vout1 = __lasx_xvfmadd_s(v11, vw11, vout1);
+                    vout2 = __lasx_xvfmadd_s(v12, vw12, vout2);
+
+                    vout0 = __lasx_xvfmadd_s(v20, vw20, vout0);
+                    vout1 = __lasx_xvfmadd_s(v21, vw21, vout1);
+                    vout2 = __lasx_xvfmadd_s(v22, vw22, vout2);
+
+                    vout0 = __lasx_xvfadd_s(__lasx_xvfadd_s(vout0, vout1), vout2);
+                    if (relu)
+                    {
+                        __m256i m = __lasx_xvfcmp_clt_s(z, vout0);
+                        vout0 = (__m256)__lasx_xvbitsel_v((__m256i)__lasx_xvfmul_s(vout0, vrc), (__m256i)vout0, m);
+                    }
+                    __lasx_xvst(vout0, outptr + out_j, 0);
+                }
+        }
+
+        for (; out_j < outW1; out_j++)
+        {
+            int in_j = out_j * stride_w - pad_l;
+            out = imgptr0[in_j]*w00 + imgptr0[in_j + dilation_w]*w01 + imgptr0[in_j + dilation_w*2]*w02 +
+                  imgptr1[in_j]*w10 + imgptr1[in_j + dilation_w]*w11 + imgptr1[in_j + dilation_w*2]*w12 +
+                  imgptr2[in_j]*w20 + imgptr2[in_j + dilation_w]*w21 + imgptr2[in_j + dilation_w*2]*w22 + bias;
+            if (relu)
+                out = out > 0.f ? out : out*relu_coeff;
+            outptr[out_j] = out;
+        }
+
+        for (; out_j < outW; out_j++ )
+        {
+            int in_j0 = out_j * stride_w - pad_l, in_j1 = in_j0 + dilation_w, in_j2 = in_j0 + dilation_w*2;
+            float s0 = 1.f, s1 = 1.f, s2 = 1.f;
+            if (in_j0 >= width)
+            {
+                in_j0 = 0;
+                s0 = 0.f;
+            }
+            if (in_j1 >= width)
+            {
+                in_j1 = 0;
+                s1 = 0.f;
+            }
+            if (in_j2 >= width)
+            {
+                in_j2 = 0;
+                s2 = 0.f;
+            }
+            out = imgptr0[in_j0]*w00*s0 + imgptr0[in_j1]*w01*s1 + imgptr0[in_j2]*w02*s2 +
+                  imgptr1[in_j0]*w10*s0 + imgptr1[in_j1]*w11*s1 + imgptr1[in_j2]*w12*s2 +
+                  imgptr2[in_j0]*w20*s0 + imgptr2[in_j1]*w21*s1 + imgptr2[in_j2]*w22*s2 + bias;
+            if (relu)
+                out = out > 0.f ? out : out*relu_coeff;
+            outptr[out_j] = out;
+        }
+    }
+}
+
+#endif // CV_LASX
+
+CV_CPU_OPTIMIZATION_NAMESPACE_END
+}} // namespace

modules/dnn/src/layers/cpu_kernels/conv_winograd_f63.cpp

@@ -0,0 +1,733 @@
+// 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.
+
+// This file is modified from the ficus (https://github.com/vpisarev/ficus/blob/master/lib/NN/OpConv_Winograd.fx).
+// Here is the original license:
+/*
+    This file is a part of ficus language project.
+    See ficus/LICENSE for the licensing terms
+*/
+
+#include "../../precomp.hpp"
+#include "convolution.hpp"
+
+#include "conv_winograd_f63.simd.hpp"
+#include "layers/cpu_kernels/conv_winograd_f63.simd_declarations.hpp" // defines CV_CPU_DISPATCH_MODES_ALL=AVX2,...,BASELINE based on CMakeLists.txt content
+
+namespace cv { namespace dnn {
+
+#if CV_NEON || CV_SIMD128 || CV_TRY_AVX2
+enum { VEC_ALIGN = 32, DFT_TYPE = CV_32F }; // Memory alignment.
+
+void winofunc_accum_f32(const float* inwptr, const float* wptr, float* outbuf, int Cg, int iblock,
+                            const int winoIblock, const int winoKblock, const int winoAtomF32, const int winoNatomF32);
+
+/*Input transform*/
+void winofunc_BtXB_8x8_f32(const float* inptr, int inpstep,
+                          float* outptr, int Cg, const int winoIblock, const int winoAtomF32);
+
+/*Output transform*/
+void winofunc_AtXA_8x8_f32(const float* inptr, int inpstep, float* bpptr, int bpstep, float* outptr, int outstep,
+                          float bias, float minval, float maxval, bool ifMinMaxAct);
+
+
+int runWinograd63(InputArray _input, InputArray _fusedAddMat, OutputArray _output, const Ptr<FastConv>& conv,
+                  int ntasks, float minval, float maxval, ActivationLayer* activ, bool ifMinMaxAct)
+{
+    Mat input = _input.getMat();
+    Mat output = _output.getMat();
+    Mat fusedAddMat = _fusedAddMat.getMat();
+
+    MatShape inputShape = shape(input);
+    MatShape outputShape = shape(output);
+    CV_Assert(inputShape.size() == 4 && outputShape.size() == 4);
+
+    int N = inputShape[0], C = inputShape[1], Hi = inputShape[2], Wi = inputShape[3];  // [N, C, H, W]
+    int K = conv->K;
+    int H0 = outputShape[2], W0 = outputShape[3];
+
+    int pad_top = conv->pad_top;
+    int pad_left = conv->pad_left;
+
+    int ngroups = conv->ngroups, Cg = C/ngroups, Kg = K/ngroups;
+    int Kg_nblocks = (Kg + CONV_WINO_KBLOCK - 1)/CONV_WINO_KBLOCK;
+    const size_t inp_planesize = (size_t)Hi*Wi;
+    const size_t out_planesize = (size_t)H0*W0;
+
+    int blocks_per_row = (W0+CONV_WINO_STEP-1)/CONV_WINO_STEP;
+    int blocks_per_plane = ((H0+CONV_WINO_STEP-1)/CONV_WINO_STEP)*blocks_per_row;
+    int blocks_per_plane_aligned = ((blocks_per_plane +
+                                     CONV_WINO_IBLOCK-1)/CONV_WINO_IBLOCK)*CONV_WINO_IBLOCK;
+
+    size_t totalbufsize = (size_t)N*C*blocks_per_plane_aligned*CONV_WINO_AREA;
+
+    AutoBuffer<float> _buf;
+    _buf.allocate(totalbufsize + VEC_ALIGN);
+    float* wbuf_all = alignPtr(_buf.data(), VEC_ALIGN);
+
+    float* inp = input.ptr<float>();
+    float* out = output.ptr<float>();
+
+    float* fusedAddPtr = fusedAddMat.empty() ? nullptr : fusedAddMat.ptr<float>();
+
+    // Phase 1. compute forward Winograd transforms for all input blocks,
+    // all input planes, all samples in the batch.
+    // [TODO]: maybe, if there are too many input channels, it makes sense to
+    // transform only part of input channels at once and then compute the partial
+    // accumulated sums (i.e. update the output buffers several times,
+    // rather than compute them in one pass).
+    parallel_for_(Range(0, ntasks), [&](const Range& r0) {
+    for (int task_id = r0.start; task_id < r0.end; task_id++)
+    {
+        int nc0 = (N*C)*task_id/ntasks;
+        int nc1 = (N*C)*(task_id+1)/ntasks;
+        for(; nc0 < nc1; nc0++)
+        {
+            int n = nc0 / C;
+            int c = nc0 - n*C;
+            int g = c / Cg;
+            c -= g*Cg;
+            for (int block_id = 0; block_id < blocks_per_plane; block_id += CONV_WINO_IBLOCK)
+            {
+                for (int db = 0; db < CONV_WINO_IBLOCK; db++)
+                {
+                    size_t inwofs = ((n*ngroups + g)*blocks_per_plane_aligned +
+                                     block_id)*Cg*CONV_WINO_AREA +
+                                    (c*CONV_WINO_IBLOCK + db)*CONV_WINO_ATOM_F32;
+                    float* inwptr = (float*)wbuf_all + inwofs;
+
+                    if (block_id + db < blocks_per_plane)
+                    {
+                        int y0 = (block_id + db) / blocks_per_row;
+                        int x0 = (block_id + db) - y0 * blocks_per_row;
+                        y0 = y0*CONV_WINO_STEP - pad_top;
+                        x0 = x0*CONV_WINO_STEP - pad_left;
+                        bool partial = y0 < 0 || y0 + CONV_WINO_SIZE > Hi ||
+                                       x0 < 0 || x0 + CONV_WINO_SIZE > Wi;
+                        int dx1 = 0, dx2 = CONV_WINO_SIZE, dy1 = 0, dy2 = CONV_WINO_SIZE;
+                        int inpstep = Wi;
+
+                        float inpbuf[CONV_WINO_AREA];
+                        float* inptr0 = (float*)inp + nc0*inp_planesize + y0*Wi + x0;
+                        float* inptr = inptr0;
+
+                        if (partial)
+                        {
+                            memset(inpbuf, 0, sizeof(inpbuf));
+                            dy1 = -y0 > 0 ? -y0 : 0;
+                            dy2 = Hi - y0 < CONV_WINO_SIZE ? Hi - y0 : CONV_WINO_SIZE;
+
+                            if (dy2 < dy1) {dy2 = dy1 = 0;}
+                            dx1 = -x0 > 0 ? -x0 : 0;
+                            dx2 = Wi - x0 < CONV_WINO_SIZE ? Wi - x0 : CONV_WINO_SIZE;
+
+                            if (dx2 < dx1) {dx2 = dx1 = 0;}
+                            inptr0 -= y0*Wi + x0;
+
+                            if (dx1 < dx2 && dy1 < dy2)
+                            {
+                                for(int dy = dy1; dy < dy2; dy++)
+                                    memcpy(&inpbuf[dy*CONV_WINO_SIZE + dx1],
+                                           inptr0 + (y0+dy)*Wi + (x0+dx1),
+                                           (dx2-dx1)*sizeof(inpbuf[0]));
+                            }
+
+                            inptr = inpbuf;
+                            inpstep = CONV_WINO_SIZE;
+                        }
+#if CV_TRY_AVX2
+                        if (conv->useAVX2)
+                            opt_AVX2::winofunc_BtXB_8x8_f32(inptr, inpstep, inwptr, Cg, CONV_WINO_IBLOCK, CONV_WINO_ATOM_F32);
+                        else
+#endif
+#if CV_TRY_AVX
+                        if (conv->useAVX)
+                            opt_AVX::winofunc_BtXB_8x8_f32(inptr, inpstep, inwptr, Cg, CONV_WINO_IBLOCK, CONV_WINO_ATOM_F32);
+                        else
+#endif
+#if CV_NEON && CV_NEON_AARCH64
+                        if (conv->useNEON)
+                            opt_NEON::winofunc_BtXB_8x8_f32(inptr, inpstep, inwptr, Cg, CONV_WINO_IBLOCK, CONV_WINO_ATOM_F32);
+                        else
+#endif
+                        winofunc_BtXB_8x8_f32(inptr, inpstep, inwptr, Cg, CONV_WINO_IBLOCK, CONV_WINO_ATOM_F32);
+                    }
+                    else
+                    {
+                        for (int i = 0; i < CONV_WINO_NATOMS_F32; i++, inwptr += CONV_WINO_IBLOCK*CONV_WINO_ATOM_F32)
+                            memset(inwptr, 0, CONV_WINO_ATOM_F32*sizeof(inwptr[0]));
+                    }
+                }
+            }
+        }
+    }});
+
+    // Phase 2. compute elemwise-weighted sums of transformed blocks,
+    // apply inverse Winograd transforms to the sums,
+    // add bias, apply activation function if any and store the results.
+    parallel_for_(Range(0, ntasks), [&](const Range& r0) {
+    for (int task_id = r0.start; task_id < r0.end; task_id++)
+    {
+        size_t out_wbuf_size = CONV_WINO_AREA*CONV_WINO_KBLOCK*CONV_WINO_IBLOCK;
+        size_t outbuf_size = CONV_WINO_AREA;
+        AutoBuffer<float> out_wbuf_, outbuf_;
+        out_wbuf_.allocate(out_wbuf_size + VEC_ALIGN);
+        float* out_wbuf = alignPtr(out_wbuf_.data(), VEC_ALIGN);
+        outbuf_.allocate(outbuf_size + VEC_ALIGN);
+        float* outbuf = alignPtr(outbuf_.data(), VEC_ALIGN);
+
+        memset(out_wbuf, 0, out_wbuf_size * sizeof(float));
+        memset(outbuf, 0, outbuf_size * sizeof(float));
+
+        int ngk0 = (int)(((int64_t)N*Kg_nblocks*ngroups)*task_id/ntasks);
+        int ngk1 = (int)(((int64_t)N*Kg_nblocks*ngroups)*(task_id+1)/ntasks);
+
+        for(; ngk0 < ngk1; ngk0++)
+        {
+            int n = ngk0 / (Kg_nblocks*ngroups);
+            int gk0 = ngk0 % (Kg_nblocks*ngroups);
+            int g = gk0 / Kg_nblocks;
+            int k0 = (gk0 % Kg_nblocks)*CONV_WINO_KBLOCK;
+            int k1 = k0 + CONV_WINO_KBLOCK <= Kg ? k0 + CONV_WINO_KBLOCK : Kg;
+
+            for (int block_id0 = 0; block_id0 < blocks_per_plane; block_id0 += CONV_WINO_IBLOCK)
+            {
+                int block_id1 = block_id0 + CONV_WINO_IBLOCK;
+                block_id1 = block_id1 < blocks_per_plane ? block_id1 : blocks_per_plane;
+                size_t inwofs = ((n*ngroups + g)*blocks_per_plane_aligned + block_id0)*Cg*CONV_WINO_AREA;
+                size_t wofs = (g*Kg_nblocks*CONV_WINO_KBLOCK + k0)*Cg*CONV_WINO_AREA;
+
+                float* inwptr = wbuf_all + inwofs;
+                const float* wptr = conv->weightsWinoBufPtr + wofs;
+
+#if CV_TRY_AVX2
+                if (conv->useAVX2)
+                    opt_AVX2::winofunc_accum_f32(inwptr, wptr, out_wbuf, Cg, block_id1 - block_id0, CONV_WINO_IBLOCK,
+                                       CONV_WINO_KBLOCK, CONV_WINO_ATOM_F32, CONV_WINO_NATOMS_F32);
+                else
+#endif
+#if CV_TRY_AVX
+                if (conv->useAVX)
+                    opt_AVX::winofunc_accum_f32(inwptr, wptr, out_wbuf, Cg, block_id1 - block_id0, CONV_WINO_IBLOCK,
+                                       CONV_WINO_KBLOCK, CONV_WINO_ATOM_F32, CONV_WINO_NATOMS_F32);
+                else
+#endif
+#if CV_NEON && CV_NEON_AARCH64
+                if (conv->useNEON)
+                    opt_NEON::winofunc_accum_f32(inwptr, wptr, out_wbuf, Cg, block_id1 - block_id0, CONV_WINO_IBLOCK,
+                                       CONV_WINO_KBLOCK, CONV_WINO_ATOM_F32, CONV_WINO_NATOMS_F32);
+                else
+#endif
+
+                winofunc_accum_f32(inwptr, wptr, out_wbuf, Cg, block_id1 - block_id0, CONV_WINO_IBLOCK,
+                                       CONV_WINO_KBLOCK, CONV_WINO_ATOM_F32, CONV_WINO_NATOMS_F32);
+                for (int k = k0; k < k1; k++)
+                {
+                    float biasv = conv->biasBuf[g*Kg + k];
+                    for (int block_id = block_id0; block_id < block_id1; block_id++)
+                    {
+                        int y0 = block_id / blocks_per_row;
+                        int x0 = block_id - y0 * blocks_per_row;
+                        y0 = y0*CONV_WINO_STEP;
+                        x0 = x0*CONV_WINO_STEP;
+                        int dy1 = H0 - y0;
+                        if (dy1 > CONV_WINO_STEP) dy1 = CONV_WINO_STEP;
+                        int dx1 = W0 - x0;
+                        if (dx1 > CONV_WINO_STEP) dx1 = CONV_WINO_STEP;
+                        assert(dx1 > 0 && dy1 > 0);
+                        bool partial = activ || dy1 < CONV_WINO_STEP || dx1 < CONV_WINO_STEP;
+                        size_t outofs = (n*K + g*Kg + k)*out_planesize + y0*W0 + x0;
+                        int outstep = W0;
+
+                        float* outptr0 = (float*)out + outofs;
+                        float* pbptr0 = fusedAddPtr ? fusedAddPtr + outofs : nullptr;
+                        float *outptr = outptr0, *bpptr = pbptr0;
+
+                        if (partial)
+                        {
+                            outptr = outbuf;
+                            outstep = CONV_WINO_SIZE;
+                            if (pbptr0)
+                            {
+                                bpptr = outbuf;
+                                for (int y = 0; y < dy1; y++)
+                                    memcpy(outbuf + y*CONV_WINO_SIZE, pbptr0 + y*W0,
+                                           dx1*sizeof(pbptr0[0]));
+                            }
+                        }
+#if CV_TRY_AVX2
+                        if (conv->useAVX2)
+                            opt_AVX::winofunc_AtXA_8x8_f32(out_wbuf + ((k - k0)*CONV_WINO_IBLOCK + (block_id - block_id0))*CONV_WINO_AREA, CONV_WINO_SIZE,
+                                                                bpptr, outstep, outptr, outstep, biasv, minval, maxval, ifMinMaxAct);
+                        else
+#endif
+#if CV_TRY_AVX
+                        if (conv->useAVX)
+                            opt_AVX::winofunc_AtXA_8x8_f32(out_wbuf + ((k - k0)*CONV_WINO_IBLOCK + (block_id - block_id0))*CONV_WINO_AREA, CONV_WINO_SIZE,
+                                                                bpptr, outstep, outptr, outstep, biasv, minval, maxval, ifMinMaxAct);
+                        else
+#endif
+#if CV_NEON && CV_NEON_AARCH64
+                        if (conv->useNEON)
+                            // NEON optimization is only for ARMv8 device, and for ARMv7 device, we use the Universal intrinsics.
+                            opt_NEON::winofunc_AtXA_8x8_f32(out_wbuf + ((k - k0)*CONV_WINO_IBLOCK + (block_id - block_id0))*CONV_WINO_AREA, CONV_WINO_SIZE,
+                                                                bpptr, outstep, outptr, outstep, biasv, minval, maxval, ifMinMaxAct);
+                        else
+#endif
+                        winofunc_AtXA_8x8_f32(out_wbuf + ((k - k0)*CONV_WINO_IBLOCK + (block_id - block_id0))*CONV_WINO_AREA, CONV_WINO_SIZE,
+                                                  bpptr, outstep, outptr, outstep, biasv, minval, maxval, ifMinMaxAct);
+                        if (partial)
+                        {
+                            if (activ)
+                                activ->forwardSlice(outptr, outptr, CONV_WINO_SIZE*CONV_WINO_STEP, 0, g*Kg + k, g*Kg + k + 1);
+                            for (int y = 0; y < dy1; y++)
+                                memcpy(outptr0 + y*W0, outptr + y*CONV_WINO_SIZE,dx1*sizeof(outptr0[0]));
+                        }
+                    }
+                }
+            }
+        }
+    }});
+    return 1;
+}
+
+/****************************************************************************************\
+                                    SIMD for winograd function
+\****************************************************************************************/
+
+#if CV_SIMD128
+
+void winofunc_accum_f32(const float* inwptr, const float* wptr, float* outbuf, int Cg, int iblock,
+                            const int winoIblock, const int winoKblock, const int winoAtomF32, const int winoNatomF32)
+{
+#if 1
+    CV_Assert(winoIblock == 3 && winoKblock == 4 && winoAtomF32 == 4);
+    for (int atom_id = 0; atom_id < winoNatomF32; atom_id++,
+            outbuf += winoAtomF32)
+    {
+        v_float32x4 s00 = v_setzero_f32(), s01 = s00, s02 = s00;
+        v_float32x4 s10 = v_setzero_f32(), s11 = s00, s12 = s00;
+        v_float32x4 s20 = v_setzero_f32(), s21 = s00, s22 = s00;
+        v_float32x4 s30 = v_setzero_f32(), s31 = s00, s32 = s00;
+
+        for (int c = 0; c < Cg; c++, inwptr += winoIblock*winoAtomF32,
+                                     wptr += winoKblock*winoAtomF32)
+        {
+            v_float32x4 x0, x1, x2;
+            x0 = v_load(inwptr);
+            x1 = v_load(inwptr + 4);
+            x2 = v_load(inwptr + 8);
+
+            v_float32x4 w0 = v_load(wptr);
+            s00 = v_fma(w0, x0, s00);
+            s01 = v_fma(w0, x1, s01);
+            s02 = v_fma(w0, x2, s02);
+
+            w0 = v_load(wptr + 4);
+            s10 = v_fma(w0, x0, s10);
+            s11 = v_fma(w0, x1, s11);
+            s12 = v_fma(w0, x2, s12);
+
+            w0 = v_load(wptr + 8);
+            s20 = v_fma(w0, x0, s20);
+            s21 = v_fma(w0, x1, s21);
+            s22 = v_fma(w0, x2, s22);
+
+            w0 = v_load(wptr + 12);
+            s30 = v_fma(w0, x0, s30);
+            s31 = v_fma(w0, x1, s31);
+            s32 = v_fma(w0, x2, s32);
+        }
+
+        v_store(outbuf, s00);
+        v_store(outbuf + 1*64, s01);
+        v_store(outbuf + 2*64, s02);
+        v_store(outbuf + 3*64, s10);
+        v_store(outbuf + 4*64, s11);
+        v_store(outbuf + 5*64, s12);
+        v_store(outbuf + 6*64, s20);
+        v_store(outbuf + 7*64, s21);
+        v_store(outbuf + 8*64, s22);
+        v_store(outbuf + 9*64, s30);
+        v_store(outbuf + 10*64, s31);
+        v_store(outbuf + 11*64, s32);
+    }
+#else
+    // Naive C++ code, the code should never be run here.
+    for (int atom_id = 0; atom_id < winoNatomF32;
+                atom_id++, outbuf += winoAtomF32)
+    {
+        float sumbuf[winoIblock*winoKblock*winoAtomF32];
+        memset(sumbuf, 0, sizeof(sumbuf));
+        for (int c = 0; c < Cg; c++, inwptr += winoIblock*winoAtomF32,
+                                     wptr += winoKblock*winoAtomF32)
+        {
+            for (int i = 0; i < winoKblock; i++)
+            {
+                for (int j = 0; j < winoIblock; j++)
+                {
+                    int i_ = i*winoAtomF32;
+                    int j_ = j*winoAtomF32;
+                    int ij_ = i_*winoIblock + j_;
+                    float s0 = inwptr[j_ + 0]*wptr[i_ + 0];
+                    float s1 = inwptr[j_ + 1]*wptr[i_ + 1];
+                    float s2 = inwptr[j_ + 2]*wptr[i_ + 2];
+                    float s3 = inwptr[j_ + 3]*wptr[i_ + 3];
+                    sumbuf[ij_ + 0] += s0;
+                    sumbuf[ij_ + 1] += s1;
+                    sumbuf[ij_ + 2] += s2;
+                    sumbuf[ij_ + 3] += s3;
+                }
+            }
+        }
+        for (int ij = 0; ij < winoKblock*winoIblock; ij++)
+        {
+            int ij_ = ij*winoAtomF32;
+            int ij_out = ij*CONV_WINO_AREA;
+            outbuf[ij_out + 0] = sumbuf[ij_ + 0];
+            outbuf[ij_out + 1] = sumbuf[ij_ + 1];
+            outbuf[ij_out + 2] = sumbuf[ij_ + 2];
+            outbuf[ij_out + 3] = sumbuf[ij_ + 3];
+        }
+    }
+#endif
+}
+
+/*Input transform*/
+void winofunc_BtXB_8x8_f32(const float* inptr, int inpstep,
+                          float* outptr, int Cg, const int winoIblock, const int winoAtomF32)
+{
+    CV_Assert(CONV_WINO_IBLOCK == 3 && CONV_WINO_KBLOCK == 4 && CONV_WINO_ATOM_F32 == 4);
+    v_float32x4 x00 = v_load(inptr), x01 = v_load(inptr + 4);
+    v_float32x4 x10 = v_load(inptr + inpstep), x11 = v_load(inptr + inpstep + 4);
+    v_float32x4 x20 = v_load(inptr + inpstep*2), x21 = v_load(inptr + inpstep*2 + 4);
+    v_float32x4 x30 = v_load(inptr + inpstep*3), x31 = v_load(inptr + inpstep*3 + 4);
+    v_float32x4 x40 = v_load(inptr + inpstep*4), x41 = v_load(inptr + inpstep*4 + 4);
+    v_float32x4 x50 = v_load(inptr + inpstep*5), x51 = v_load(inptr + inpstep*5 + 4);
+    v_float32x4 x60 = v_load(inptr + inpstep*6), x61 = v_load(inptr + inpstep*6 + 4);
+    v_float32x4 x70 = v_load(inptr + inpstep*7), x71 = v_load(inptr + inpstep*7 + 4);
+
+    v_float32x4 z00, z01, z10, z11, z20, z21, z30, z31, z40, z41, z50, z51, z60, z61, z70, z71;
+
+    {
+        /* Y[0] = [1.f, 0.f, -5.25f, 0.f, 5.25f, 0.f, -1.f, 0.f]*X */
+        /* Y[7] = [0.f, -1.f, 0.f, 5.25f, 0.f, -5.25f, 0.f, 1.f]*X */
+        v_float32x4 q5_25 = v_setall_f32(5.25f), t00, t01, t10, t11;
+        t00 = x40 - x20;
+        t01 = x41 - x21;
+        t10 = x30 - x50;
+        t11 = x31 - x51;
+        v_float32x4 y00 = v_fma(t00, q5_25, x00 - x60);
+        v_float32x4 y01 = v_fma(t01, q5_25, x01 - x61);
+        v_float32x4 y70 = v_fma(t10, q5_25, x70 - x10);
+        v_float32x4 y71 = v_fma(t11, q5_25, x71 - x11);
+
+        /* Y[1] = [0.f, 1.f, 1.f, -4.25f, -4.25f, 1.f, 1.f, 0.f]*X */
+        /* Y[2] = [0.f, -1.f, 1.f, 4.25f, -4.25f, -1.f, 1.f, 0.f]*X */
+        v_float32x4 qm4_25 = v_setall_f32(-4.25f);
+        t00 = v_fma(x30, qm4_25, x10 + x50);
+        t01 = v_fma(x31, qm4_25, x11 + x51);
+        t10 = v_fma(x40, qm4_25, x20 + x60);
+        t11 = v_fma(x41, qm4_25, x21 + x61);
+
+        v_float32x4 y10 = t00 + t10, y11 = t01 + t11;
+        v_float32x4 y20 = t10 - t00, y21 = t11 - t01;
+
+        /* Y[3] = [0.f, 0.5f, 0.25f, -2.5f, -1.25f, 2.f, 1.f, 0.f]*X */
+        /* Y[4] = [0.f, -0.5f, 0.25f, 2.5f, -1.25f, -2.f, 1.f, 0.f]*X */
+        v_float32x4 q0_5 = v_setall_f32(0.5f), q0_25 = v_setall_f32(0.25f);
+        v_float32x4 qm2_5 = v_setall_f32(-2.5f), qm1_25 = v_setall_f32(-1.25f);
+        t00 = v_fma(x10, q0_5, x50 + x50);
+        t01 = v_fma(x11, q0_5, x51 + x51);
+        t10 = v_fma(x20, q0_25, x60);
+        t11 = v_fma(x21, q0_25, x61);
+        t00 = v_fma(x30, qm2_5, t00);
+        t01 = v_fma(x31, qm2_5, t01);
+        t10 = v_fma(x40, qm1_25, t10);
+        t11 = v_fma(x41, qm1_25, t11);
+
+        v_float32x4 y30 = t00 + t10, y31 = t01 + t11;
+        v_float32x4 y40 = t10 - t00, y41 = t11 - t01;
+
+        /* Y[5] = [0.f, 2.f, 4.f, -2.5f, -5.f, 0.5f, 1.f, 0.f]*X */
+        /* Y[6] = [0.f, -2.f, 4.f, 2.5f, -5.f, -0.5f, 1.f, 0.f]*X */
+        v_float32x4 q4 = v_setall_f32(4.f), qm5 = v_setall_f32(-5.f);
+        t00 = v_fma(x50, q0_5, x10 + x10);
+        t01 = v_fma(x51, q0_5, x11 + x11);
+        t10 = v_fma(x20, q4   , x60);
+        t11 = v_fma(x21, q4   , x61);
+        t00 = v_fma(x30, qm2_5, t00);
+        t01 = v_fma(x31, qm2_5, t01);
+        t10 = v_fma(x40, qm5  , t10);
+        t11 = v_fma(x41, qm5  , t11);
+
+        v_float32x4 y50 = t00 + t10, y51 = t01 + t11;
+        v_float32x4 y60 = t10 - t00, y61 = t11 - t01;
+
+        /* transpose 8x8 matrix with v_transpose4x4 */
+
+        v_float32x4 y000, y100, y200, y300, y010, y110, y210, y310, y400, y500, y600, y700, y410, y510, y610, y710;
+        v_transpose4x4(y00, y10, y20, y30, y000, y100, y200, y300);
+        v_transpose4x4(y01, y11, y21, y31, y010, y110, y210, y310);
+        v_transpose4x4(y40, y50, y60, y70, y400, y500, y600, y700);
+        v_transpose4x4(y41, y51, y61, y71, y410, y510, y610, y710);
+
+        /* Z[0] = [1.f, 0.f, -5.25f, 0.f, 5.25f, 0.f, -1.f, 0.f]*Y */
+        /* Z[7] = [0.f, -1.f, 0.f, 5.25f, 0.f, -5.25f, 0.f, 1.f]*Y */
+        t00 = y010 - y200;
+        t01 = y410 - y600;
+        t10 = y300 - y110;
+        t11 = y700 - y510;
+        z00 = v_fma(t00, q5_25, y000 - y210);
+        z01 = v_fma(t01, q5_25, y400 - y610);
+        z70 = v_fma(t10, q5_25, y310 - y100);
+        z71 = v_fma(t11, q5_25, y710 - y500);
+
+        /* Z[1] = [0.f, 1.f, 1.f, -4.25f, -4.25f, 1.f, 1.f, 0.f]*Y */
+        /* Z[2] = [0.f, -1.f, 1.f, 4.25f, -4.25f, -1.f, 1.f, 0.f]*Y */
+        t00 = v_fma(y300, qm4_25, y100 + y110);
+        t01 = v_fma(y700, qm4_25, y500 + y510);
+        t10 = v_fma(y010, qm4_25, y200 + y210);
+        t11 = v_fma(y410, qm4_25, y600 + y610);
+
+        z10 = t00 + t10; z11 = t01 + t11;
+        z20 = t10 - t00; z21 = t11 - t01;
+
+        /* Z[3] = [0.f, 0.5f, 0.25f, -2.5f, -1.25f, 2.f, 1.f, 0.f]*Y */
+        /* Z[4] = [0.f, -0.5f, 0.25f, 2.5f, -1.25f, -2.f, 1.f, 0.f]*Y */
+        t00 = v_fma(y100, q0_5, y110 + y110);
+        t01 = v_fma(y500, q0_5, y510 + y510);
+        t10 = v_fma(y200, q0_25, y210);
+        t11 = v_fma(y600, q0_25, y610);
+        t00 = v_fma(y300, qm2_5, t00);
+        t01 = v_fma(y700, qm2_5, t01);
+        t10 = v_fma(y010, qm1_25, t10);
+        t11 = v_fma(y410, qm1_25, t11);
+
+        z30 = t00 + t10; z31 = t01 + t11;
+        z40 = t10 - t00; z41 = t11 - t01;
+
+        /* Z[5] = [0.f, 2.f, 4.f, -2.5f, -5.f, 0.5f, 1.f, 0.f]*Y */
+        /* Z[6] = [0.f, -2.f, 4.f, 2.5f, -5.f, -0.5f, 1.f, 0.f]*Y */
+        t00 = v_fma(y110, q0_5, y100 + y100);
+        t01 = v_fma(y510, q0_5, y500 + y500);
+        t10 = v_fma(y200, q4, y210);
+        t11 = v_fma(y600, q4, y610);
+        t00 = v_fma(y300, qm2_5, t00);
+        t01 = v_fma(y700, qm2_5, t01);
+        t10 = v_fma(y010, qm5, t10);
+        t11 = v_fma(y410, qm5, t11);
+
+        z50 = t00 + t10; z51 = t01 + t11;
+        z60 = t10 - t00; z61 = t11 - t01;
+    }
+
+    const int outstep = winoIblock*winoAtomF32*Cg;
+
+    v_store(outptr, z00);
+    v_store(outptr + outstep, z01);
+    v_store(outptr + outstep*2, z10);
+    v_store(outptr + outstep*3, z11);
+    v_store(outptr + outstep*4, z20);
+    v_store(outptr + outstep*5, z21);
+    v_store(outptr + outstep*6, z30);
+    v_store(outptr + outstep*7, z31);
+    v_store(outptr + outstep*8, z40);
+    v_store(outptr + outstep*9, z41);
+    v_store(outptr + outstep*10, z50);
+    v_store(outptr + outstep*11, z51);
+    v_store(outptr + outstep*12, z60);
+    v_store(outptr + outstep*13, z61);
+    v_store(outptr + outstep*14, z70);
+    v_store(outptr + outstep*15, z71);
+}
+
+/*Output transform*/
+/*  Inverse Winograd 8x8 transform:
+    out = (A'*inp*A)', where
+    inp is input 8x8 FP32 matrix,
+    A' is
+    [1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 0.f,
+     0.f, 1.f, -1.f, 2.f, -2.f, 0.5f, -0.5f, 0.f,
+     0.f, 1.f, 1.f, 4.f, 4.f, 0.25f, 0.25f, 0.f,
+     0.f, 1.f, -1.f, 8.f, -8.f, 0.125f, -0.125f, 0.f,
+     0.f, 1.f, 1.f, 16.f, 16.f, 1.f/16, 1.f/16, 0.f,
+     0.f, 1.f, -1.f, 32.f, -32.f, 1.f/32, -1.f/32, 1.f]
+
+    inp is pre-loaded into xij registers,
+    out will be stored in zij, where (0<=i<=7 for x, 0<=i<=5 for z), 0<=j<=1.
+
+    After the inverse transform is done, we add bias,
+    optionally add results from the earlier tensors (by-pass),
+    optionally apply activation function and then
+    store the final results.
+
+    That is, after both forward and then inverse transformation,
+    we get non-transposed result.
+    Of course, for the correct work of Winograd-based convolution,
+    the Winograd-transformed weights should also be transposed.
+    init_conv() (see OpConv.fx) takes care of that.
+*/
+void winofunc_AtXA_8x8_f32(const float* inptr, int inpstep,
+                          float* bpptr, int bpstep, float* outptr, int outstep,
+                          float bias, float minval, float maxval, bool ifMinMaxAct)
+{
+    CV_Assert(CONV_WINO_IBLOCK == 3 && CONV_WINO_KBLOCK == 4 && CONV_WINO_ATOM_F32 == 4);
+    v_float32x4 x00 = v_load(inptr), x01 = v_load(inptr + 4);
+    v_float32x4 x10 = v_load(inptr + inpstep), x11 = v_load(inptr + inpstep + 4);
+    v_float32x4 x20 = v_load(inptr + inpstep*2), x21 = v_load(inptr + inpstep*2 + 4);
+    v_float32x4 x30 = v_load(inptr + inpstep*3), x31 = v_load(inptr + inpstep*3 + 4);
+    v_float32x4 x40 = v_load(inptr + inpstep*4), x41 = v_load(inptr + inpstep*4 + 4);
+    v_float32x4 x50 = v_load(inptr + inpstep*5), x51 = v_load(inptr + inpstep*5 + 4);
+    v_float32x4 x60 = v_load(inptr + inpstep*6), x61 = v_load(inptr + inpstep*6 + 4);
+    v_float32x4 x70 = v_load(inptr + inpstep*7), x71 = v_load(inptr + inpstep*7 + 4);
+    v_float32x4 z00, z01, z10, z11, z20, z21, z30, z31, z40, z41, z50, z51;
+
+    {
+        v_float32x4 s12_0, s12_1, s34_0, s34_1, s56_0, s56_1;
+        s12_0 = x10 + x20; s12_1 = x11 + x21;
+        s34_0 = x30 + x40; s34_1 = x31 + x41;
+        s56_0 = x50 + x60; s56_1 = x51 + x61;
+
+        v_float32x4 y00 = x00 + s12_0 + s34_0 + s56_0;
+        v_float32x4 y01 = x01 + s12_1 + s34_1 + s56_1;
+
+        v_float32x4 a0 = v_setall_f32(0.25f), a1 = v_setall_f32(4.0f);
+        v_float32x4 y20 = v_fma(s56_0, a0, v_fma(s34_0, a1, s12_0));
+        v_float32x4 y21 = v_fma(s56_1, a0 ,v_fma(s34_1, a1, s12_1) );
+
+        a0 = v_setall_f32(1.f/16), a1 = v_setall_f32(16.0f);
+        v_float32x4 y40 = v_fma(s56_0, a0, v_fma(s34_0, a1, s12_0));
+        v_float32x4 y41 = v_fma(s56_1, a0, v_fma(s34_1, a1, s12_1));
+
+        s12_0 = x10 - x20; s12_1 = x11 - x21;
+        s34_0 = x30 - x40; s34_1 = x31 - x41;
+        s56_0 = x50 - x60; s56_1 = x51 - x61;
+
+        a0 = v_setall_f32(1.f/32), a1 = v_setall_f32(32.f);
+        v_float32x4 y50 = v_fma(s56_0, a0, v_fma(s34_0, a1, x70 + s12_0));
+        v_float32x4 y51 = v_fma(s56_1, a0, v_fma(s34_1, a1, x71 + s12_1));
+
+        a0 = v_setall_f32(0.5f), a1 = v_setall_f32(2.f);
+        v_float32x4 y10 = v_fma(s56_0, a0, v_fma(s34_0, a1, s12_0));
+        v_float32x4 y11 = v_fma(s56_1, a0, v_fma(s34_1, a1, s12_1));
+
+        a0 = v_setall_f32(0.125f), a1 = v_setall_f32(8.f);
+        v_float32x4 y30 = v_fma(s56_0, a0, v_fma(s34_0, a1, s12_0));
+        v_float32x4 y31 = v_fma(s56_1, a0, v_fma(s34_1, a1, s12_1));
+
+        v_float32x4 y60 = v_setall_f32(0.f), y61 = y60, y70 = y60, y71 = y60;
+
+        /* transpose 8x8 matrix with v_transpose4x4 */
+
+        v_float32x4 y000, y100, y200, y300, y010, y110, y210, y310, y400, y500, y600, y700, y410, y510, y610, y710;
+        v_transpose4x4(y00, y10, y20, y30, y000, y100, y200, y300);
+        v_transpose4x4(y01, y11, y21, y31, y010, y110, y210, y310);
+        v_transpose4x4(y40, y50, y60, y70, y400, y500, y600, y700);
+        v_transpose4x4(y41, y51, y61, y71, y410, y510, y610, y710);
+
+        s12_0 = y100 + y200; s12_1 = y500 + y600;
+        s34_0 = y300 + y010; s34_1 = y700 + y410;
+        s56_0 = y110 + y210; s56_1 = y510 + y610;
+
+        z00 = y000 + s12_0 + s34_0 + s56_0;
+        z01 = y400 + s12_1 + s34_1 + s56_1;
+
+        a0 = v_setall_f32(0.25f), a1 = v_setall_f32(4.0f);
+        z20 = v_fma(s56_0, a0, v_fma(s34_0, a1, s12_0));
+        z21 = v_fma(s56_1, a0, v_fma(s34_1, a1, s12_1));
+
+        a0 = v_setall_f32(1.f/16), a1 = v_setall_f32(16.0f);
+        z40 = v_fma(s56_0, a0, v_fma(s34_0, a1, s12_0));
+        z41 = v_fma(s56_1, a0, v_fma(s34_1, a1, s12_1));
+
+        s12_0 = y100 - y200; s12_1 = y500 - y600;
+        s34_0 = y300 - y010; s34_1 = y700 - y410;
+        s56_0 = y110 - y210; s56_1 = y510 - y610;
+
+        a0 = v_setall_f32(1.f/32), a1 = v_setall_f32(32.0f);
+        z50 = v_fma(s56_0, a0, v_fma(s34_0, a1, y310 + s12_0));
+        z51 = v_fma(s56_1, a0, v_fma(s34_1, a1, y710 + s12_1));
+        a0 = v_setall_f32(0.5f), a1 = v_setall_f32(2.0f);
+        z10 = v_fma(s56_0, a0, v_fma(s34_0, a1, s12_0));
+        z11 = v_fma(s56_1, a0, v_fma(s34_1, a1, s12_1));
+
+        a0 = v_setall_f32(0.125f), a1 = v_setall_f32(8.0f);
+        z30 = v_fma(s56_0, a0, v_fma(s34_0, a1, s12_0));
+        z31 = v_fma(s56_1, a0, v_fma(s34_1, a1, s12_1));
+
+        v_float32x4 vbias = v_setall_f32(bias);
+        z00 += vbias;
+        z01 += vbias;
+        z10 += vbias;
+        z11 += vbias;
+        z20 += vbias;
+        z21 += vbias;
+        z30 += vbias;
+        z31 += vbias;
+        z40 += vbias;
+        z41 += vbias;
+        z50 += vbias;
+        z51 += vbias;
+    }
+
+    if (bpptr)
+    {
+        z00 += v_load(bpptr);
+        z01 += v_load_low(bpptr + 4);
+        z10 += v_load(bpptr + bpstep);
+        z11 += v_load_low(bpptr + bpstep + 4);
+        z20 += v_load(bpptr + bpstep*2);
+        z21 += v_load_low(bpptr + bpstep*2 + 4);
+        z30 += v_load(bpptr + bpstep*3);
+        z31 += v_load_low(bpptr + bpstep*3 + 4);
+        z40 += v_load(bpptr + bpstep*4);
+        z41 += v_load_low(bpptr + bpstep*4 + 4);
+        z50 += v_load(bpptr + bpstep*5);
+        z51 += v_load_low(bpptr + bpstep*5 + 4);
+    }
+
+    if (ifMinMaxAct)
+    {
+        v_float32x4 vmax = v_setall_f32(maxval);
+        v_float32x4 vmin = v_setall_f32(minval);
+
+        z00 = v_min(v_max(z00, vmin), vmax);
+        z01 = v_min(v_max(z01, vmin), vmax);
+        z10 = v_min(v_max(z10, vmin), vmax);
+        z11 = v_min(v_max(z11, vmin), vmax);
+        z20 = v_min(v_max(z20, vmin), vmax);
+        z21 = v_min(v_max(z21, vmin), vmax);
+        z30 = v_min(v_max(z30, vmin), vmax);
+        z31 = v_min(v_max(z31, vmin), vmax);
+        z40 = v_min(v_max(z40, vmin), vmax);
+        z41 = v_min(v_max(z41, vmin), vmax);
+        z50 = v_min(v_max(z50, vmin), vmax);
+        z51 = v_min(v_max(z51, vmin), vmax);
+    }
+
+    v_store(outptr, z00);
+    v_store_low(outptr + 4, z01);
+    v_store(outptr + outstep, z10);
+    v_store_low(outptr + outstep + 4, z11);
+    v_store(outptr + outstep*2, z20);
+    v_store_low(outptr + outstep*2 + 4, z21);
+    v_store(outptr + outstep*3, z30);
+    v_store_low(outptr + outstep*3 + 4, z31);
+    v_store(outptr + outstep*4, z40);
+    v_store_low(outptr + outstep*4 + 4, z41);
+    v_store(outptr + outstep*5, z50);
+    v_store_low(outptr + outstep*5 + 4, z51);
+}
+#endif
+
+#else
+int runWinograd63(InputArray _input, InputArray _fusedAddMat, OutputArray _output, const Ptr<FastConv>& conv,
+                  int ntasks, float minval, float maxval, ActivationLayer* activ, bool ifMinMaxAct)
+{
+    return 0;
+}
+#endif
+
+}} // namespace cv::dnn

modules/dnn/src/layers/cpu_kernels/conv_winograd_f63.simd.hpp

@@ -0,0 +1,886 @@
+// 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 "opencv2/core/hal/intrin.hpp"
+
+namespace cv {
+namespace dnn {
+CV_CPU_OPTIMIZATION_NAMESPACE_BEGIN
+
+/* Accumulate */
+void winofunc_accum_f32(const float* inwptr, const float* wptr, float* outbuf, int Cg, int iblock,
+                            const int winoIblock, const int winoKblock, const int winoAtomF32, const int winoNatomF32);
+
+/*Input transform*/
+void winofunc_BtXB_8x8_f32(const float* inptr, int inpstep,
+                               float* outptr, int Cg, const int winoIblock, const int winoAtomF32);
+
+/*Output transform*/
+void winofunc_AtXA_8x8_f32(const float* inptr, int inpstep,
+                               float* bpptr, int bpstep, float* outptr, int outstep,
+                               float bias, float minval, float maxval, bool ifMinMaxAct);
+
+#if !defined(CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY) && CV_AVX
+
+#if !CV_FMA3 // AVX workaround
+#undef _mm256_fmadd_ps
+#define _mm256_fmadd_ps(a, b, c) _mm256_add_ps(c, _mm256_mul_ps(a, b))
+#endif
+
+void winofunc_accum_f32(const float* inwptr, const float* wptr, float* outbuf, int Cg, int iblock,
+                            const int winoIblock, const int winoKblock, const int winoAtomF32, const int winoNatomF32)
+{
+    CV_Assert(winoIblock == 6 && winoKblock == 4 && winoAtomF32 == 8);
+    if (iblock > 3)
+    {
+        for (int atom_id = 0; atom_id < winoNatomF32; atom_id++,
+                outbuf += winoAtomF32)
+        {
+            __m256 s00 = _mm256_set1_ps(0.f), s01 = s00, s02 = s00, s03 = s00, s04 = s00, s05 = s00;
+            __m256 s10 = _mm256_set1_ps(0.f), s11 = s00, s12 = s00, s13 = s00, s14 = s00, s15 = s00;
+            __m256 s20 = _mm256_set1_ps(0.f), s21 = s00, s22 = s00, s23 = s00, s24 = s00, s25 = s00;
+            __m256 s30 = _mm256_set1_ps(0.f), s31 = s00, s32 = s00, s33 = s00, s34 = s00, s35 = s00;
+            for (int c = 0; c < Cg; c++, inwptr += winoIblock*winoAtomF32,
+                                         wptr += winoKblock*winoAtomF32)
+            {
+                __m256 w0 = _mm256_load_ps(wptr), w1 = _mm256_load_ps(wptr + 8);
+                __m256 w2 = _mm256_load_ps(wptr + 16), w3 = _mm256_load_ps(wptr + 24);
+                __m256 x0, x1;
+                x0 = _mm256_load_ps(inwptr);
+                x1 = _mm256_load_ps(inwptr + 8);
+                s00 = _mm256_fmadd_ps(w0, x0, s00);
+                s01 = _mm256_fmadd_ps(w0, x1, s01);
+                s10 = _mm256_fmadd_ps(w1, x0, s10);
+                s11 = _mm256_fmadd_ps(w1, x1, s11);
+                s20 = _mm256_fmadd_ps(w2, x0, s20);
+                s21 = _mm256_fmadd_ps(w2, x1, s21);
+                s30 = _mm256_fmadd_ps(w3, x0, s30);
+                s31 = _mm256_fmadd_ps(w3, x1, s31);
+                x0 = _mm256_load_ps(inwptr + 16);
+                x1 = _mm256_load_ps(inwptr + 24);
+                s02 = _mm256_fmadd_ps(w0, x0, s02);
+                s03 = _mm256_fmadd_ps(w0, x1, s03);
+                s12 = _mm256_fmadd_ps(w1, x0, s12);
+                s13 = _mm256_fmadd_ps(w1, x1, s13);
+                s22 = _mm256_fmadd_ps(w2, x0, s22);
+                s23 = _mm256_fmadd_ps(w2, x1, s23);
+                s32 = _mm256_fmadd_ps(w3, x0, s32);
+                s33 = _mm256_fmadd_ps(w3, x1, s33);
+                x0 = _mm256_load_ps(inwptr + 32);
+                x1 = _mm256_load_ps(inwptr + 40);
+                s04 = _mm256_fmadd_ps(w0, x0, s04);
+                s05 = _mm256_fmadd_ps(w0, x1, s05);
+                s14 = _mm256_fmadd_ps(w1, x0, s14);
+                s15 = _mm256_fmadd_ps(w1, x1, s15);
+                s24 = _mm256_fmadd_ps(w2, x0, s24);
+                s25 = _mm256_fmadd_ps(w2, x1, s25);
+                s34 = _mm256_fmadd_ps(w3, x0, s34);
+                s35 = _mm256_fmadd_ps(w3, x1, s35);
+            }
+
+            _mm256_store_ps(outbuf, s00);
+            _mm256_store_ps(outbuf + 1*64, s01);
+            _mm256_store_ps(outbuf + 2*64, s02);
+            _mm256_store_ps(outbuf + 3*64, s03);
+            _mm256_store_ps(outbuf + 4*64, s04);
+            _mm256_store_ps(outbuf + 5*64, s05);
+
+            _mm256_store_ps(outbuf + 6*64, s10);
+            _mm256_store_ps(outbuf + 7*64, s11);
+            _mm256_store_ps(outbuf + 8*64, s12);
+            _mm256_store_ps(outbuf + 9*64, s13);
+            _mm256_store_ps(outbuf + 10*64, s14);
+            _mm256_store_ps(outbuf + 11*64, s15);
+
+            _mm256_store_ps(outbuf + 12*64, s20);
+            _mm256_store_ps(outbuf + 13*64, s21);
+            _mm256_store_ps(outbuf + 14*64, s22);
+            _mm256_store_ps(outbuf + 15*64, s23);
+            _mm256_store_ps(outbuf + 16*64, s24);
+            _mm256_store_ps(outbuf + 17*64, s25);
+
+            _mm256_store_ps(outbuf + 18*64, s30);
+            _mm256_store_ps(outbuf + 19*64, s31);
+            _mm256_store_ps(outbuf + 20*64, s32);
+            _mm256_store_ps(outbuf + 21*64, s33);
+            _mm256_store_ps(outbuf + 22*64, s34);
+            _mm256_store_ps(outbuf + 23*64, s35);
+        }
+    }
+    else
+    {
+        for (int atom_id = 0; atom_id < winoNatomF32; atom_id++,
+                outbuf += winoAtomF32)
+        {
+            __m256 s00 = _mm256_set1_ps(0.f), s01 = s00, s02 = s00;
+            __m256 s10 = _mm256_set1_ps(0.f), s11 = s00, s12 = s00;
+            __m256 s20 = _mm256_set1_ps(0.f), s21 = s00, s22 = s00;
+            __m256 s30 = _mm256_set1_ps(0.f), s31 = s00, s32 = s00;
+            for (int c = 0; c < Cg; c++, inwptr += winoIblock*winoAtomF32,
+                                         wptr += winoKblock*winoAtomF32) {
+                __m256 w0 = _mm256_load_ps(wptr), w1 = _mm256_load_ps(wptr + 8);
+                __m256 w2 = _mm256_load_ps(wptr + 16), w3 = _mm256_load_ps(wptr + 24);
+                __m256 x0, x1, x2;
+                x0 = _mm256_load_ps(inwptr);
+                x1 = _mm256_load_ps(inwptr + 8);
+                x2 = _mm256_load_ps(inwptr + 16);
+                s00 = _mm256_fmadd_ps(w0, x0, s00);
+                s01 = _mm256_fmadd_ps(w0, x1, s01);
+                s02 = _mm256_fmadd_ps(w0, x2, s02);
+                s10 = _mm256_fmadd_ps(w1, x0, s10);
+                s11 = _mm256_fmadd_ps(w1, x1, s11);
+                s12 = _mm256_fmadd_ps(w1, x2, s12);
+                s20 = _mm256_fmadd_ps(w2, x0, s20);
+                s21 = _mm256_fmadd_ps(w2, x1, s21);
+                s22 = _mm256_fmadd_ps(w2, x2, s22);
+                s30 = _mm256_fmadd_ps(w3, x0, s30);
+                s31 = _mm256_fmadd_ps(w3, x1, s31);
+                s32 = _mm256_fmadd_ps(w3, x2, s32);
+            }
+
+            _mm256_store_ps(outbuf, s00);
+            _mm256_store_ps(outbuf + 1*64, s01);
+            _mm256_store_ps(outbuf + 2*64, s02);
+            _mm256_store_ps(outbuf + 6*64, s10);
+            _mm256_store_ps(outbuf + 7*64, s11);
+            _mm256_store_ps(outbuf + 8*64, s12);
+            _mm256_store_ps(outbuf + 12*64, s20);
+            _mm256_store_ps(outbuf + 13*64, s21);
+            _mm256_store_ps(outbuf + 14*64, s22);
+            _mm256_store_ps(outbuf + 18*64, s30);
+            _mm256_store_ps(outbuf + 19*64, s31);
+            _mm256_store_ps(outbuf + 20*64, s32);
+        }
+    }
+    _mm256_zeroupper();
+}
+static inline
+void transpose8_ps(__m256 &row0, __m256 &row1, __m256 &row2, __m256 &row3, __m256 &row4, __m256 &row5, __m256 &row6, __m256 &row7)
+{
+    __m256 __t0, __t1, __t2, __t3, __t4, __t5, __t6, __t7;
+    __m256 __tt0, __tt1, __tt2, __tt3, __tt4, __tt5, __tt6, __tt7;
+    __t0 = _mm256_unpacklo_ps(row0, row1);
+    __t1 = _mm256_unpackhi_ps(row0, row1);
+    __t2 = _mm256_unpacklo_ps(row2, row3);
+    __t3 = _mm256_unpackhi_ps(row2, row3);
+    __t4 = _mm256_unpacklo_ps(row4, row5);
+    __t5 = _mm256_unpackhi_ps(row4, row5);
+    __t6 = _mm256_unpacklo_ps(row6, row7);
+    __t7 = _mm256_unpackhi_ps(row6, row7);
+    __tt0 = _mm256_shuffle_ps(__t0,__t2,_MM_SHUFFLE(1,0,1,0));
+    __tt1 = _mm256_shuffle_ps(__t0,__t2,_MM_SHUFFLE(3,2,3,2));
+    __tt2 = _mm256_shuffle_ps(__t1,__t3,_MM_SHUFFLE(1,0,1,0));
+    __tt3 = _mm256_shuffle_ps(__t1,__t3,_MM_SHUFFLE(3,2,3,2));
+    __tt4 = _mm256_shuffle_ps(__t4,__t6,_MM_SHUFFLE(1,0,1,0));
+    __tt5 = _mm256_shuffle_ps(__t4,__t6,_MM_SHUFFLE(3,2,3,2));
+    __tt6 = _mm256_shuffle_ps(__t5,__t7,_MM_SHUFFLE(1,0,1,0));
+    __tt7 = _mm256_shuffle_ps(__t5,__t7,_MM_SHUFFLE(3,2,3,2));
+    row0 = _mm256_permute2f128_ps(__tt0, __tt4, 0x20);
+    row1 = _mm256_permute2f128_ps(__tt1, __tt5, 0x20);
+    row2 = _mm256_permute2f128_ps(__tt2, __tt6, 0x20);
+    row3 = _mm256_permute2f128_ps(__tt3, __tt7, 0x20);
+    row4 = _mm256_permute2f128_ps(__tt0, __tt4, 0x31);
+    row5 = _mm256_permute2f128_ps(__tt1, __tt5, 0x31);
+    row6 = _mm256_permute2f128_ps(__tt2, __tt6, 0x31);
+    row7 = _mm256_permute2f128_ps(__tt3, __tt7, 0x31);
+}
+
+/*Input transform*/
+void winofunc_BtXB_8x8_f32(const float* inptr, int inpstep,
+                               float* outptr, int Cg, const int winoIblock, const int winoAtomF32)
+{
+    __m256 x00 = _mm256_loadu_ps(inptr);
+    __m256 x10 = _mm256_loadu_ps(inptr + inpstep);
+    __m256 x20 = _mm256_loadu_ps(inptr + inpstep*2);
+    __m256 x30 = _mm256_loadu_ps(inptr + inpstep*3);
+    __m256 x40 = _mm256_loadu_ps(inptr + inpstep*4);
+    __m256 x50 = _mm256_loadu_ps(inptr + inpstep*5);
+    __m256 x60 = _mm256_loadu_ps(inptr + inpstep*6);
+    __m256 x70 = _mm256_loadu_ps(inptr + inpstep*7);
+
+    __m256 z00, z10, z20, z30, z40, z50, z60, z70;
+
+    {
+        /* Y[0] = [1.f, 0.f, -5.25f, 0.f, 5.25f, 0.f, -1.f, 0.f]*X */
+        /* Y[7] = [0.f, -1.f, 0.f, 5.25f, 0.f, -5.25f, 0.f, 1.f]*X */
+        __m256 q5_25 = _mm256_set1_ps(5.25f), t00, t10;
+        t00 = _mm256_sub_ps(x40, x20);
+        t10 = _mm256_sub_ps(x30, x50);
+
+        __m256 y00 = _mm256_fmadd_ps(t00, q5_25, _mm256_sub_ps(x00, x60));
+        __m256 y70 = _mm256_fmadd_ps(t10, q5_25, _mm256_sub_ps(x70, x10));
+
+        /* Y[1] = [0.f, 1.f, 1.f, -4.25f, -4.25f, 1.f, 1.f, 0.f]*X */
+        /* Y[2] = [0.f, -1.f, 1.f, 4.25f, -4.25f, -1.f, 1.f, 0.f]*X */
+        __m256 qm4_25 = _mm256_set1_ps(-4.25f);
+        t00 = _mm256_fmadd_ps(x30, qm4_25, _mm256_add_ps(x10, x50));
+        t10 = _mm256_fmadd_ps(x40, qm4_25, _mm256_add_ps(x20, x60));
+
+        __m256 y10 = _mm256_add_ps(t00, t10);
+        __m256 y20 = _mm256_sub_ps(t10, t00);
+
+        /* Y[3] = [0.f, 0.5f, 0.25f, -2.5f, -1.25f, 2.f, 1.f, 0.f]*X */
+        /* Y[4] = [0.f, -0.5f, 0.25f, 2.5f, -1.25f, -2.f, 1.f, 0.f]*X */
+        __m256 q0_5 = _mm256_set1_ps(0.5f), q0_25 = _mm256_set1_ps(0.25f);
+        __m256 qm2_5 = _mm256_set1_ps(-2.5f), qm1_25 = _mm256_set1_ps(-1.25f);
+        t00 = _mm256_fmadd_ps(x10, q0_5, _mm256_add_ps(x50, x50));
+        t10 = _mm256_fmadd_ps(x20, q0_25, x60);
+        t00 = _mm256_fmadd_ps(x30, qm2_5, t00);
+        t10 = _mm256_fmadd_ps(x40, qm1_25, t10);
+
+        __m256 y30 = _mm256_add_ps(t00, t10);
+        __m256 y40 = _mm256_sub_ps(t10, t00);
+
+        /* Y[5] = [0.f, 2.f, 4.f, -2.5f, -5.f, 0.5f, 1.f, 0.f]*X */
+        /* Y[6] = [0.f, -2.f, 4.f, 2.5f, -5.f, -0.5f, 1.f, 0.f]*X */
+        __m256 q4 = _mm256_set1_ps(4.f), qm5 = _mm256_set1_ps(-5.f);
+        t00 = _mm256_fmadd_ps(x50, q0_5, _mm256_add_ps(x10, x10));
+        t10 = _mm256_fmadd_ps(x20, q4   , x60);
+        t00 = _mm256_fmadd_ps(x30, qm2_5, t00);
+        t10 = _mm256_fmadd_ps(x40, qm5  , t10);
+
+        __m256 y50 = _mm256_add_ps(t00, t10);
+        __m256 y60 = _mm256_sub_ps(t10, t00);
+
+        /* transpose 8x8 matrix in-place with some renumeration of the elements: */
+        transpose8_ps(y00, y10, y20, y30, y40, y50, y60, y70);
+
+        /* Z[0] = [1.f, 0.f, -5.25f, 0.f, 5.25f, 0.f, -1.f, 0.f]*Y */
+        /* Z[7] = [0.f, -1.f, 0.f, 5.25f, 0.f, -5.25f, 0.f, 1.f]*Y */
+        t00 = _mm256_sub_ps(y40, y20);
+        t10 = _mm256_sub_ps(y30, y50);
+        z00 = _mm256_fmadd_ps(t00, q5_25, _mm256_sub_ps(y00, y60));
+        z70 = _mm256_fmadd_ps(t10, q5_25, _mm256_sub_ps(y70, y10));
+
+        /* Z[1] = [0.f, 1.f, 1.f, -4.25f, -4.25f, 1.f, 1.f, 0.f]*Y */
+        /* Z[2] = [0.f, -1.f, 1.f, 4.25f, -4.25f, -1.f, 1.f, 0.f]*Y */
+        t00 = _mm256_fmadd_ps(y30, qm4_25, _mm256_add_ps(y10, y50));
+        t10 = _mm256_fmadd_ps(y40, qm4_25, _mm256_add_ps(y20, y60));
+        z10 = _mm256_add_ps(t00, t10);
+        z20 = _mm256_sub_ps(t10, t00);
+
+        /* Z[3] = [0.f, 0.5f, 0.25f, -2.5f, -1.25f, 2.f, 1.f, 0.f]*Y */
+        /* Z[4] = [0.f, -0.5f, 0.25f, 2.5f, -1.25f, -2.f, 1.f, 0.f]*Y */
+        t00 = _mm256_fmadd_ps(y10, q0_5, _mm256_add_ps(y50, y50));
+        t10 = _mm256_fmadd_ps(y20, q0_25, y60);
+        t00 = _mm256_fmadd_ps(y30, qm2_5, t00);
+        t10 = _mm256_fmadd_ps(y40, qm1_25, t10);
+
+        z30 = _mm256_add_ps(t00, t10);
+        z40 = _mm256_sub_ps(t10, t00);
+
+        /* Z[5] = [0.f, 2.f, 4.f, -2.5f, -5.f, 0.5f, 1.f, 0.f]*Y */
+        /* Z[6] = [0.f, -2.f, 4.f, 2.5f, -5.f, -0.5f, 1.f, 0.f]*Y */
+        t00 = _mm256_fmadd_ps(y50, q0_5, _mm256_add_ps(y10, y10));
+        t10 = _mm256_fmadd_ps(y20, q4, y60);
+        t00 = _mm256_fmadd_ps(y30, qm2_5, t00);
+        t10 = _mm256_fmadd_ps(y40, qm5, t10);
+
+        z50 = _mm256_add_ps(t00, t10);
+        z60 = _mm256_sub_ps(t10, t00);
+    }
+
+    const int outstep = winoIblock*winoAtomF32*Cg;
+
+    _mm256_storeu_ps(outptr, z00);
+    _mm256_storeu_ps(outptr + outstep, z10);
+    _mm256_storeu_ps(outptr + outstep*2, z20);
+    _mm256_storeu_ps(outptr + outstep*3, z30);
+    _mm256_storeu_ps(outptr + outstep*4, z40);
+    _mm256_storeu_ps(outptr + outstep*5, z50);
+    _mm256_storeu_ps(outptr + outstep*6, z60);
+    _mm256_storeu_ps(outptr + outstep*7, z70);
+    _mm256_zeroupper();
+}
+
+#define STORE6_ELE_FROM_16(ptr, z00, lowM, highM) \
+    lowM = _mm256_castps256_ps128(z00); \
+    highM = _mm256_extractf128_ps(z00, 1); \
+    _mm_storeu_ps(ptr, lowM); \
+    _mm_storel_epi64((__m128i*)(ptr + 4), _mm_castps_si128(highM))
+
+/*  Inverse Winograd 8x8 transform:
+    out = (A'*inp*A)', where
+    inp is input 8x8 FP32 matrix,
+    A' is
+    [1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 0.f,
+     0.f, 1.f, -1.f, 2.f, -2.f, 0.5f, -0.5f, 0.f,
+     0.f, 1.f, 1.f, 4.f, 4.f, 0.25f, 0.25f, 0.f,
+     0.f, 1.f, -1.f, 8.f, -8.f, 0.125f, -0.125f, 0.f,
+     0.f, 1.f, 1.f, 16.f, 16.f, 1.f/16, 1.f/16, 0.f,
+     0.f, 1.f, -1.f, 32.f, -32.f, 1.f/32, -1.f/32, 1.f]
+*/
+void winofunc_AtXA_8x8_f32(const float* inptr, int inpstep,
+                          float* bpptr, int bpstep, float* outptr, int outstep,
+                          float bias, float minval, float maxval, bool ifMinMaxAct)
+{
+
+    __m256 x00 = _mm256_load_ps(inptr);
+    __m256 x10 = _mm256_load_ps(inptr + inpstep);
+    __m256 x20 = _mm256_load_ps(inptr + inpstep*2);
+    __m256 x30 = _mm256_load_ps(inptr + inpstep*3);
+    __m256 x40 = _mm256_load_ps(inptr + inpstep*4);
+    __m256 x50 = _mm256_load_ps(inptr + inpstep*5);
+    __m256 x60 = _mm256_load_ps(inptr + inpstep*6);
+    __m256 x70 = _mm256_load_ps(inptr + inpstep*7);
+    __m256 z00, z10, z20, z30, z40, z50;
+
+    {
+        __m256 s12_0, s34_0, s56_0;
+        s12_0 = _mm256_add_ps(x10, x20);
+        s34_0 = _mm256_add_ps(x30, x40);
+        s56_0 = _mm256_add_ps(x50, x60);
+
+        __m256 y00 = _mm256_add_ps(x00, _mm256_add_ps(s12_0, _mm256_add_ps(s34_0, s56_0)));
+        __m256 y20 = _mm256_fmadd_ps(s56_0, _mm256_set1_ps(0.25f), _mm256_fmadd_ps(s34_0, _mm256_set1_ps(4.0f), s12_0));
+        __m256 y40 = _mm256_fmadd_ps(s56_0, _mm256_set1_ps(1.f/16), _mm256_fmadd_ps(s34_0, _mm256_set1_ps(16.0f), s12_0));
+
+        s12_0 = _mm256_sub_ps(x10, x20);
+        s34_0 = _mm256_sub_ps(x30, x40);
+        s56_0 = _mm256_sub_ps(x50, x60);
+        __m256 y50 = _mm256_fmadd_ps(s56_0, _mm256_set1_ps(1.f/32), _mm256_fmadd_ps(s34_0, _mm256_set1_ps(32.f), _mm256_add_ps(x70, s12_0)));
+        __m256 y10 = _mm256_fmadd_ps(s56_0, _mm256_set1_ps(0.5f), _mm256_fmadd_ps(s34_0, _mm256_set1_ps(2.f), s12_0));
+        __m256 y30 = _mm256_fmadd_ps(s56_0, _mm256_set1_ps(0.125f), _mm256_fmadd_ps(s34_0, _mm256_set1_ps(8.f), s12_0));
+        __m256 y60 = _mm256_set1_ps(0.f), y70 = y60;
+
+        /* transpose 8x8 matrix in-place with some renumeration of the elements: */
+
+        transpose8_ps(y00, y10, y20, y30, y40, y50, y60, y70);
+
+        s12_0 = _mm256_add_ps(y10, y20);
+        s34_0 = _mm256_add_ps(y30, y40);
+        s56_0 = _mm256_add_ps(y50, y60);
+
+        z00 = _mm256_add_ps(y00, _mm256_add_ps(s12_0, _mm256_add_ps(s34_0, s56_0)));
+        z20 = _mm256_fmadd_ps(s56_0, _mm256_set1_ps(0.25f), _mm256_fmadd_ps(s34_0, _mm256_set1_ps(4.0f), s12_0));
+        z40 = _mm256_fmadd_ps(s56_0, _mm256_set1_ps(1.f/16), _mm256_fmadd_ps(s34_0, _mm256_set1_ps(16.0f), s12_0));
+
+        s12_0 = _mm256_sub_ps(y10, y20);
+        s34_0 = _mm256_sub_ps(y30, y40);
+        s56_0 = _mm256_sub_ps(y50, y60);
+
+        z50 = _mm256_fmadd_ps(s56_0, _mm256_set1_ps(1.f/32), _mm256_fmadd_ps(s34_0, _mm256_set1_ps(32.0f), _mm256_add_ps(y70, s12_0)));
+        z10 = _mm256_fmadd_ps(s56_0, _mm256_set1_ps(0.5f), _mm256_fmadd_ps(s34_0, _mm256_set1_ps(2.0f), s12_0));
+        z30 = _mm256_fmadd_ps(s56_0, _mm256_set1_ps(0.125f), _mm256_fmadd_ps(s34_0, _mm256_set1_ps(8.0f), s12_0));
+
+        __m256 vbias = _mm256_set1_ps(bias);
+        z00 = _mm256_add_ps(vbias, z00);
+        z10 = _mm256_add_ps(vbias, z10);
+        z20 = _mm256_add_ps(vbias, z20);
+        z30 = _mm256_add_ps(vbias, z30);
+        z40 = _mm256_add_ps(vbias, z40);
+        z50 = _mm256_add_ps(vbias, z50);
+    }
+
+    if (bpptr)
+    {
+        z00 = _mm256_add_ps(z00, _mm256_loadu_ps(bpptr));
+        z10 = _mm256_add_ps(z10, _mm256_loadu_ps(bpptr + bpstep));
+        z20 = _mm256_add_ps(z20, _mm256_loadu_ps(bpptr + bpstep*2));
+        z30 = _mm256_add_ps(z30, _mm256_loadu_ps(bpptr + bpstep*3));
+        z40 = _mm256_add_ps(z40, _mm256_loadu_ps(bpptr + bpstep*4));
+        z50 = _mm256_add_ps(z50, _mm256_loadu_ps(bpptr + bpstep*5));
+    }
+
+    if (ifMinMaxAct)
+    {
+        __m256 vmax = _mm256_set1_ps(maxval);
+        __m256 vmin = _mm256_set1_ps(minval);
+
+        z00 = _mm256_min_ps(_mm256_max_ps(z00, vmin), vmax);
+        z10 = _mm256_min_ps(_mm256_max_ps(z10, vmin), vmax);
+        z20 = _mm256_min_ps(_mm256_max_ps(z20, vmin), vmax);
+        z30 = _mm256_min_ps(_mm256_max_ps(z30, vmin), vmax);
+        z40 = _mm256_min_ps(_mm256_max_ps(z40, vmin), vmax);
+        z50 = _mm256_min_ps(_mm256_max_ps(z50, vmin), vmax);
+    }
+
+    __m128 lowM, highM;
+    STORE6_ELE_FROM_16(outptr, z00, lowM, highM);
+    STORE6_ELE_FROM_16(outptr + outstep, z10, lowM, highM);
+    STORE6_ELE_FROM_16(outptr + outstep * 2, z20, lowM, highM);
+    STORE6_ELE_FROM_16(outptr + outstep * 3, z30, lowM, highM);
+    STORE6_ELE_FROM_16(outptr + outstep * 4, z40, lowM, highM);
+    STORE6_ELE_FROM_16(outptr + outstep * 5, z50, lowM, highM);
+    _mm256_zeroupper();
+}
+#endif // CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY
+
+CV_CPU_OPTIMIZATION_NAMESPACE_END
+
+// NEON code work around.
+namespace opt_NEON
+{
+
+#if !defined(CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY) && CV_NEON && CV_NEON_AARCH64
+/* Accumulate */
+void winofunc_accum_f32(const float* inwptr, const float* wptr, float* outbuf, int Cg, int iblock,
+                        const int winoIblock, const int winoKblock, const int winoAtomF32, const int winoNatomF32);
+
+/*Input transform*/
+void winofunc_BtXB_8x8_f32(const float* inptr, int inpstep,
+                            float* outptr, int Cg, const int winoIblock, const int winoAtomF32);
+
+/*Output transform*/
+void winofunc_AtXA_8x8_f32(const float* inptr, int inpstep,
+                            float* bpptr, int bpstep, float* outptr, int outstep,
+                            float bias, float minval, float maxval, bool ifMinMaxAct);
+
+void winofunc_accum_f32(const float* inwptr, const float* wptr, float* outbuf, int Cg, int iblock,
+                            const int winoIblock, const int winoKblock, const int winoAtomF32, const int winoNatomF32)
+{
+    CV_Assert(winoIblock == 6 && winoKblock == 4 && winoAtomF32 == 4);
+    if (iblock > 3)
+    {
+        for (int atom_id = 0; atom_id < winoNatomF32; atom_id++,
+                outbuf += winoAtomF32)
+        {
+            float32x4_t s00 = vdupq_n_f32(0.f), s01 = s00, s02 = s00, s03 = s00, s04 = s00, s05 = s00;
+            float32x4_t s10 = vdupq_n_f32(0.f), s11 = s00, s12 = s00, s13 = s00, s14 = s00, s15 = s00;
+            float32x4_t s20 = vdupq_n_f32(0.f), s21 = s00, s22 = s00, s23 = s00, s24 = s00, s25 = s00;
+            float32x4_t s30 = vdupq_n_f32(0.f), s31 = s00, s32 = s00, s33 = s00, s34 = s00, s35 = s00;
+            for (int c = 0; c < Cg; c++, inwptr += winoIblock*winoAtomF32,
+                                         wptr += winoKblock*winoAtomF32) {
+                float32x4_t w0 = vld1q_f32(wptr), w1 = vld1q_f32(wptr + 4);
+                float32x4_t w2 = vld1q_f32(wptr + 8), w3 = vld1q_f32(wptr + 12);
+                float32x4_t x0, x1;
+                x0 = vld1q_f32(inwptr);
+                x1 = vld1q_f32(inwptr + 4);
+                s00 = vfmaq_f32(s00, w0, x0);
+                s01 = vfmaq_f32(s01, w0, x1);
+                s10 = vfmaq_f32(s10, w1, x0);
+                s11 = vfmaq_f32(s11, w1, x1);
+                s20 = vfmaq_f32(s20, w2, x0);
+                s21 = vfmaq_f32(s21, w2, x1);
+                s30 = vfmaq_f32(s30, w3, x0);
+                s31 = vfmaq_f32(s31, w3, x1);
+                x0 = vld1q_f32(inwptr + 8);
+                x1 = vld1q_f32(inwptr + 12);
+                s02 = vfmaq_f32(s02, w0, x0);
+                s03 = vfmaq_f32(s03, w0, x1);
+                s12 = vfmaq_f32(s12, w1, x0);
+                s13 = vfmaq_f32(s13, w1, x1);
+                s22 = vfmaq_f32(s22, w2, x0);
+                s23 = vfmaq_f32(s23, w2, x1);
+                s32 = vfmaq_f32(s32, w3, x0);
+                s33 = vfmaq_f32(s33, w3, x1);
+                x0 = vld1q_f32(inwptr + 16);
+                x1 = vld1q_f32(inwptr + 20);
+                s04 = vfmaq_f32(s04, w0, x0);
+                s05 = vfmaq_f32(s05, w0, x1);
+                s14 = vfmaq_f32(s14, w1, x0);
+                s15 = vfmaq_f32(s15, w1, x1);
+                s24 = vfmaq_f32(s24, w2, x0);
+                s25 = vfmaq_f32(s25, w2, x1);
+                s34 = vfmaq_f32(s34, w3, x0);
+                s35 = vfmaq_f32(s35, w3, x1);
+            }
+
+            vst1q_f32(outbuf, s00);
+            vst1q_f32(outbuf + 1*64, s01);
+            vst1q_f32(outbuf + 2*64, s02);
+            vst1q_f32(outbuf + 3*64, s03);
+            vst1q_f32(outbuf + 4*64, s04);
+            vst1q_f32(outbuf + 5*64, s05);
+
+            vst1q_f32(outbuf + 6*64, s10);
+            vst1q_f32(outbuf + 7*64, s11);
+            vst1q_f32(outbuf + 8*64, s12);
+            vst1q_f32(outbuf + 9*64, s13);
+            vst1q_f32(outbuf + 10*64, s14);
+            vst1q_f32(outbuf + 11*64, s15);
+
+            vst1q_f32(outbuf + 12*64, s20);
+            vst1q_f32(outbuf + 13*64, s21);
+            vst1q_f32(outbuf + 14*64, s22);
+            vst1q_f32(outbuf + 15*64, s23);
+            vst1q_f32(outbuf + 16*64, s24);
+            vst1q_f32(outbuf + 17*64, s25);
+
+            vst1q_f32(outbuf + 18*64, s30);
+            vst1q_f32(outbuf + 19*64, s31);
+            vst1q_f32(outbuf + 20*64, s32);
+            vst1q_f32(outbuf + 21*64, s33);
+            vst1q_f32(outbuf + 22*64, s34);
+            vst1q_f32(outbuf + 23*64, s35);
+        }
+    }
+    else
+    {
+        for (int atom_id = 0; atom_id < winoNatomF32; atom_id++,
+                outbuf += winoAtomF32)
+        {
+            float32x4_t s00 = vdupq_n_f32(0.f), s01 = s00, s02 = s00;
+            float32x4_t s10 = vdupq_n_f32(0.f), s11 = s00, s12 = s00;
+            float32x4_t s20 = vdupq_n_f32(0.f), s21 = s00, s22 = s00;
+            float32x4_t s30 = vdupq_n_f32(0.f), s31 = s00, s32 = s00;
+            for (int c = 0; c < Cg; c++, inwptr += winoIblock*winoAtomF32,
+                                         wptr += winoKblock*winoAtomF32) {
+                float32x4_t w0 = vld1q_f32(wptr), w1 = vld1q_f32(wptr + 4);
+                float32x4_t w2 = vld1q_f32(wptr + 8), w3 = vld1q_f32(wptr + 12);
+                float32x4_t x0, x1, x2;
+                x0 = vld1q_f32(inwptr);
+                x1 = vld1q_f32(inwptr + 4);
+                x2 = vld1q_f32(inwptr + 8);
+                s00 = vfmaq_f32(s00, w0, x0);
+                s01 = vfmaq_f32(s01, w0, x1);
+                s02 = vfmaq_f32(s02, w0, x2);
+                s10 = vfmaq_f32(s10, w1, x0);
+                s11 = vfmaq_f32(s11, w1, x1);
+                s12 = vfmaq_f32(s12, w1, x2);
+                s20 = vfmaq_f32(s20, w2, x0);
+                s21 = vfmaq_f32(s21, w2, x1);
+                s22 = vfmaq_f32(s22, w2, x2);
+                s30 = vfmaq_f32(s30, w3, x0);
+                s31 = vfmaq_f32(s31, w3, x1);
+                s32 = vfmaq_f32(s32, w3, x2);
+            }
+
+            vst1q_f32(outbuf, s00);
+            vst1q_f32(outbuf + 1*64, s01);
+            vst1q_f32(outbuf + 2*64, s02);
+            vst1q_f32(outbuf + 6*64, s10);
+            vst1q_f32(outbuf + 7*64, s11);
+            vst1q_f32(outbuf + 8*64, s12);
+            vst1q_f32(outbuf + 12*64, s20);
+            vst1q_f32(outbuf + 13*64, s21);
+            vst1q_f32(outbuf + 14*64, s22);
+            vst1q_f32(outbuf + 18*64, s30);
+            vst1q_f32(outbuf + 19*64, s31);
+            vst1q_f32(outbuf + 20*64, s32);
+        }
+    }
+}
+
+#define T4x4(a, b, c, d, tr0, tr1) \
+    tr0 = vtrnq_f32(a, b); \
+    tr1 = vtrnq_f32(c, d); \
+    a = vcombine_f32(vget_low_f32(tr0.val[0]), vget_low_f32(tr1.val[0])); \
+    b = vcombine_f32(vget_low_f32(tr0.val[1]), vget_low_f32(tr1.val[1])); \
+    c = vcombine_f32(vget_high_f32(tr0.val[0]), vget_high_f32(tr1.val[0])); \
+    d = vcombine_f32(vget_high_f32(tr0.val[1]), vget_high_f32(tr1.val[1]))
+
+/*Input transform*/
+void winofunc_BtXB_8x8_f32(const float* inptr, int inpstep,
+                          float* outptr, int Cg, const int winoIblock, const int winoAtomF32)
+{
+    float32x4_t x00 = vld1q_f32(inptr), x01 = vld1q_f32(inptr + 4);
+    float32x4_t x10 = vld1q_f32(inptr + inpstep), x11 = vld1q_f32(inptr + inpstep + 4);
+    float32x4_t x20 = vld1q_f32(inptr + inpstep*2), x21 = vld1q_f32(inptr + inpstep*2 + 4);
+    float32x4_t x30 = vld1q_f32(inptr + inpstep*3), x31 = vld1q_f32(inptr + inpstep*3 + 4);
+    float32x4_t x40 = vld1q_f32(inptr + inpstep*4), x41 = vld1q_f32(inptr + inpstep*4 + 4);
+    float32x4_t x50 = vld1q_f32(inptr + inpstep*5), x51 = vld1q_f32(inptr + inpstep*5 + 4);
+    float32x4_t x60 = vld1q_f32(inptr + inpstep*6), x61 = vld1q_f32(inptr + inpstep*6 + 4);
+    float32x4_t x70 = vld1q_f32(inptr + inpstep*7), x71 = vld1q_f32(inptr + inpstep*7 + 4);
+
+    float32x4_t z00, z01, z10, z11, z20, z21, z30, z31, z40, z41, z50, z51, z60, z61, z70, z71;
+
+    {
+        /* Y[0] = [1.f, 0.f, -5.25f, 0.f, 5.25f, 0.f, -1.f, 0.f]*X */
+        /* Y[7] = [0.f, -1.f, 0.f, 5.25f, 0.f, -5.25f, 0.f, 1.f]*X */
+        float32x4_t q5_25 = vdupq_n_f32(5.25f), t00, t01, t10, t11;
+        t00 = vsubq_f32(x40, x20);
+        t01 = vsubq_f32(x41, x21);
+        t10 = vsubq_f32(x30, x50);
+        t11 = vsubq_f32(x31, x51);
+        float32x4_t y00 = vfmaq_f32(vsubq_f32(x00, x60), t00, q5_25);
+        float32x4_t y01 = vfmaq_f32(vsubq_f32(x01, x61), t01, q5_25);
+        float32x4_t y70 = vfmaq_f32(vsubq_f32(x70, x10), t10, q5_25);
+        float32x4_t y71 = vfmaq_f32(vsubq_f32(x71, x11), t11, q5_25);
+
+        /* Y[1] = [0.f, 1.f, 1.f, -4.25f, -4.25f, 1.f, 1.f, 0.f]*X */
+        /* Y[2] = [0.f, -1.f, 1.f, 4.25f, -4.25f, -1.f, 1.f, 0.f]*X */
+        float32x4_t qm4_25 = vdupq_n_f32(-4.25f);
+        t00 = vfmaq_f32(vaddq_f32(x10, x50), x30, qm4_25);
+        t01 = vfmaq_f32(vaddq_f32(x11, x51), x31, qm4_25);
+        t10 = vfmaq_f32(vaddq_f32(x20, x60), x40, qm4_25);
+        t11 = vfmaq_f32(vaddq_f32(x21, x61), x41, qm4_25);
+
+        float32x4_t y10 = vaddq_f32(t00, t10), y11 = vaddq_f32(t01, t11);
+        float32x4_t y20 = vsubq_f32(t10, t00), y21 = vsubq_f32(t11, t01);
+
+        /* Y[3] = [0.f, 0.5f, 0.25f, -2.5f, -1.25f, 2.f, 1.f, 0.f]*X */
+        /* Y[4] = [0.f, -0.5f, 0.25f, 2.5f, -1.25f, -2.f, 1.f, 0.f]*X */
+        float32x4_t q0_5 = vdupq_n_f32(0.5f), q0_25 = vdupq_n_f32(0.25f);
+        float32x4_t qm2_5 = vdupq_n_f32(-2.5f), qm1_25 = vdupq_n_f32(-1.25f);
+        t00 = vfmaq_f32(vaddq_f32(x50, x50), x10, q0_5);
+        t01 = vfmaq_f32(vaddq_f32(x51, x51), x11, q0_5);
+        t10 = vfmaq_f32(x60, x20, q0_25);
+        t11 = vfmaq_f32(x61, x21, q0_25);
+        t00 = vfmaq_f32(t00, x30, qm2_5);
+        t01 = vfmaq_f32(t01, x31, qm2_5);
+        t10 = vfmaq_f32(t10, x40, qm1_25);
+        t11 = vfmaq_f32(t11, x41, qm1_25);
+
+        float32x4_t y30 = vaddq_f32(t00, t10), y31 = vaddq_f32(t01, t11);
+        float32x4_t y40 = vsubq_f32(t10, t00), y41 = vsubq_f32(t11, t01);
+
+        /* Y[5] = [0.f, 2.f, 4.f, -2.5f, -5.f, 0.5f, 1.f, 0.f]*X */
+        /* Y[6] = [0.f, -2.f, 4.f, 2.5f, -5.f, -0.5f, 1.f, 0.f]*X */
+        float32x4_t q4 = vdupq_n_f32(4.f), qm5 = vdupq_n_f32(-5.f);
+        t00 = vfmaq_f32(vaddq_f32(x10, x10), x50, q0_5);
+        t01 = vfmaq_f32(vaddq_f32(x11, x11), x51, q0_5);
+        t10 = vfmaq_f32(x60, x20, q4);
+        t11 = vfmaq_f32(x61, x21, q4);
+        t00 = vfmaq_f32(t00, x30, qm2_5);
+        t01 = vfmaq_f32(t01, x31, qm2_5);
+        t10 = vfmaq_f32(t10, x40, qm5);
+        t11 = vfmaq_f32(t11, x41, qm5);
+
+        float32x4_t y50 = vaddq_f32(t00, t10), y51 = vaddq_f32(t01, t11);
+        float32x4_t y60 = vsubq_f32(t10, t00), y61 = vsubq_f32(t11, t01);
+
+        /* transpose 8x8 matrix in-place with some renumeration of the elements: */
+        /* Y:              */
+        /*        y00 y01  */
+        /*        y10 y11  */
+        /*        ...      */
+        /*        y70 y71  */
+        /*   Y':           */
+        /*        y00 y40  */
+        /*        y10 y50  */
+        /*        y20 y60  */
+        /*        y30 y70  */
+        /*        y01 y41  */
+        /*        y11 y51  */
+        /*        y21 y61  */
+        /*        y31 y71  */
+        /*    in other words, y40 <-> y01, y50 <-> y11, y60 <-> y21, y70 <-> y31 */
+        float32x4x2_t tr0, tr1;
+
+        T4x4(y00, y10, y20, y30, tr0, tr1);
+        T4x4(y01, y11, y21, y31, tr0, tr1);
+        T4x4(y40, y50, y60, y70, tr0, tr1);
+        T4x4(y41, y51, y61, y71, tr0, tr1);
+
+        /* Z[0] = [1.f, 0.f, -5.25f, 0.f, 5.25f, 0.f, -1.f, 0.f]*Y */
+        /* Z[7] = [0.f, -1.f, 0.f, 5.25f, 0.f, -5.25f, 0.f, 1.f]*Y */
+        t00 = vsubq_f32(y01, y20);
+        t01 = vsubq_f32(y41, y60);
+        t10 = vsubq_f32(y30, y11);
+        t11 = vsubq_f32(y70, y51);
+        z00 = vfmaq_f32(vsubq_f32(y00, y21), t00, q5_25);
+        z01 = vfmaq_f32(vsubq_f32(y40, y61), t01, q5_25);
+        z70 = vfmaq_f32(vsubq_f32(y31, y10), t10, q5_25);
+        z71 = vfmaq_f32(vsubq_f32(y71, y50), t11, q5_25);
+
+        /* Z[1] = [0.f, 1.f, 1.f, -4.25f, -4.25f, 1.f, 1.f, 0.f]*Y */
+        /* Z[2] = [0.f, -1.f, 1.f, 4.25f, -4.25f, -1.f, 1.f, 0.f]*Y */
+        t00 = vfmaq_f32(vaddq_f32(y10, y11), y30, qm4_25);
+        t01 = vfmaq_f32(vaddq_f32(y50, y51), y70, qm4_25);
+        t10 = vfmaq_f32(vaddq_f32(y20, y21), y01, qm4_25);
+        t11 = vfmaq_f32(vaddq_f32(y60, y61), y41, qm4_25);
+
+        z10 = vaddq_f32(t00, t10); z11 = vaddq_f32(t01, t11);
+        z20 = vsubq_f32(t10, t00); z21 = vsubq_f32(t11, t01);
+
+        /* Z[3] = [0.f, 0.5f, 0.25f, -2.5f, -1.25f, 2.f, 1.f, 0.f]*Y */
+        /* Z[4] = [0.f, -0.5f, 0.25f, 2.5f, -1.25f, -2.f, 1.f, 0.f]*Y */
+        t00 = vfmaq_f32(vaddq_f32(y11, y11), y10, q0_5);
+        t01 = vfmaq_f32(vaddq_f32(y51, y51), y50, q0_5);
+        t10 = vfmaq_f32(y21, y20, q0_25);
+        t11 = vfmaq_f32(y61, y60, q0_25);
+        t00 = vfmaq_f32(t00, y30, qm2_5);
+        t01 = vfmaq_f32(t01, y70, qm2_5);
+        t10 = vfmaq_f32(t10, y01, qm1_25);
+        t11 = vfmaq_f32(t11, y41, qm1_25);
+
+        z30 = vaddq_f32(t00, t10); z31 = vaddq_f32(t01, t11);
+        z40 = vsubq_f32(t10, t00); z41 = vsubq_f32(t11, t01);
+
+        /* Z[5] = [0.f, 2.f, 4.f, -2.5f, -5.f, 0.5f, 1.f, 0.f]*Y */
+        /* Z[6] = [0.f, -2.f, 4.f, 2.5f, -5.f, -0.5f, 1.f, 0.f]*Y */
+        t00 = vfmaq_f32(vaddq_f32(y10, y10), y11, q0_5);
+        t01 = vfmaq_f32(vaddq_f32(y50, y50), y51, q0_5);
+        t10 = vfmaq_f32(y21, y20, q4);
+        t11 = vfmaq_f32(y61, y60, q4);
+        t00 = vfmaq_f32(t00, y30, qm2_5);
+        t01 = vfmaq_f32(t01, y70, qm2_5);
+        t10 = vfmaq_f32(t10, y01, qm5);
+        t11 = vfmaq_f32(t11, y41, qm5);
+
+        z50 = vaddq_f32(t00, t10); z51 = vaddq_f32(t01, t11);
+        z60 = vsubq_f32(t10, t00); z61 = vsubq_f32(t11, t01);
+    }
+
+    const int outstep = winoIblock*winoAtomF32*Cg;
+
+    vst1q_f32(outptr, z00);
+    vst1q_f32(outptr + outstep, z01);
+    vst1q_f32(outptr + outstep*2, z10);
+    vst1q_f32(outptr + outstep*3, z11);
+    vst1q_f32(outptr + outstep*4, z20);
+    vst1q_f32(outptr + outstep*5, z21);
+    vst1q_f32(outptr + outstep*6, z30);
+    vst1q_f32(outptr + outstep*7, z31);
+    vst1q_f32(outptr + outstep*8, z40);
+    vst1q_f32(outptr + outstep*9, z41);
+    vst1q_f32(outptr + outstep*10, z50);
+    vst1q_f32(outptr + outstep*11, z51);
+    vst1q_f32(outptr + outstep*12, z60);
+    vst1q_f32(outptr + outstep*13, z61);
+    vst1q_f32(outptr + outstep*14, z70);
+    vst1q_f32(outptr + outstep*15, z71);
+}
+
+/*Output transform*/
+void winofunc_AtXA_8x8_f32(const float* inptr, int inpstep,
+                          float* bpptr, int bpstep, float* outptr, int outstep,
+                          float bias, float minval, float maxval, bool ifMinMaxAct)
+{
+    float32x4_t x00 = vld1q_f32(inptr), x01 = vld1q_f32(inptr + 4);
+    float32x4_t x10 = vld1q_f32(inptr + inpstep), x11 = vld1q_f32(inptr + inpstep + 4);
+    float32x4_t x20 = vld1q_f32(inptr + inpstep*2), x21 = vld1q_f32(inptr + inpstep*2 + 4);
+    float32x4_t x30 = vld1q_f32(inptr + inpstep*3), x31 = vld1q_f32(inptr + inpstep*3 + 4);
+    float32x4_t x40 = vld1q_f32(inptr + inpstep*4), x41 = vld1q_f32(inptr + inpstep*4 + 4);
+    float32x4_t x50 = vld1q_f32(inptr + inpstep*5), x51 = vld1q_f32(inptr + inpstep*5 + 4);
+    float32x4_t x60 = vld1q_f32(inptr + inpstep*6), x61 = vld1q_f32(inptr + inpstep*6 + 4);
+    float32x4_t x70 = vld1q_f32(inptr + inpstep*7), x71 = vld1q_f32(inptr + inpstep*7 + 4);
+    float32x4_t z00, z01, z10, z11, z20, z21, z30, z31, z40, z41, z50, z51;
+
+    {
+        float32x4_t s12_0, s12_1, s34_0, s34_1, s56_0, s56_1;
+        s12_0 = vaddq_f32(x10, x20); s12_1 = vaddq_f32(x11, x21);
+        s34_0 = vaddq_f32(x30, x40); s34_1 = vaddq_f32(x31, x41);
+        s56_0 = vaddq_f32(x50, x60); s56_1 = vaddq_f32(x51, x61);
+
+        float32x4_t y00 = vaddq_f32(vaddq_f32(vaddq_f32(x00, s12_0), s34_0), s56_0);
+        float32x4_t y01 = vaddq_f32(vaddq_f32(vaddq_f32(x01, s12_1), s34_1), s56_1);
+        float32x4_t y20 = vfmaq_n_f32(vfmaq_n_f32(s12_0, s34_0, 4.0f), s56_0, 0.25f);
+        float32x4_t y21 = vfmaq_n_f32(vfmaq_n_f32(s12_1, s34_1, 4.0f), s56_1, 0.25f);
+        float32x4_t y40 = vfmaq_n_f32(vfmaq_n_f32(s12_0, s34_0, 16.0f), s56_0, 1.f/16);
+        float32x4_t y41 = vfmaq_n_f32(vfmaq_n_f32(s12_1, s34_1, 16.0f), s56_1, 1.f/16);
+
+        s12_0 = vsubq_f32(x10, x20); s12_1 = vsubq_f32(x11, x21);
+        s34_0 = vsubq_f32(x30, x40); s34_1 = vsubq_f32(x31, x41);
+        s56_0 = vsubq_f32(x50, x60); s56_1 = vsubq_f32(x51, x61);
+
+        float32x4_t y50 = vfmaq_n_f32(vfmaq_n_f32(vaddq_f32(x70, s12_0),
+                                      s34_0, 32.f), s56_0, 1.f/32);
+        float32x4_t y51 = vfmaq_n_f32(vfmaq_n_f32(vaddq_f32(x71, s12_1),
+                                      s34_1, 32.f), s56_1, 1.f/32);
+        float32x4_t y10 = vfmaq_n_f32(vfmaq_n_f32(s12_0, s34_0, 2.0f), s56_0, 0.5f);
+        float32x4_t y11 = vfmaq_n_f32(vfmaq_n_f32(s12_1, s34_1, 2.0f), s56_1, 0.5f);
+        float32x4_t y30 = vfmaq_n_f32(vfmaq_n_f32(s12_0, s34_0, 8.0f), s56_0, 0.125f);
+        float32x4_t y31 = vfmaq_n_f32(vfmaq_n_f32(s12_1, s34_1, 8.0f), s56_1, 0.125f);
+        float32x4_t y60 = vdupq_n_f32(0.f), y61 = y60, y70 = y60, y71 = y60;
+
+        /* transpose 8x8 matrix in-place with some renumeration of the elements: */
+        /*  Y: */
+        /*        y00 y01 */
+        /*        y10 y11 */
+        /*        ... */
+        /*        y50 y51 */
+        /*        0   0 */
+        /*        0   0 */
+        /*   Y': */
+        /*        y00 y40 */
+        /*        y10 y50 */
+        /*        y20 y60 */
+        /*        y30 y70 */
+        /*        y01 y41 */
+        /*        y11 y51 */
+        /*        y21 y61 */
+        /*        y31 y71 */
+        /*    in other words, y40 <-> y01, y50 <-> y11, y60 <-> y21, y70 <-> y31 */
+        float32x4x2_t tr0, tr1;
+
+        T4x4(y00, y10, y20, y30, tr0, tr1);
+        T4x4(y01, y11, y21, y31, tr0, tr1);
+        T4x4(y40, y50, y60, y70, tr0, tr1);
+        T4x4(y41, y51, y61, y71, tr0, tr1);
+
+        s12_0 = vaddq_f32(y10, y20); s12_1 = vaddq_f32(y50, y60);
+        s34_0 = vaddq_f32(y30, y01); s34_1 = vaddq_f32(y70, y41);
+        s56_0 = vaddq_f32(y11, y21); s56_1 = vaddq_f32(y51, y61);
+
+        z00 = vaddq_f32(vaddq_f32(vaddq_f32(y00, s12_0), s34_0), s56_0);
+        z01 = vaddq_f32(vaddq_f32(vaddq_f32(y40, s12_1), s34_1), s56_1);
+        z20 = vfmaq_n_f32(vfmaq_n_f32(s12_0, s34_0, 4.0f), s56_0, 0.25f);
+        z21 = vfmaq_n_f32(vfmaq_n_f32(s12_1, s34_1, 4.0f), s56_1, 0.25f);
+        z40 = vfmaq_n_f32(vfmaq_n_f32(s12_0, s34_0, 16.0f), s56_0, 1.f/16);
+        z41 = vfmaq_n_f32(vfmaq_n_f32(s12_1, s34_1, 16.0f), s56_1, 1.f/16);
+
+        s12_0 = vsubq_f32(y10, y20); s12_1 = vsubq_f32(y50, y60);
+        s34_0 = vsubq_f32(y30, y01); s34_1 = vsubq_f32(y70, y41);
+        s56_0 = vsubq_f32(y11, y21); s56_1 = vsubq_f32(y51, y61);
+
+        z50 = vfmaq_n_f32(vfmaq_n_f32(vaddq_f32(y31, s12_0),
+                          s34_0, 32.f), s56_0, 1.f/32);
+        z51 = vfmaq_n_f32(vfmaq_n_f32(vaddq_f32(y71, s12_1),
+                          s34_1, 32.f), s56_1, 1.f/32);
+        z10 = vfmaq_n_f32(vfmaq_n_f32(s12_0, s34_0, 2.0f), s56_0, 0.5f);
+        z11 = vfmaq_n_f32(vfmaq_n_f32(s12_1, s34_1, 2.0f), s56_1, 0.5f);
+        z30 = vfmaq_n_f32(vfmaq_n_f32(s12_0, s34_0, 8.0f), s56_0, 0.125f);
+        z31 = vfmaq_n_f32(vfmaq_n_f32(s12_1, s34_1, 8.0f), s56_1, 0.125f);
+        float32x4_t vbias = vdupq_n_f32(bias);
+
+        z00 = vaddq_f32(z00, vbias);
+        z01 = vaddq_f32(z01, vbias);
+        z10 = vaddq_f32(z10, vbias);
+        z11 = vaddq_f32(z11, vbias);
+        z20 = vaddq_f32(z20, vbias);
+        z21 = vaddq_f32(z21, vbias);
+        z30 = vaddq_f32(z30, vbias);
+        z31 = vaddq_f32(z31, vbias);
+        z40 = vaddq_f32(z40, vbias);
+        z41 = vaddq_f32(z41, vbias);
+        z50 = vaddq_f32(z50, vbias);
+        z51 = vaddq_f32(z51, vbias);
+    }
+
+    if (bpptr)
+    {
+        float32x2_t zhalf = vdup_n_f32(0.f);
+        z00 = vaddq_f32(z00, vld1q_f32(bpptr));
+        z01 = vaddq_f32(z01, vcombine_f32(vld1_f32(bpptr + 4), zhalf));
+        z10 = vaddq_f32(z10, vld1q_f32(bpptr + bpstep));
+        z11 = vaddq_f32(z11, vcombine_f32(vld1_f32(bpptr + bpstep + 4), zhalf));
+        z20 = vaddq_f32(z20, vld1q_f32(bpptr + bpstep*2));
+        z21 = vaddq_f32(z21, vcombine_f32(vld1_f32(bpptr + bpstep*2 + 4), zhalf));
+        z30 = vaddq_f32(z30, vld1q_f32(bpptr + bpstep*3));
+        z31 = vaddq_f32(z31, vcombine_f32(vld1_f32(bpptr + bpstep*3 + 4), zhalf));
+        z40 = vaddq_f32(z40, vld1q_f32(bpptr + bpstep*4));
+        z41 = vaddq_f32(z41, vcombine_f32(vld1_f32(bpptr + bpstep*4 + 4), zhalf));
+        z50 = vaddq_f32(z50, vld1q_f32(bpptr + bpstep*5));
+        z51 = vaddq_f32(z51, vcombine_f32(vld1_f32(bpptr + bpstep*5 + 4), zhalf));
+    }
+
+    if (ifMinMaxAct)
+    {
+        float32x4_t vmax = vdupq_n_f32(maxval);
+        float32x4_t vmin = vdupq_n_f32(minval);
+
+        z00 = vminq_f32(vmaxq_f32(z00, vmin), vmax);
+        z01 = vminq_f32(vmaxq_f32(z01, vmin), vmax);
+        z10 = vminq_f32(vmaxq_f32(z10, vmin), vmax);
+        z11 = vminq_f32(vmaxq_f32(z11, vmin), vmax);
+        z20 = vminq_f32(vmaxq_f32(z20, vmin), vmax);
+        z21 = vminq_f32(vmaxq_f32(z21, vmin), vmax);
+        z30 = vminq_f32(vmaxq_f32(z30, vmin), vmax);
+        z31 = vminq_f32(vmaxq_f32(z31, vmin), vmax);
+        z40 = vminq_f32(vmaxq_f32(z40, vmin), vmax);
+        z41 = vminq_f32(vmaxq_f32(z41, vmin), vmax);
+        z50 = vminq_f32(vmaxq_f32(z50, vmin), vmax);
+        z51 = vminq_f32(vmaxq_f32(z51, vmin), vmax);
+    }
+
+    vst1q_f32(outptr, z00);
+    vst1_f32(outptr + 4, vget_low_f32(z01));
+    vst1q_f32(outptr + outstep, z10);
+    vst1_f32(outptr + outstep + 4, vget_low_f32(z11));
+    vst1q_f32(outptr + outstep*2, z20);
+    vst1_f32(outptr + outstep*2 + 4, vget_low_f32(z21));
+    vst1q_f32(outptr + outstep*3, z30);
+    vst1_f32(outptr + outstep*3 + 4, vget_low_f32(z31));
+    vst1q_f32(outptr + outstep*4, z40);
+    vst1_f32(outptr + outstep*4 + 4, vget_low_f32(z41));
+    vst1q_f32(outptr + outstep*5, z50);
+    vst1_f32(outptr + outstep*5 + 4, vget_low_f32(z51));
+}
+
+#endif
+}
+
+}} // namespace

modules/dnn/src/layers/cpu_kernels/convolution.hpp

@@ -10,39 +10,58 @@
 #ifndef CONV_PRAM
 #define CONV_PRAM
 #if CV_NEON && CV_NEON_AARCH64  // 32 registers.
-#define CONV_MR 4
-#define CONV_NR 28
+#define CONV_MR_FP32 4
+#define CONV_NR_FP32 28
+
+// The FP16 can only be supported by ARM64 and with FP16 FMA supported.
+#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC // check FP16 FMA.
+#define CONV_ARM_FP16 1
+#endif
+
+#ifdef CONV_ARM_FP16
+// Currently, only ARM 64 support FP16.
+#define CONV_MR_FP16 8
+#define CONV_NR_FP16 24
+typedef __fp16 float16_t; // Fix conflict between float16_t in arm_neon.h and float16_t in cvdef.h.
+#endif
+
 #elif CV_NEON              // 16 registers.
-#define CONV_MR 4
-#define CONV_NR 12
+#define CONV_MR_FP32 4
+#define CONV_NR_FP32 12
 #else // SIMD 128, AVX or AVX2
-#define CONV_MR 4
-#define CONV_NR 24
+#define CONV_MR_FP32 4
+#define CONV_NR_FP32 24
 #endif
 
 // Winograd Params
 enum {
-    _FX_WINO_STEP=6,
-    _FX_WINO_KSIZE=3,
-    _FX_WINO_SIZE=_FX_WINO_STEP+_FX_WINO_KSIZE-1,
-    _FX_WINO_AREA=_FX_WINO_SIZE*_FX_WINO_SIZE,
+    CONV_WINO_STEP=6,
+    CONV_WINO_KSIZE=3,
+    CONV_WINO_SIZE=CONV_WINO_STEP+CONV_WINO_KSIZE-1, // 8
+    CONV_WINO_AREA=CONV_WINO_SIZE*CONV_WINO_SIZE,
 
-    _FX_WINO_KBLOCK = 4,
-#if (CV_NEON && CV_NEON_AARCH64) || CV_TRY_AVX2
-    _FX_WINO_IBLOCK = 6,
+    CONV_WINO_KBLOCK = 4,
+#if (CV_NEON && CV_NEON_AARCH64) || CV_TRY_AVX || CV_TRY_AVX2
+    CONV_WINO_IBLOCK = 6,
 #else
-    _FX_WINO_IBLOCK = 3,
+    CONV_WINO_IBLOCK = 3,
 #endif
 
-#if CV_TRY_AVX2
-    _FX_WINO_ATOM_F32 = 8,
+#if CV_TRY_AVX || CV_TRY_AVX2
+    CONV_WINO_ATOM_F32 = 8,
 #else
-    _FX_WINO_ATOM_F32 = 4,
+    CONV_WINO_ATOM_F32 = 4,
 #endif
 
-    _FX_WINO_NATOMS_F32 = _FX_WINO_AREA / _FX_WINO_ATOM_F32, // for AVX2, it is 8, otherwise, it's 16.
+    CONV_WINO_NATOMS_F32 = CONV_WINO_AREA / CONV_WINO_ATOM_F32, // for AVX2, it is 8, otherwise, it's 16.
+
+    // FP 16
+    CONV_WINO_ATOM_F16 = CONV_WINO_ATOM_F32 * 2,
+    CONV_WINO_NATOMS_F16 = CONV_WINO_AREA / CONV_WINO_ATOM_F16,
 };
-enum { _FX_CONV_TYPE_GENERIC=0, _FX_CONV_TYPE_DEPTHWISE=1, _FX_CONV_TYPE_WINOGRAD3X3=2, _FX_CONV_TYPE_DEPTHWISE_REMAIN=3 };
+
+// NOTE that: CONV_TYPE_DEPTHWISE is for 3x3 depthwise conv, and others depthwise will be set as CONV_TYPE_DEPTHWISE_REMAIN.
+enum { CONV_TYPE_GENERIC=0, CONV_TYPE_DEPTHWISE=1, CONV_TYPE_WINOGRAD3X3=2, CONV_TYPE_DEPTHWISE_REMAIN=3 };
 enum { CONV_1D = 0, CONV_2D = 1, CONV_3D = 2 };
 #endif
 
@@ -62,8 +81,17 @@ struct FastConv
     std::vector<float> weightsWinoBuf; // For Winograd F(6x6, 3x3).
     float* weightsWinoBufPtr;
     std::vector<float> biasBuf;
+
+#if CV_NEON && CV_NEON_AARCH64 && CV_FP16
+    std::vector<float16_t> weightsBuf_FP16;
+    float16_t* weightsBufPtr_FP16;
+    std::vector<float16_t> weightsWinoBuf_FP16;
+    float16_t* weightsWinoBufPtr_FP16;
+#endif
+
     int conv_type;
     int conv_dim;  // Flag for conv1d, conv2d, or conv3d.
+    bool useFP16 = false; // Only ARMv8 is supported.
 #if CV_SIMD128
     bool useSIMD128 = true;
 #else
@@ -93,6 +121,7 @@ Ptr<FastConv> initFastConv(
         const std::vector<size_t>& pads_begin,
         const std::vector<size_t>& pads_end,
         int conv_dim,
+        const bool useFP16,
         bool useWinograd);
 
 // It contains different computing branches, like winograd, 1x1 conv.
@@ -105,22 +134,6 @@ void runDepthwise(InputArray _input, OutputArray _output, const Ptr<FastConv>& c
 int runWinograd63(InputArray _input, InputArray _fusedAddMat, OutputArray _output, const Ptr<FastConv>& conv, int ntasks,
                   float minval, float maxval, ActivationLayer* activ, bool ifMinMaxAct);
 
-namespace opt_AVX2
-{
-#if CV_TRY_AVX2
-void convBlock_AVX2(int np, const float* a, const float* b, float* c, int ldc, bool init_c);
-
-void convBlockMR1(int np, const float* a, const float* b, float *c, const float bias, bool init_c, const float minval,
-                  const float maxval, bool ifMinMaxAct);
-
-void _fx_winograd_accum_f32(const float* inwptr, const float* wptr, float* outbuf, int Cg, int iblock);
-void _fx_winograd_BtXB_8x8_f32(const float* inptr, int inpstep, float* outptr, int Cg);
-void _fx_winograd_AtXA_8x8_f32(const float* inptr, int inpstep, float* bpptr, int bpstep, float* outptr, int outstep,
-                               float bias, float minval, float maxval, bool ifMinMaxAct);
-
-#endif
-} // namespace opt_AVX2
-
 } // namespace dnn
 } // namespace cv
 

modules/dnn/src/layers/elementwise_layers.cpp

@@ -188,9 +188,11 @@ public:
     }
 
 #ifdef HAVE_CANN
-    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
+    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputs,
+                                      const std::vector<Ptr<BackendWrapper> > &outputs,
+                                      const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
     {
-        return func.initCannOp(inputsWrapper, index, nodes);
+        return func.initCannOp(Layer::name, inputs, nodes);
     }
 #endif // HAVE_CANN
 
@@ -214,13 +216,6 @@ public:
     }
 #endif
 
-    virtual Ptr<BackendNode> initVkCom(const std::vector<Ptr<BackendWrapper> >& inputs) CV_OVERRIDE
-    {
-#ifdef HAVE_VULKAN
-        return Ptr<BackendNode>(new VkComBackendNode(inputs, func.initVkCom()));
-#endif  // HAVE_VULKAN
-        return Ptr<BackendNode>();
-    }
 
     virtual bool tryFuse(Ptr<dnn::Layer>& top) CV_OVERRIDE
     {
@@ -357,7 +352,6 @@ struct ReLUFunctor : public BaseFunctor
         return backendId == DNN_BACKEND_OPENCV ||
                backendId == DNN_BACKEND_CUDA ||
                backendId == DNN_BACKEND_HALIDE ||
-               backendId == DNN_BACKEND_VKCOM ||
                backendId == DNN_BACKEND_CANN;
     }
 
@@ -459,9 +453,11 @@ struct ReLUFunctor : public BaseFunctor
 #endif  // HAVE_HALIDE
 
 #ifdef HAVE_CANN
-    Ptr<BackendNode> initCannOp(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes)
+    Ptr<BackendNode> initCannOp(const std::string& name,
+                                const std::vector<Ptr<BackendWrapper> > &inputs,
+                                const std::vector<Ptr<BackendNode> >& nodes)
     {
-        auto x = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
+        auto x = inputs[0].dynamicCast<CannBackendWrapper>();
         auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
         auto x_desc = x->getTensorDesc();
 
@@ -469,10 +465,9 @@ struct ReLUFunctor : public BaseFunctor
 
         if (slope)
         {
-            std::string op_name = cv::format("leakyrelu_%d", index);
-            auto op = std::make_shared<ge::op::LeakyRelu>(op_name);
+            auto op = std::make_shared<ge::op::LeakyRelu>(name);
 
-            op->set_input_x_by_name(*op_x, "y");
+            op->set_input_x_by_name(*op_x, x->name.c_str());
             op->update_input_desc_x(*x_desc);
 
             op->set_attr_negative_slope(slope);
@@ -482,10 +477,9 @@ struct ReLUFunctor : public BaseFunctor
             return Ptr<BackendNode>(new CannBackendNode(op));
         }
 
-        std::string op_name = cv::format("relu_%d", index);
-        auto op = std::make_shared<ge::op::Relu>(op_name); // FIXIT: Relu6?
+        auto op = std::make_shared<ge::op::Relu>(name);
 
-        op->set_input_x_by_name(*op_x, "y");
+        op->set_input_x_by_name(*op_x, x->name.c_str());
         op->update_input_desc_x(*x_desc);
 
         op->update_output_desc_y(*output_desc);
@@ -512,14 +506,6 @@ struct ReLUFunctor : public BaseFunctor
     }
 #endif
 
-#ifdef HAVE_VULKAN
-    std::shared_ptr<vkcom::OpBase> initVkCom()
-    {
-        std::shared_ptr<vkcom::OpBase> op(new vkcom::OpReLU(slope));
-        return op;
-    }
-#endif  // HAVE_VULKAN
-
     bool tryQuantize(const std::vector<std::vector<float> > &scales,
                      const std::vector<std::vector<int> > &zeropoints, LayerParams& params)
     {
@@ -653,28 +639,29 @@ struct ReLU6Functor : public BaseFunctor
 #endif  // HAVE_HALIDE
 
 #ifdef HAVE_CANN
-    Ptr<BackendNode> initCannOp(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes)
+    Ptr<BackendNode> initCannOp(const std::string& name,
+                                const std::vector<Ptr<BackendWrapper> > &inputs,
+                                const std::vector<Ptr<BackendNode> >& nodes)
     {
-        auto x = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
+        auto x = inputs[0].dynamicCast<CannBackendWrapper>();
 
-        std::string op_name = cv::format("clip_%d", index);
-        auto op = std::make_shared<ge::op::ClipByValue>(op_name);
+        auto op = std::make_shared<ge::op::ClipByValue>(name);
 
         auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
-        op->set_input_x_by_name(*op_x, "y");
+        op->set_input_x_by_name(*op_x, x->name.c_str());
         auto x_desc = x->getTensorDesc();
         op->update_input_desc_x(*x_desc);
 
         Mat min_value_mat(1, 1, CV_32F, Scalar(minValue));
         std::vector<int> shape_{1};
-        auto op_const_minv = std::make_shared<CannConstOp>(min_value_mat.data, min_value_mat.type(), shape_, cv::format("%s_min_value", op_name.c_str()));
+        auto op_const_minv = std::make_shared<CannConstOp>(min_value_mat.data, min_value_mat.type(), shape_, cv::format("%s_min_value", name.c_str()));
         op->set_input_clip_value_min(*(op_const_minv->getOp()));
         op->update_input_desc_clip_value_min(*(op_const_minv->getTensorDesc()));
 
         Mat max_value_mat(1, 1, CV_32F, Scalar(maxValue));
-        auto op_const_maxv = std::make_shared<CannConstOp>(max_value_mat.data, max_value_mat.type(), shape_, cv::format("%s_max_value", op_name.c_str()));
-        op->set_input_clip_value_min(*(op_const_maxv->getOp()));
-        op->update_input_desc_clip_value_min(*(op_const_maxv->getTensorDesc()));
+        auto op_const_maxv = std::make_shared<CannConstOp>(max_value_mat.data, max_value_mat.type(), shape_, cv::format("%s_max_value", name.c_str()));
+        op->set_input_clip_value_max(*(op_const_maxv->getOp()));
+        op->update_input_desc_clip_value_max(*(op_const_maxv->getTensorDesc()));
 
         auto output_desc = std::make_shared<ge::TensorDesc>(ge::Shape(), ge::FORMAT_NCHW, ge::DT_FLOAT);
         op->update_output_desc_y(*output_desc);
@@ -703,14 +690,6 @@ struct ReLU6Functor : public BaseFunctor
     }
 #endif
 
-#ifdef HAVE_VULKAN
-    std::shared_ptr<vkcom::OpBase> initVkCom()
-    {
-        // TODO: add vkcom implementation
-        return std::shared_ptr<vkcom::OpBase>();
-    }
-#endif  // HAVE_VULKAN
-
     bool tryQuantize(const std::vector<std::vector<float> > &scales,
                      const std::vector<std::vector<int> > &zeropoints, LayerParams& params)
     {
@@ -805,7 +784,9 @@ struct BaseDefaultFunctor : public BaseFunctor
 #endif  // HAVE_HALIDE
 
 #ifdef HAVE_CANN
-    Ptr<BackendNode> initCannOp(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes)
+    Ptr<BackendNode> initCannOp(const std::string& name,
+                                const std::vector<Ptr<BackendWrapper> > &inputs,
+                                const std::vector<Ptr<BackendNode> >& nodes)
     {
         CV_Error(Error::StsNotImplemented, "");
     }
@@ -825,18 +806,61 @@ struct BaseDefaultFunctor : public BaseFunctor
     }
 #endif
 
-#ifdef HAVE_VULKAN
-    std::shared_ptr<vkcom::OpBase> initVkCom()
-    {
-        // TODO: add vkcom implementation
-        return std::shared_ptr<vkcom::OpBase>();
-    }
-#endif  // HAVE_VULKAN
-
 private:
     static const char* const ocl_kernel_name;
 };
 
+struct GeluFunctor : public BaseDefaultFunctor<GeluFunctor>
+{
+    typedef GeluLayer Layer;
+
+    explicit GeluFunctor() {}
+
+    bool supportBackend(int backendId, int)
+    {
+        return backendId == DNN_BACKEND_OPENCV;
+    }
+
+    inline float calculate(float x) const
+    {
+        return 0.5f * x * (1.0f + erf(x * M_SQRT1_2));
+    }
+
+    int64 getFLOPSPerElement() const { return 100; }
+};
+
+template<>
+const char* const BaseDefaultFunctor<GeluFunctor>::ocl_kernel_name = "GeluForward";
+
+namespace GeluApproximationConstants
+{
+    static constexpr float sqrt_2_pi = 0.7978845834732056f;
+    static constexpr float coef_sqrt_2_pi = 0.044714998453855515f * sqrt_2_pi;
+}
+
+struct GeluApproximationFunctor : public BaseDefaultFunctor<GeluApproximationFunctor>
+{
+    typedef GeluApproximationLayer Layer;
+
+    explicit GeluApproximationFunctor() {}
+
+    bool supportBackend(int backendId, int)
+    {
+        return backendId == DNN_BACKEND_OPENCV;
+    }
+
+    inline float calculate(float x) const
+    {
+        return 0.5f * x * (1.f + tanh(x * (GeluApproximationConstants::sqrt_2_pi +
+                                           GeluApproximationConstants::coef_sqrt_2_pi * x * x)));
+    }
+
+    int64 getFLOPSPerElement() const { return 100; }
+};
+
+template<>
+const char* const BaseDefaultFunctor<GeluApproximationFunctor>::ocl_kernel_name = "GeluApproximationForward";
+
 struct TanHFunctor : public BaseDefaultFunctor<TanHFunctor>
 {
     typedef TanHLayer Layer;
@@ -874,15 +898,16 @@ struct TanHFunctor : public BaseDefaultFunctor<TanHFunctor>
 #endif  // HAVE_HALIDE
 
 #ifdef HAVE_CANN
-    Ptr<BackendNode> initCannOp(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes)
+    Ptr<BackendNode> initCannOp(const std::string& name,
+                                const std::vector<Ptr<BackendWrapper> > &inputs,
+                                const std::vector<Ptr<BackendNode> >& nodes)
     {
-        auto x = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
+        auto x = inputs[0].dynamicCast<CannBackendWrapper>();
 
-        std::string op_name = cv::format("tanh_%d", index);
-        auto op = std::make_shared<ge::op::Tanh>(op_name);
+        auto op = std::make_shared<ge::op::Tanh>(name);
 
         auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
-        op->set_input_x_by_name(*op_x, "y");
+        op->set_input_x_by_name(*op_x, x->name.c_str());
         auto x_desc = x->getTensorDesc();
         op->update_input_desc_x(*x_desc);
 
@@ -940,17 +965,18 @@ struct SwishFunctor : public BaseDefaultFunctor<SwishFunctor>
 #endif  // HAVE_HALIDE
 
 #ifdef HAVE_CANN
-    Ptr<BackendNode> initCannOp(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes)
+    Ptr<BackendNode> initCannOp(const std::string& name,
+                                const std::vector<Ptr<BackendWrapper> > &inputs,
+                                const std::vector<Ptr<BackendNode> >& nodes)
     {
-        auto x = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
+        auto x = inputs[0].dynamicCast<CannBackendWrapper>();
 
-        std::string op_name = cv::format("swish_%d", index);
-        auto op = std::make_shared<ge::op::Swish>(op_name);
+        auto op = std::make_shared<ge::op::Swish>(name);
 
         op->set_attr_scale(1.0f);
 
         auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
-        op->set_input_x_by_name(*op_x, "y");
+        op->set_input_x_by_name(*op_x, x->name.c_str());
         auto x_desc = x->getTensorDesc();
         op->update_input_desc_x(*x_desc);
 
@@ -1017,15 +1043,16 @@ struct MishFunctor : public BaseDefaultFunctor<MishFunctor>
 #endif  // HAVE_HALIDE
 
 #ifdef HAVE_CANN
-    Ptr<BackendNode> initCannOp(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes)
+    Ptr<BackendNode> initCannOp(const std::string& name,
+                                const std::vector<Ptr<BackendWrapper> > &inputs,
+                                const std::vector<Ptr<BackendNode> >& nodes)
     {
-        auto x = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
+        auto x = inputs[0].dynamicCast<CannBackendWrapper>();
 
-        std::string op_name = cv::format("mish_%d", index);
-        auto op = std::make_shared<ge::op::Mish>(op_name);
+        auto op = std::make_shared<ge::op::Mish>(name);
 
         auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
-        op->set_input_x_by_name(*op_x, "y");
+        op->set_input_x_by_name(*op_x, x->name.c_str());
         auto x_desc = x->getTensorDesc();
         op->update_input_desc_x(*x_desc);
 
@@ -1092,15 +1119,16 @@ struct SigmoidFunctor : public BaseDefaultFunctor<SigmoidFunctor>
 #endif  // HAVE_HALIDE
 
 #ifdef HAVE_CANN
-    Ptr<BackendNode> initCannOp(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes)
+    Ptr<BackendNode> initCannOp(const std::string& name,
+                                const std::vector<Ptr<BackendWrapper> > &inputs,
+                                const std::vector<Ptr<BackendNode> >& nodes)
     {
-        auto x = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
+        auto x = inputs[0].dynamicCast<CannBackendWrapper>();
 
-        std::string op_name = cv::format("sigmoid_%d", index);
-        auto op = std::make_shared<ge::op::Sigmoid>(op_name);
+        auto op = std::make_shared<ge::op::Sigmoid>(name);
 
         auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
-        op->set_input_x_by_name(*op_x, "y");
+        op->set_input_x_by_name(*op_x, x->name.c_str());
         auto x_desc = x->getTensorDesc();
         op->update_input_desc_x(*x_desc);
 
@@ -1169,17 +1197,18 @@ struct ELUFunctor : public BaseDefaultFunctor<ELUFunctor>
 #endif  // HAVE_HALIDE
 
 #ifdef HAVE_CANN
-    Ptr<BackendNode> initCannOp(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes)
+    Ptr<BackendNode> initCannOp(const std::string& name,
+                                const std::vector<Ptr<BackendWrapper> > &inputs,
+                                const std::vector<Ptr<BackendNode> >& nodes)
     {
-        auto x = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
+        auto x = inputs[0].dynamicCast<CannBackendWrapper>();
 
-        std::string op_name = cv::format("elu_%d", index);
-        auto op = std::make_shared<ge::op::Elu>(op_name);
+        auto op = std::make_shared<ge::op::Elu>(name);
 
         op->set_attr_alpha(alpha);
 
         auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
-        op->set_input_x_by_name(*op_x, "y");
+        op->set_input_x_by_name(*op_x, x->name.c_str());
         auto x_desc = x->getTensorDesc();
         op->update_input_desc_x(*x_desc);
 
@@ -1240,15 +1269,16 @@ struct AbsValFunctor : public BaseDefaultFunctor<AbsValFunctor>
 #endif  // HAVE_HALIDE
 
 #ifdef HAVE_CANN
-    Ptr<BackendNode> initCannOp(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes)
+    Ptr<BackendNode> initCannOp(const std::string& name,
+                                const std::vector<Ptr<BackendWrapper> > &inputs,
+                                const std::vector<Ptr<BackendNode> >& nodes)
     {
-        auto x = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
+        auto x = inputs[0].dynamicCast<CannBackendWrapper>();
 
-        std::string op_name = cv::format("abs_%d", index);
-        auto op = std::make_shared<ge::op::Abs>(op_name);
+        auto op = std::make_shared<ge::op::Abs>(name);
 
         auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
-        op->set_input_x_by_name(*op_x, "y");
+        op->set_input_x_by_name(*op_x, x->name.c_str());
         auto x_desc = x->getTensorDesc();
         op->update_input_desc_x(*x_desc);
 
@@ -1301,15 +1331,16 @@ struct BNLLFunctor : public BaseDefaultFunctor<BNLLFunctor>
 #endif
 
 #ifdef HAVE_CANN
-    Ptr<BackendNode> initCannOp(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes)
+    Ptr<BackendNode> initCannOp(const std::string& name,
+                                const std::vector<Ptr<BackendWrapper> > &inputs,
+                                const std::vector<Ptr<BackendNode> >& nodes)
     {
-        auto x = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
+        auto x = inputs[0].dynamicCast<CannBackendWrapper>();
 
-        std::string op_name = cv::format("bnll_%d", index);
-        auto op = std::make_shared<ge::op::BNLL>(op_name);
+        auto op = std::make_shared<ge::op::BNLL>(name);
 
         auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
-        op->set_input_x_by_name(*op_x, "y");
+        op->set_input_x_by_name(*op_x, x->name.c_str());
         auto x_desc = x->getTensorDesc();
         op->update_input_desc_x(*x_desc);
 
@@ -1357,15 +1388,16 @@ struct CeilFunctor : public BaseDefaultFunctor<CeilFunctor>
 #endif
 
 #ifdef HAVE_CANN
-    Ptr<BackendNode> initCannOp(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes)
+    Ptr<BackendNode> initCannOp(const std::string& name,
+                                const std::vector<Ptr<BackendWrapper> > &inputs,
+                                const std::vector<Ptr<BackendNode> >& nodes)
     {
-        auto x = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
+        auto x = inputs[0].dynamicCast<CannBackendWrapper>();
 
-        std::string op_name = cv::format("bnll_%d", index);
-        auto op = std::make_shared<ge::op::BNLL>(op_name);
+        auto op = std::make_shared<ge::op::BNLL>(name);
 
         auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
-        op->set_input_x_by_name(*op_x, "y");
+        op->set_input_x_by_name(*op_x, x->name.c_str());
         auto x_desc = x->getTensorDesc();
         op->update_input_desc_x(*x_desc);
 
@@ -1415,15 +1447,16 @@ struct FloorFunctor : public BaseDefaultFunctor<FloorFunctor>
 #endif
 
 #ifdef HAVE_CANN
-    Ptr<BackendNode> initCannOp(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes)
+    Ptr<BackendNode> initCannOp(const std::string& name,
+                                const std::vector<Ptr<BackendWrapper> > &inputs,
+                                const std::vector<Ptr<BackendNode> >& nodes)
     {
-        auto x = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
+        auto x = inputs[0].dynamicCast<CannBackendWrapper>();
 
-        std::string op_name = cv::format("floor_%d", index);
-        auto op = std::make_shared<ge::op::Floor>(op_name);
+        auto op = std::make_shared<ge::op::Floor>(name);
 
         auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
-        op->set_input_x_by_name(*op_x, "y");
+        op->set_input_x_by_name(*op_x, x->name.c_str());
         auto x_desc = x->getTensorDesc();
         op->update_input_desc_x(*x_desc);
 
@@ -2269,7 +2302,9 @@ struct PowerFunctor : public BaseFunctor
 #endif  // HAVE_HALIDE
 
 #ifdef HAVE_CANN
-    Ptr<BackendNode> initCannOp(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes)
+    Ptr<BackendNode> initCannOp(const std::string& name,
+                                const std::vector<Ptr<BackendWrapper> > &inputs,
+                                const std::vector<Ptr<BackendNode> >& nodes)
     {
         CV_Error(Error::StsNotImplemented, "");
     }
@@ -2304,14 +2339,6 @@ struct PowerFunctor : public BaseFunctor
     }
 #endif
 
-#ifdef HAVE_VULKAN
-    std::shared_ptr<vkcom::OpBase> initVkCom()
-    {
-        // TODO: add vkcom implementation
-        return std::shared_ptr<vkcom::OpBase>();
-    }
-#endif  // HAVE_VULKAN
-
     bool tryFuse(Ptr<dnn::Layer>& top)
     {
         if (power != 1.0f && shift != 0.0f)
@@ -2432,7 +2459,8 @@ struct ChannelsPReLUFunctor : public BaseFunctor
 #endif
         return backendId == DNN_BACKEND_OPENCV ||
                backendId == DNN_BACKEND_CUDA ||
-               backendId == DNN_BACKEND_HALIDE;
+               backendId == DNN_BACKEND_HALIDE ||
+               backendId == DNN_BACKEND_CANN;
     }
 
     void apply(const float* srcptr, float* dstptr, int len, size_t planeSize, int cn0, int cn1) const
@@ -2523,22 +2551,23 @@ struct ChannelsPReLUFunctor : public BaseFunctor
 #endif  // HAVE_HALIDE
 
 #ifdef HAVE_CANN
-    Ptr<BackendNode> initCannOp(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes)
+    Ptr<BackendNode> initCannOp(const std::string& name,
+                                const std::vector<Ptr<BackendWrapper> > &inputs,
+                                const std::vector<Ptr<BackendNode> >& nodes)
     {
-        auto x = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
+        auto x = inputs[0].dynamicCast<CannBackendWrapper>();
         auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
         auto x_desc = x->getTensorDesc();
 
         auto output_desc = std::make_shared<ge::TensorDesc>(ge::Shape(), ge::FORMAT_NCHW, ge::DT_FLOAT);
 
-        std::string op_name = cv::format("prelu_%d", index);
-        auto op = std::make_shared<ge::op::PRelu>(op_name);
+        auto op = std::make_shared<ge::op::PRelu>(name);
 
-        op->set_input_x_by_name(*op_x, "y");
+        op->set_input_x_by_name(*op_x, x->name.c_str());
         op->update_input_desc_x(*x_desc);
 
         std::vector<int> shape_{scale.size[0]}; // scale should be a 1d of shape [n] tensor, and it is a 2d mat of shape [n, 1] in opencv
-        auto op_const_slope = std::make_shared<CannConstOp>(scale.data, scale.type(), shape_, cv::format("%s_weight", op_name.c_str()));
+        auto op_const_slope = std::make_shared<CannConstOp>(scale.data, scale.type(), shape_, cv::format("%s_weight", name.c_str()));
         op->set_input_weight(*(op_const_slope->getOp()));
         op->update_input_desc_weight(*(op_const_slope->getTensorDesc()));
 
@@ -2566,14 +2595,6 @@ struct ChannelsPReLUFunctor : public BaseFunctor
     }
 #endif
 
-#ifdef HAVE_VULKAN
-    std::shared_ptr<vkcom::OpBase> initVkCom()
-    {
-        // TODO: add vkcom implementation
-        return std::shared_ptr<vkcom::OpBase>();
-    }
-#endif  // HAVE_VULKAN
-
     int64 getFLOPSPerElement() const { return 1; }
 };
 
@@ -2694,6 +2715,22 @@ Ptr<ReLU6Layer> ReLU6Layer::create(const LayerParams& params)
     return l;
 }
 
+Ptr<GeluLayer> GeluLayer::create(const LayerParams& params)
+{
+    Ptr<GeluLayer> l(new ElementWiseLayer<GeluFunctor>(GeluFunctor()));
+    l->setParamsFrom(params);
+
+    return l;
+}
+
+Ptr<GeluApproximationLayer> GeluApproximationLayer::create(const LayerParams& params)
+{
+    Ptr<GeluApproximationLayer> l(new ElementWiseLayer<GeluApproximationFunctor>(GeluApproximationFunctor()));
+    l->setParamsFrom(params);
+
+    return l;
+}
+
 Ptr<TanHLayer> TanHLayer::create(const LayerParams& params)
 {
     Ptr<TanHLayer> l(new ElementWiseLayer<TanHFunctor>());

modules/dnn/src/layers/eltwise_layer.cpp

@@ -849,16 +849,18 @@ public:
     }
 
 #ifdef HAVE_CANN
-    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
+    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputs,
+                                      const std::vector<Ptr<BackendWrapper> > &outputs,
+                                      const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
     {
-        CV_Assert(inputsWrapper.size() == 2);
+        CV_Assert(inputs.size() == 2);
         CV_Assert(nodes.size() == 2);
 
         auto op_x1 = nodes[0].dynamicCast<CannBackendNode>()->getOp();
-        auto x1 = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
+        auto x1 = inputs[0].dynamicCast<CannBackendWrapper>();
         auto x1_desc = x1->getTensorDesc();
         auto op_x2 = nodes[1].dynamicCast<CannBackendNode>()->getOp();
-        auto x2 = inputsWrapper[1].dynamicCast<CannBackendWrapper>();
+        auto x2 = inputs[1].dynamicCast<CannBackendWrapper>();
         auto x2_desc = x2->getTensorDesc();
         auto output_desc = std::make_shared<ge::TensorDesc>(ge::Shape(), ge::FORMAT_NCHW, ge::DT_FLOAT);
 
@@ -866,22 +868,22 @@ public:
         // add, mul, div, max, min
         switch (op)
         {
-#define BUILD_CANN_ELTWISE_OP(op_type, class_name, op_name)      \
-            case op_type: {                                      \
-                auto eltwise_op =                                \
-                  std::make_shared<ge::op::class_name>(op_name); \
-                eltwise_op->set_input_x1_by_name(*op_x1, "y");   \
-                eltwise_op->set_input_x2_by_name(*op_x2, "y");   \
-                eltwise_op->update_input_desc_x1(*x1_desc);      \
-                eltwise_op->update_input_desc_x2(*x2_desc);      \
-                eltwise_op->update_output_desc_y(*output_desc);  \
-                eltwise_operator = eltwise_op;                   \
+#define BUILD_CANN_ELTWISE_OP(op_type, class_name, op_name)                 \
+            case op_type: {                                                 \
+                auto eltwise_op =                                           \
+                  std::make_shared<ge::op::class_name>(op_name);            \
+                eltwise_op->set_input_x1_by_name(*op_x1, x1->name.c_str()); \
+                eltwise_op->set_input_x2_by_name(*op_x2, x2->name.c_str()); \
+                eltwise_op->update_input_desc_x1(*x1_desc);                 \
+                eltwise_op->update_input_desc_x2(*x2_desc);                 \
+                eltwise_op->update_output_desc_y(*output_desc);             \
+                eltwise_operator = eltwise_op;                              \
             } break;
-            BUILD_CANN_ELTWISE_OP(SUM, Add, cv::format("add_%d", index));
-            BUILD_CANN_ELTWISE_OP(PROD, Mul, cv::format("mul_%d", index));
-            BUILD_CANN_ELTWISE_OP(DIV, Xdivy, cv::format("div_%d", index));
-            BUILD_CANN_ELTWISE_OP(MAX, Maximum, cv::format("max_%d", index));
-            BUILD_CANN_ELTWISE_OP(MIN, Minimum, cv::format("min_%d", index));
+            BUILD_CANN_ELTWISE_OP(SUM, Add, name);
+            BUILD_CANN_ELTWISE_OP(PROD, Mul, name);
+            BUILD_CANN_ELTWISE_OP(DIV, Xdivy, name);
+            BUILD_CANN_ELTWISE_OP(MAX, Maximum, name);
+            BUILD_CANN_ELTWISE_OP(MIN, Minimum, name);
 #undef BUILD_CANN_ELTWISE_OP
             default: CV_Error(Error::StsNotImplemented, "Unsupported eltwise operation");
         }

modules/dnn/src/layers/fast_convolution/fast_convolution.avx2.cpp

@@ -1,499 +0,0 @@
-// 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 "../../precomp.hpp"
-#include "fast_convolution.hpp"
-
-namespace cv {
-namespace dnn {
-namespace opt_AVX2
-{
-#if CV_TRY_AVX2
-void convBlockMR1(int np, const float* a, const float* b, float *c, const float bias, bool init_c,
-          const float minval, const float maxval, bool ifMinMaxAct)
-{
-#if CONV_NR == 24
-    __m256 c0 = _mm256_set1_ps(bias), c1 = c0, c2 = c0;
-
-    for (int p = 0; p < np; p++, a++, b += CONV_NR)
-    {
-        __m256 a0 = _mm256_set1_ps(a[0]);
-        __m256 b0 = _mm256_loadu_ps(b), b1 = _mm256_loadu_ps(b + 8), b2 = _mm256_loadu_ps(b + 16);
-
-        c0 = _mm256_fmadd_ps(b0, a0, c0);
-        c1 = _mm256_fmadd_ps(b1, a0, c1);
-        c2 = _mm256_fmadd_ps(b2, a0, c2);
-    }
-
-    if (init_c)
-    {
-        c0 = _mm256_add_ps(_mm256_loadu_ps(c), c0);
-        c1 = _mm256_add_ps(_mm256_loadu_ps(c + 8), c1);
-        c2 = _mm256_add_ps(_mm256_loadu_ps(c + 16), c2);
-    }
-
-     if (ifMinMaxAct)
-    {
-        __m256 vmax = _mm256_set1_ps(maxval);
-        __m256 vmin = _mm256_set1_ps(minval);
-
-        c0 = _mm256_min_ps(_mm256_max_ps(c0, vmin), vmax);
-        c1 = _mm256_min_ps(_mm256_max_ps(c1, vmin), vmax);
-        c2 = _mm256_min_ps(_mm256_max_ps(c2, vmin), vmax);
-    }
-
-    _mm256_storeu_ps(c, c0);
-    _mm256_storeu_ps(c + 8, c1);
-    _mm256_storeu_ps(c + 16, c2);
-    _mm256_zeroupper();
-#else
-#error "unsupported CONV_NR in convBlockMR1."
-#endif
-}
-
-void convBlock_AVX2(int np, const float* a, const float* b, float* c, int ldc, bool init_c)
-{
-#if CONV_MR == 4 && CONV_NR == 24
-    __m256 c00 = _mm256_set1_ps(0.f), c01 = c00, c02 = c00;
-    __m256 c10 = c00, c11 = c00, c12 = c00;
-    __m256 c20 = c00, c21 = c00, c22 = c00;
-    __m256 c30 = c00, c31 = c00, c32 = c00;
-
-    __m256 a0 = _mm256_setzero_ps(), a1 = _mm256_setzero_ps();
-    __m256 b0 = _mm256_setzero_ps(), b1 = _mm256_setzero_ps(), b2 = _mm256_setzero_ps();
-
-    for (int p = 0; p < np; p++, a += CONV_MR, b += CONV_NR)
-    {
-        a0 = _mm256_set1_ps(a[0]), a1 = _mm256_set1_ps(a[1]);
-        b0 = _mm256_load_ps(b), b1 = _mm256_load_ps(b + 8), b2 = _mm256_load_ps(b + 16);
-
-        c00 = _mm256_fmadd_ps(b0, a0, c00);
-        c01 = _mm256_fmadd_ps(b1, a0, c01);
-        c02 = _mm256_fmadd_ps(b2, a0, c02);
-
-        c10 = _mm256_fmadd_ps(b0, a1, c10);
-        c11 = _mm256_fmadd_ps(b1, a1, c11);
-        c12 = _mm256_fmadd_ps(b2, a1, c12);
-
-        a0 = _mm256_set1_ps(a[2]), a1 = _mm256_set1_ps(a[3]);
-
-        c20 = _mm256_fmadd_ps(b0, a0, c20);
-        c21 = _mm256_fmadd_ps(b1, a0, c21);
-        c22 = _mm256_fmadd_ps(b2, a0, c22);
-
-        c30 = _mm256_fmadd_ps(b0, a1, c30);
-        c31 = _mm256_fmadd_ps(b1, a1, c31);
-        c32 = _mm256_fmadd_ps(b2, a1, c32);
-    }
-
-    if (!init_c)
-    {
-        c00 = _mm256_add_ps(c00, _mm256_load_ps(c));
-        c01 = _mm256_add_ps(c01, _mm256_load_ps(c + 8));
-        c02 = _mm256_add_ps(c02, _mm256_load_ps(c + 16));
-
-        c10 = _mm256_add_ps(c10, _mm256_load_ps(c + ldc));
-        c11 = _mm256_add_ps(c11, _mm256_load_ps(c + ldc + 8));
-        c12 = _mm256_add_ps(c12, _mm256_load_ps(c + ldc + 16));
-
-        c20 = _mm256_add_ps(c20, _mm256_load_ps(c + ldc*2));
-        c21 = _mm256_add_ps(c21, _mm256_load_ps(c + ldc*2 + 8));
-        c22 = _mm256_add_ps(c22, _mm256_load_ps(c + ldc*2 + 16));
-
-        c30 = _mm256_add_ps(c30, _mm256_load_ps(c + ldc*3));
-        c31 = _mm256_add_ps(c31, _mm256_load_ps(c + ldc*3 + 8));
-        c32 = _mm256_add_ps(c32, _mm256_load_ps(c + ldc*3 + 16));
-    }
-
-    _mm256_storeu_ps(c, c00), _mm256_storeu_ps(c+8, c01), _mm256_storeu_ps(c+16, c02);
-    _mm256_storeu_ps(c + ldc, c10), _mm256_storeu_ps(c + ldc + 8, c11), _mm256_storeu_ps(c + ldc + 16, c12);
-    _mm256_storeu_ps(c + ldc*2, c20), _mm256_storeu_ps(c + ldc*2 + 8, c21), _mm256_storeu_ps(c + ldc*2 + 16, c22);
-    _mm256_storeu_ps(c + ldc*3, c30), _mm256_storeu_ps(c + ldc*3 + 8, c31), _mm256_storeu_ps(c + ldc*3 + 16, c32);
-    _mm256_zeroupper();
-#else
-#error "unsupported CONV_MR and/or CONV_NR in convBlock_AVX2."
-#endif
-}
-
-void _fx_winograd_accum_f32(const float* inwptr, const float* wptr,
-                       float* outbuf, int Cg, int iblock)
-{
-    CV_Assert(_FX_WINO_IBLOCK == 6 && _FX_WINO_KBLOCK == 4 && _FX_WINO_ATOM_F32 == 8);
-    if (iblock > 3)
-    {
-        for (int atom_id = 0; atom_id < _FX_WINO_NATOMS_F32; atom_id++,
-                outbuf += _FX_WINO_ATOM_F32)
-        {
-            __m256 s00 = _mm256_set1_ps(0.f), s01 = s00, s02 = s00, s03 = s00, s04 = s00, s05 = s00;
-            __m256 s10 = _mm256_set1_ps(0.f), s11 = s00, s12 = s00, s13 = s00, s14 = s00, s15 = s00;
-            __m256 s20 = _mm256_set1_ps(0.f), s21 = s00, s22 = s00, s23 = s00, s24 = s00, s25 = s00;
-            __m256 s30 = _mm256_set1_ps(0.f), s31 = s00, s32 = s00, s33 = s00, s34 = s00, s35 = s00;
-            for (int c = 0; c < Cg; c++, inwptr += _FX_WINO_IBLOCK*_FX_WINO_ATOM_F32,
-                                         wptr += _FX_WINO_KBLOCK*_FX_WINO_ATOM_F32)
-            {
-                __m256 w0 = _mm256_load_ps(wptr), w1 = _mm256_load_ps(wptr + 8);
-                __m256 w2 = _mm256_load_ps(wptr + 16), w3 = _mm256_load_ps(wptr + 24);
-                __m256 x0, x1;
-                x0 = _mm256_load_ps(inwptr);
-                x1 = _mm256_load_ps(inwptr + 8);
-                s00 = _mm256_fmadd_ps(w0, x0, s00);
-                s01 = _mm256_fmadd_ps(w0, x1, s01);
-                s10 = _mm256_fmadd_ps(w1, x0, s10);
-                s11 = _mm256_fmadd_ps(w1, x1, s11);
-                s20 = _mm256_fmadd_ps(w2, x0, s20);
-                s21 = _mm256_fmadd_ps(w2, x1, s21);
-                s30 = _mm256_fmadd_ps(w3, x0, s30);
-                s31 = _mm256_fmadd_ps(w3, x1, s31);
-                x0 = _mm256_load_ps(inwptr + 16);
-                x1 = _mm256_load_ps(inwptr + 24);
-                s02 = _mm256_fmadd_ps(w0, x0, s02);
-                s03 = _mm256_fmadd_ps(w0, x1, s03);
-                s12 = _mm256_fmadd_ps(w1, x0, s12);
-                s13 = _mm256_fmadd_ps(w1, x1, s13);
-                s22 = _mm256_fmadd_ps(w2, x0, s22);
-                s23 = _mm256_fmadd_ps(w2, x1, s23);
-                s32 = _mm256_fmadd_ps(w3, x0, s32);
-                s33 = _mm256_fmadd_ps(w3, x1, s33);
-                x0 = _mm256_load_ps(inwptr + 32);
-                x1 = _mm256_load_ps(inwptr + 40);
-                s04 = _mm256_fmadd_ps(w0, x0, s04);
-                s05 = _mm256_fmadd_ps(w0, x1, s05);
-                s14 = _mm256_fmadd_ps(w1, x0, s14);
-                s15 = _mm256_fmadd_ps(w1, x1, s15);
-                s24 = _mm256_fmadd_ps(w2, x0, s24);
-                s25 = _mm256_fmadd_ps(w2, x1, s25);
-                s34 = _mm256_fmadd_ps(w3, x0, s34);
-                s35 = _mm256_fmadd_ps(w3, x1, s35);
-            }
-
-            _mm256_store_ps(outbuf, s00);
-            _mm256_store_ps(outbuf + 1*64, s01);
-            _mm256_store_ps(outbuf + 2*64, s02);
-            _mm256_store_ps(outbuf + 3*64, s03);
-            _mm256_store_ps(outbuf + 4*64, s04);
-            _mm256_store_ps(outbuf + 5*64, s05);
-
-            _mm256_store_ps(outbuf + 6*64, s10);
-            _mm256_store_ps(outbuf + 7*64, s11);
-            _mm256_store_ps(outbuf + 8*64, s12);
-            _mm256_store_ps(outbuf + 9*64, s13);
-            _mm256_store_ps(outbuf + 10*64, s14);
-            _mm256_store_ps(outbuf + 11*64, s15);
-
-            _mm256_store_ps(outbuf + 12*64, s20);
-            _mm256_store_ps(outbuf + 13*64, s21);
-            _mm256_store_ps(outbuf + 14*64, s22);
-            _mm256_store_ps(outbuf + 15*64, s23);
-            _mm256_store_ps(outbuf + 16*64, s24);
-            _mm256_store_ps(outbuf + 17*64, s25);
-
-            _mm256_store_ps(outbuf + 18*64, s30);
-            _mm256_store_ps(outbuf + 19*64, s31);
-            _mm256_store_ps(outbuf + 20*64, s32);
-            _mm256_store_ps(outbuf + 21*64, s33);
-            _mm256_store_ps(outbuf + 22*64, s34);
-            _mm256_store_ps(outbuf + 23*64, s35);
-        }
-    }
-    else
-    {
-        for (int atom_id = 0; atom_id < _FX_WINO_NATOMS_F32; atom_id++,
-                outbuf += _FX_WINO_ATOM_F32)
-        {
-            __m256 s00 = _mm256_set1_ps(0.f), s01 = s00, s02 = s00;
-            __m256 s10 = _mm256_set1_ps(0.f), s11 = s00, s12 = s00;
-            __m256 s20 = _mm256_set1_ps(0.f), s21 = s00, s22 = s00;
-            __m256 s30 = _mm256_set1_ps(0.f), s31 = s00, s32 = s00;
-            for (int c = 0; c < Cg; c++, inwptr += _FX_WINO_IBLOCK*_FX_WINO_ATOM_F32,
-                                         wptr += _FX_WINO_KBLOCK*_FX_WINO_ATOM_F32) {
-                __m256 w0 = _mm256_load_ps(wptr), w1 = _mm256_load_ps(wptr + 8);
-                __m256 w2 = _mm256_load_ps(wptr + 16), w3 = _mm256_load_ps(wptr + 24);
-                __m256 x0, x1, x2;
-                x0 = _mm256_load_ps(inwptr);
-                x1 = _mm256_load_ps(inwptr + 8);
-                x2 = _mm256_load_ps(inwptr + 16);
-                s00 = _mm256_fmadd_ps(w0, x0, s00);
-                s01 = _mm256_fmadd_ps(w0, x1, s01);
-                s02 = _mm256_fmadd_ps(w0, x2, s02);
-                s10 = _mm256_fmadd_ps(w1, x0, s10);
-                s11 = _mm256_fmadd_ps(w1, x1, s11);
-                s12 = _mm256_fmadd_ps(w1, x2, s12);
-                s20 = _mm256_fmadd_ps(w2, x0, s20);
-                s21 = _mm256_fmadd_ps(w2, x1, s21);
-                s22 = _mm256_fmadd_ps(w2, x2, s22);
-                s30 = _mm256_fmadd_ps(w3, x0, s30);
-                s31 = _mm256_fmadd_ps(w3, x1, s31);
-                s32 = _mm256_fmadd_ps(w3, x2, s32);
-            }
-
-            _mm256_store_ps(outbuf, s00);
-            _mm256_store_ps(outbuf + 1*64, s01);
-            _mm256_store_ps(outbuf + 2*64, s02);
-            _mm256_store_ps(outbuf + 6*64, s10);
-            _mm256_store_ps(outbuf + 7*64, s11);
-            _mm256_store_ps(outbuf + 8*64, s12);
-            _mm256_store_ps(outbuf + 12*64, s20);
-            _mm256_store_ps(outbuf + 13*64, s21);
-            _mm256_store_ps(outbuf + 14*64, s22);
-            _mm256_store_ps(outbuf + 18*64, s30);
-            _mm256_store_ps(outbuf + 19*64, s31);
-            _mm256_store_ps(outbuf + 20*64, s32);
-        }
-    }
-    _mm256_zeroupper();
-}
-static inline
-void transpose8_ps(__m256 &row0, __m256 &row1, __m256 &row2, __m256 &row3, __m256 &row4, __m256 &row5, __m256 &row6, __m256 &row7)
-{
-    __m256 __t0, __t1, __t2, __t3, __t4, __t5, __t6, __t7;
-    __m256 __tt0, __tt1, __tt2, __tt3, __tt4, __tt5, __tt6, __tt7;
-    __t0 = _mm256_unpacklo_ps(row0, row1);
-    __t1 = _mm256_unpackhi_ps(row0, row1);
-    __t2 = _mm256_unpacklo_ps(row2, row3);
-    __t3 = _mm256_unpackhi_ps(row2, row3);
-    __t4 = _mm256_unpacklo_ps(row4, row5);
-    __t5 = _mm256_unpackhi_ps(row4, row5);
-    __t6 = _mm256_unpacklo_ps(row6, row7);
-    __t7 = _mm256_unpackhi_ps(row6, row7);
-    __tt0 = _mm256_shuffle_ps(__t0,__t2,_MM_SHUFFLE(1,0,1,0));
-    __tt1 = _mm256_shuffle_ps(__t0,__t2,_MM_SHUFFLE(3,2,3,2));
-    __tt2 = _mm256_shuffle_ps(__t1,__t3,_MM_SHUFFLE(1,0,1,0));
-    __tt3 = _mm256_shuffle_ps(__t1,__t3,_MM_SHUFFLE(3,2,3,2));
-    __tt4 = _mm256_shuffle_ps(__t4,__t6,_MM_SHUFFLE(1,0,1,0));
-    __tt5 = _mm256_shuffle_ps(__t4,__t6,_MM_SHUFFLE(3,2,3,2));
-    __tt6 = _mm256_shuffle_ps(__t5,__t7,_MM_SHUFFLE(1,0,1,0));
-    __tt7 = _mm256_shuffle_ps(__t5,__t7,_MM_SHUFFLE(3,2,3,2));
-    row0 = _mm256_permute2f128_ps(__tt0, __tt4, 0x20);
-    row1 = _mm256_permute2f128_ps(__tt1, __tt5, 0x20);
-    row2 = _mm256_permute2f128_ps(__tt2, __tt6, 0x20);
-    row3 = _mm256_permute2f128_ps(__tt3, __tt7, 0x20);
-    row4 = _mm256_permute2f128_ps(__tt0, __tt4, 0x31);
-    row5 = _mm256_permute2f128_ps(__tt1, __tt5, 0x31);
-    row6 = _mm256_permute2f128_ps(__tt2, __tt6, 0x31);
-    row7 = _mm256_permute2f128_ps(__tt3, __tt7, 0x31);
-}
-
-/*Input transform*/
-void _fx_winograd_BtXB_8x8_f32(const float* inptr, int inpstep, float* outptr, int Cg)
-{
-    __m256 x00 = _mm256_loadu_ps(inptr);
-    __m256 x10 = _mm256_loadu_ps(inptr + inpstep);
-    __m256 x20 = _mm256_loadu_ps(inptr + inpstep*2);
-    __m256 x30 = _mm256_loadu_ps(inptr + inpstep*3);
-    __m256 x40 = _mm256_loadu_ps(inptr + inpstep*4);
-    __m256 x50 = _mm256_loadu_ps(inptr + inpstep*5);
-    __m256 x60 = _mm256_loadu_ps(inptr + inpstep*6);
-    __m256 x70 = _mm256_loadu_ps(inptr + inpstep*7);
-
-    __m256 z00, z10, z20, z30, z40, z50, z60, z70;
-
-    {
-        /* Y[0] = [1.f, 0.f, -5.25f, 0.f, 5.25f, 0.f, -1.f, 0.f]*X */
-        /* Y[7] = [0.f, -1.f, 0.f, 5.25f, 0.f, -5.25f, 0.f, 1.f]*X */
-        __m256 q5_25 = _mm256_set1_ps(5.25f), t00, t10;
-        t00 = _mm256_sub_ps(x40, x20);
-        t10 = _mm256_sub_ps(x30, x50);
-
-        __m256 y00 = _mm256_fmadd_ps(t00, q5_25, _mm256_sub_ps(x00, x60));
-        __m256 y70 = _mm256_fmadd_ps(t10, q5_25, _mm256_sub_ps(x70, x10));
-
-        /* Y[1] = [0.f, 1.f, 1.f, -4.25f, -4.25f, 1.f, 1.f, 0.f]*X */
-        /* Y[2] = [0.f, -1.f, 1.f, 4.25f, -4.25f, -1.f, 1.f, 0.f]*X */
-        __m256 qm4_25 = _mm256_set1_ps(-4.25f);
-        t00 = _mm256_fmadd_ps(x30, qm4_25, _mm256_add_ps(x10, x50));
-        t10 = _mm256_fmadd_ps(x40, qm4_25, _mm256_add_ps(x20, x60));
-
-        __m256 y10 = _mm256_add_ps(t00, t10);
-        __m256 y20 = _mm256_sub_ps(t10, t00);
-
-        /* Y[3] = [0.f, 0.5f, 0.25f, -2.5f, -1.25f, 2.f, 1.f, 0.f]*X */
-        /* Y[4] = [0.f, -0.5f, 0.25f, 2.5f, -1.25f, -2.f, 1.f, 0.f]*X */
-        __m256 q0_5 = _mm256_set1_ps(0.5f), q0_25 = _mm256_set1_ps(0.25f);
-        __m256 qm2_5 = _mm256_set1_ps(-2.5f), qm1_25 = _mm256_set1_ps(-1.25f);
-        t00 = _mm256_fmadd_ps(x10, q0_5, _mm256_add_ps(x50, x50));
-        t10 = _mm256_fmadd_ps(x20, q0_25, x60);
-        t00 = _mm256_fmadd_ps(x30, qm2_5, t00);
-        t10 = _mm256_fmadd_ps(x40, qm1_25, t10);
-
-        __m256 y30 = _mm256_add_ps(t00, t10);
-        __m256 y40 = _mm256_sub_ps(t10, t00);
-
-        /* Y[5] = [0.f, 2.f, 4.f, -2.5f, -5.f, 0.5f, 1.f, 0.f]*X */
-        /* Y[6] = [0.f, -2.f, 4.f, 2.5f, -5.f, -0.5f, 1.f, 0.f]*X */
-        __m256 q4 = _mm256_set1_ps(4.f), qm5 = _mm256_set1_ps(-5.f);
-        t00 = _mm256_fmadd_ps(x50, q0_5, _mm256_add_ps(x10, x10));
-        t10 = _mm256_fmadd_ps(x20, q4   , x60);
-        t00 = _mm256_fmadd_ps(x30, qm2_5, t00);
-        t10 = _mm256_fmadd_ps(x40, qm5  , t10);
-
-        __m256 y50 = _mm256_add_ps(t00, t10);
-        __m256 y60 = _mm256_sub_ps(t10, t00);
-
-        /* transpose 8x8 matrix in-place with some renumeration of the elements: */
-        transpose8_ps(y00, y10, y20, y30, y40, y50, y60, y70);
-
-        /* Z[0] = [1.f, 0.f, -5.25f, 0.f, 5.25f, 0.f, -1.f, 0.f]*Y */
-        /* Z[7] = [0.f, -1.f, 0.f, 5.25f, 0.f, -5.25f, 0.f, 1.f]*Y */
-        t00 = _mm256_sub_ps(y40, y20);
-        t10 = _mm256_sub_ps(y30, y50);
-        z00 = _mm256_fmadd_ps(t00, q5_25, _mm256_sub_ps(y00, y60));
-        z70 = _mm256_fmadd_ps(t10, q5_25, _mm256_sub_ps(y70, y10));
-
-        /* Z[1] = [0.f, 1.f, 1.f, -4.25f, -4.25f, 1.f, 1.f, 0.f]*Y */
-        /* Z[2] = [0.f, -1.f, 1.f, 4.25f, -4.25f, -1.f, 1.f, 0.f]*Y */
-        t00 = _mm256_fmadd_ps(y30, qm4_25, _mm256_add_ps(y10, y50));
-        t10 = _mm256_fmadd_ps(y40, qm4_25, _mm256_add_ps(y20, y60));
-        z10 = _mm256_add_ps(t00, t10);
-        z20 = _mm256_sub_ps(t10, t00);
-
-        /* Z[3] = [0.f, 0.5f, 0.25f, -2.5f, -1.25f, 2.f, 1.f, 0.f]*Y */
-        /* Z[4] = [0.f, -0.5f, 0.25f, 2.5f, -1.25f, -2.f, 1.f, 0.f]*Y */
-        t00 = _mm256_fmadd_ps(y10, q0_5, _mm256_add_ps(y50, y50));
-        t10 = _mm256_fmadd_ps(y20, q0_25, y60);
-        t00 = _mm256_fmadd_ps(y30, qm2_5, t00);
-        t10 = _mm256_fmadd_ps(y40, qm1_25, t10);
-
-        z30 = _mm256_add_ps(t00, t10);
-        z40 = _mm256_sub_ps(t10, t00);
-
-        /* Z[5] = [0.f, 2.f, 4.f, -2.5f, -5.f, 0.5f, 1.f, 0.f]*Y */
-        /* Z[6] = [0.f, -2.f, 4.f, 2.5f, -5.f, -0.5f, 1.f, 0.f]*Y */
-        t00 = _mm256_fmadd_ps(y50, q0_5, _mm256_add_ps(y10, y10));
-        t10 = _mm256_fmadd_ps(y20, q4, y60);
-        t00 = _mm256_fmadd_ps(y30, qm2_5, t00);
-        t10 = _mm256_fmadd_ps(y40, qm5, t10);
-
-        z50 = _mm256_add_ps(t00, t10);
-        z60 = _mm256_sub_ps(t10, t00);
-    }
-
-    const int outstep = _FX_WINO_IBLOCK*_FX_WINO_ATOM_F32*Cg;
-
-    _mm256_storeu_ps(outptr, z00);
-    _mm256_storeu_ps(outptr + outstep, z10);
-    _mm256_storeu_ps(outptr + outstep*2, z20);
-    _mm256_storeu_ps(outptr + outstep*3, z30);
-    _mm256_storeu_ps(outptr + outstep*4, z40);
-    _mm256_storeu_ps(outptr + outstep*5, z50);
-    _mm256_storeu_ps(outptr + outstep*6, z60);
-    _mm256_storeu_ps(outptr + outstep*7, z70);
-    _mm256_zeroupper();
-}
-
-#define STORE6_ELE_FROM_16(ptr, z00, lowM, highM) \
-    lowM = _mm256_castps256_ps128(z00); \
-    highM = _mm256_extractf128_ps(z00, 1); \
-    _mm_storeu_ps(ptr, lowM); \
-    _mm_storel_epi64((__m128i*)(ptr + 4), _mm_castps_si128(highM))
-
-/*  Inverse Winograd 8x8 transform:
-    out = (A'*inp*A)', where
-    inp is input 8x8 FP32 matrix,
-    A' is
-    [1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 0.f,
-     0.f, 1.f, -1.f, 2.f, -2.f, 0.5f, -0.5f, 0.f,
-     0.f, 1.f, 1.f, 4.f, 4.f, 0.25f, 0.25f, 0.f,
-     0.f, 1.f, -1.f, 8.f, -8.f, 0.125f, -0.125f, 0.f,
-     0.f, 1.f, 1.f, 16.f, 16.f, 1.f/16, 1.f/16, 0.f,
-     0.f, 1.f, -1.f, 32.f, -32.f, 1.f/32, -1.f/32, 1.f]
-*/
-void _fx_winograd_AtXA_8x8_f32(const float* inptr, int inpstep,
-                          float* bpptr, int bpstep, float* outptr, int outstep,
-                          float bias, float minval, float maxval, bool ifMinMaxAct)
-{
-
-    __m256 x00 = _mm256_load_ps(inptr);
-    __m256 x10 = _mm256_load_ps(inptr + inpstep);
-    __m256 x20 = _mm256_load_ps(inptr + inpstep*2);
-    __m256 x30 = _mm256_load_ps(inptr + inpstep*3);
-    __m256 x40 = _mm256_load_ps(inptr + inpstep*4);
-    __m256 x50 = _mm256_load_ps(inptr + inpstep*5);
-    __m256 x60 = _mm256_load_ps(inptr + inpstep*6);
-    __m256 x70 = _mm256_load_ps(inptr + inpstep*7);
-    __m256 z00, z10, z20, z30, z40, z50;
-
-    {
-        __m256 s12_0, s34_0, s56_0;
-        s12_0 = _mm256_add_ps(x10, x20);
-        s34_0 = _mm256_add_ps(x30, x40);
-        s56_0 = _mm256_add_ps(x50, x60);
-
-        __m256 y00 = _mm256_add_ps(x00, _mm256_add_ps(s12_0, _mm256_add_ps(s34_0, s56_0)));
-        __m256 y20 = _mm256_fmadd_ps(s56_0, _mm256_set1_ps(0.25f), _mm256_fmadd_ps(s34_0, _mm256_set1_ps(4.0f), s12_0));
-        __m256 y40 = _mm256_fmadd_ps(s56_0, _mm256_set1_ps(1.f/16), _mm256_fmadd_ps(s34_0, _mm256_set1_ps(16.0f), s12_0));
-
-        s12_0 = _mm256_sub_ps(x10, x20);
-        s34_0 = _mm256_sub_ps(x30, x40);
-        s56_0 = _mm256_sub_ps(x50, x60);
-        __m256 y50 = _mm256_fmadd_ps(s56_0, _mm256_set1_ps(1.f/32), _mm256_fmadd_ps(s34_0, _mm256_set1_ps(32.f), _mm256_add_ps(x70, s12_0)));
-        __m256 y10 = _mm256_fmadd_ps(s56_0, _mm256_set1_ps(0.5f), _mm256_fmadd_ps(s34_0, _mm256_set1_ps(2.f), s12_0));
-        __m256 y30 = _mm256_fmadd_ps(s56_0, _mm256_set1_ps(0.125f), _mm256_fmadd_ps(s34_0, _mm256_set1_ps(8.f), s12_0));
-        __m256 y60 = _mm256_set1_ps(0.f), y70 = y60;
-
-        /* transpose 8x8 matrix in-place with some renumeration of the elements: */
-
-        transpose8_ps(y00, y10, y20, y30, y40, y50, y60, y70);
-
-        s12_0 = _mm256_add_ps(y10, y20);
-        s34_0 = _mm256_add_ps(y30, y40);
-        s56_0 = _mm256_add_ps(y50, y60);
-
-        z00 = _mm256_add_ps(y00, _mm256_add_ps(s12_0, _mm256_add_ps(s34_0, s56_0)));
-        z20 = _mm256_fmadd_ps(s56_0, _mm256_set1_ps(0.25f), _mm256_fmadd_ps(s34_0, _mm256_set1_ps(4.0f), s12_0));
-        z40 = _mm256_fmadd_ps(s56_0, _mm256_set1_ps(1.f/16), _mm256_fmadd_ps(s34_0, _mm256_set1_ps(16.0f), s12_0));
-
-        s12_0 = _mm256_sub_ps(y10, y20);
-        s34_0 = _mm256_sub_ps(y30, y40);
-        s56_0 = _mm256_sub_ps(y50, y60);
-
-        z50 = _mm256_fmadd_ps(s56_0, _mm256_set1_ps(1.f/32), _mm256_fmadd_ps(s34_0, _mm256_set1_ps(32.0f), _mm256_add_ps(y70, s12_0)));
-        z10 = _mm256_fmadd_ps(s56_0, _mm256_set1_ps(0.5f), _mm256_fmadd_ps(s34_0, _mm256_set1_ps(2.0f), s12_0));
-        z30 = _mm256_fmadd_ps(s56_0, _mm256_set1_ps(0.125f), _mm256_fmadd_ps(s34_0, _mm256_set1_ps(8.0f), s12_0));
-
-        __m256 vbias = _mm256_set1_ps(bias);
-        z00 = _mm256_add_ps(vbias, z00);
-        z10 = _mm256_add_ps(vbias, z10);
-        z20 = _mm256_add_ps(vbias, z20);
-        z30 = _mm256_add_ps(vbias, z30);
-        z40 = _mm256_add_ps(vbias, z40);
-        z50 = _mm256_add_ps(vbias, z50);
-    }
-
-    if (bpptr)
-    {
-        z00 = _mm256_add_ps(z00, _mm256_loadu_ps(bpptr));
-        z10 = _mm256_add_ps(z10, _mm256_loadu_ps(bpptr + bpstep));
-        z20 = _mm256_add_ps(z20, _mm256_loadu_ps(bpptr + bpstep*2));
-        z30 = _mm256_add_ps(z30, _mm256_loadu_ps(bpptr + bpstep*3));
-        z40 = _mm256_add_ps(z40, _mm256_loadu_ps(bpptr + bpstep*4));
-        z50 = _mm256_add_ps(z50, _mm256_loadu_ps(bpptr + bpstep*5));
-    }
-
-    if (ifMinMaxAct)
-    {
-        __m256 vmax = _mm256_set1_ps(maxval);
-        __m256 vmin = _mm256_set1_ps(minval);
-
-        z00 = _mm256_min_ps(_mm256_max_ps(z00, vmin), vmax);
-        z10 = _mm256_min_ps(_mm256_max_ps(z10, vmin), vmax);
-        z20 = _mm256_min_ps(_mm256_max_ps(z20, vmin), vmax);
-        z30 = _mm256_min_ps(_mm256_max_ps(z30, vmin), vmax);
-        z40 = _mm256_min_ps(_mm256_max_ps(z40, vmin), vmax);
-        z50 = _mm256_min_ps(_mm256_max_ps(z50, vmin), vmax);
-    }
-
-    __m128 lowM, highM;
-    STORE6_ELE_FROM_16(outptr, z00, lowM, highM);
-    STORE6_ELE_FROM_16(outptr + outstep, z10, lowM, highM);
-    STORE6_ELE_FROM_16(outptr + outstep * 2, z20, lowM, highM);
-    STORE6_ELE_FROM_16(outptr + outstep * 3, z30, lowM, highM);
-    STORE6_ELE_FROM_16(outptr + outstep * 4, z40, lowM, highM);
-    STORE6_ELE_FROM_16(outptr + outstep * 5, z50, lowM, highM);
-    _mm256_zeroupper();
-}
-
-#endif
-} // namespace opt_AVX2
-} // namespace dnn
-} // namespace cv

modules/dnn/src/layers/fast_convolution/fast_convolution.simd.hpp

@@ -1,567 +0,0 @@
-// 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 OPENCV_FAST_CONVOLUTION_SIMD_HPP
-#define OPENCV_FAST_CONVOLUTION_SIMD_HPP
-
-#include "opencv2/core/hal/intrin.hpp"
-#include <opencv2/core/utils/logger.hpp>
-
-namespace cv {
-namespace dnn {
-
-static void convBlockMR1NoSIMD(int np, const float* a, const float* b, float *c, const float bias, bool init_c,
-                               const float minval, const float maxval, bool ifMinMaxAct, const int outLen)
-{
-    std::vector<float> cbuffer(outLen, 0);
-    float* cbuf = cbuffer.data();
-    for( int p = 0; p < np; p++ )
-    {
-        float ai = a[p];
-        for( int j = 0; j < outLen; j++ )
-            cbuf[j] += b[CONV_NR*p + j] * ai;
-    }
-
-    if (init_c)
-    {
-        for(int j = 0; j < outLen; j++)
-        {
-            c[j] += cbuf[j] + bias;
-            if (ifMinMaxAct)
-                c[j] = std::min(std::max(c[j], minval), maxval);
-        }
-    }
-    else
-    {
-        for(int j = 0; j < outLen; j++)
-        {
-            c[j] = cbuf[j] + bias;
-            if (ifMinMaxAct)
-                c[j] = std::min(std::max(c[j], minval), maxval);
-        }
-    }
-}
-
-void convBlockMR1(int np, const float* a, const float* b, float *c, const float bias, bool init_c,
-                  const float minval, const float maxval, bool ifMinMaxAct, const int outLen)
-{
-#if CV_SIMD128
-    // The outLen represents the valid output value in CONV_NR length.
-    // When outLen is very small, we use the no-SIMD branch.
-    const int CONV_NRby3 = CONV_NR/3;
-    if (outLen > CONV_NRby3)
-    {
-        v_float32x4 c0  = v_setall_f32(bias), c1 = c0, c2 = c0; // CONV_NR == 12
-#if CONV_NR == 28 || CONV_NR == 24
-        v_float32x4 c3 = c0, c4 = c0, c5 = c0;
-#endif
-#if CONV_NR == 28
-        v_float32x4 c6 = c0;
-#endif
-        for (int p = 0; p < np; p++, a++, b += CONV_NR)
-        {
-            v_float32x4 a0 = v_setall_f32(a[0]);
-            v_float32x4 b0 = v_load(b), b1 = v_load(b + 4), b2 = v_load(b + 8);
-#if CONV_NR == 28 || CONV_NR == 24
-            v_float32x4 b3 = v_load(b + 12), b4 = v_load(b + 16), b5 = v_load(b + 20);
-#endif
-#if CONV_NR == 28
-            v_float32x4 b6 = v_load(b + 24);
-#endif
-
-            c0 = v_fma(b0, a0, c0);
-            c1 = v_fma(b1, a0, c1);
-            c2 = v_fma(b2, a0, c2);
-#if CONV_NR == 28 || CONV_NR == 24
-            c3 = v_fma(b3, a0, c3);
-            c4 = v_fma(b4, a0, c4);
-            c5 = v_fma(b5, a0, c5);
-#endif
-#if CONV_NR == 28
-            c6 = v_fma(b6, a0, c6);
-#endif
-        }
-
-        if (init_c)
-        {
-            c0 += v_load(c);
-            c1 += v_load(c + 4);
-            c2 += v_load(c + 8);
-#if CONV_NR == 28 || CONV_NR == 24
-            c3 += v_load(c + 12);
-            c4 += v_load(c + 16);
-            c5 += v_load(c + 20);
-#endif
-#if CONV_NR == 28
-            c6  += v_load(c + 24);
-#endif
-        }
-
-        if (ifMinMaxAct)
-        {
-           v_float32x4 vmax = v_setall_f32(maxval), vmin = v_setall_f32(minval);
-           c0 = v_min(v_max(c0, vmin), vmax);
-           c1 = v_min(v_max(c1, vmin), vmax);
-           c2 = v_min(v_max(c2, vmin), vmax);
-#if CONV_NR == 28 || CONV_NR == 24
-           c3 = v_min(v_max(c3, vmin), vmax);
-           c4 = v_min(v_max(c4, vmin), vmax);
-           c5 = v_min(v_max(c5, vmin), vmax);
-#endif
-#if CONV_NR == 28
-            c6 = v_min(v_max(c6, vmin), vmax);
-#endif
-        }
-
-        v_store(c, c0);
-        v_store(c + 4, c1);
-        v_store(c + 8, c2);
-#if CONV_NR == 28 || CONV_NR == 24
-        v_store(c + 12, c3);
-        v_store(c + 16, c4);
-        v_store(c + 20, c5);
-#endif
-#if CONV_NR == 28
-        v_store(c + 24, c6);
-#endif
-     }
-     else
-         convBlockMR1NoSIMD(np, a, b, c, bias, init_c, minval, maxval, ifMinMaxAct, outLen);
-#else
-    convBlockMR1NoSIMD(np, a, b, c, bias, init_c, minval, maxval, ifMinMaxAct, outLen);
-#endif
-}
-
-#if CV_SIMD128
-#if CONV_MR == 4 && CONV_NR == 24
-static void convBlock4x24(int np, const float* a, const float* b, float* c, int ldc, bool init_c)
-{
-    v_float32x4 c0  = v_setzero_f32(), c1 = c0, c2 = c0, c3 = c0, c4 = c0, c5 = c0;
-    v_float32x4 c6  = v_setzero_f32(), c7 = c6, c8 = c6, c9 = c6, c10 = c6, c11 = c6;
-    v_float32x4 c12 = v_setzero_f32(), c13 = c12, c14 = c12, c15 = c12, c16 = c12, c17 = c12;
-    v_float32x4 c18 = v_setzero_f32(), c19 = c18, c20 = c18, c21 = c18, c22 = c18, c23 = c18;
-
-    for (int p = 0; p < np; p++, a += CONV_MR, b += CONV_NR)
-    {
-        v_float32x4 a0 = v_setall_f32(a[0]);
-        v_float32x4 b0 = v_load(b), b1 = v_load(b + 4), b2 = v_load(b + 8);
-        v_float32x4 b3 = v_load(b + 12), b4 = v_load(b + 16), b5 = v_load(b + 20);
-
-        c0 = v_fma(b0, a0, c0);
-        c1 = v_fma(b1, a0, c1);
-        c2 = v_fma(b2, a0, c2);
-        c3 = v_fma(b3, a0, c3);
-        c4 = v_fma(b4, a0, c4);
-        c5 = v_fma(b5, a0, c5);
-
-        a0  = v_setall_f32(a[1]);
-        c6  = v_fma(b0, a0, c6);
-        c7  = v_fma(b1, a0, c7);
-        c8  = v_fma(b2, a0, c8);
-        c9  = v_fma(b3, a0, c9);
-        c10 = v_fma(b4, a0, c10);
-        c11 = v_fma(b5, a0, c11);
-
-        a0 = v_setall_f32(a[2]);
-        c12 = v_fma(b0, a0, c12);
-        c13 = v_fma(b1, a0, c13);
-        c14 = v_fma(b2, a0, c14);
-        c15 = v_fma(b3, a0, c15);
-        c16 = v_fma(b4, a0, c16);
-        c17 = v_fma(b5, a0, c17);
-
-        a0 = v_setall_f32(a[3]);
-        c18 = v_fma(b0, a0, c18);
-        c19 = v_fma(b1, a0, c19);
-        c20 = v_fma(b2, a0, c20);
-        c21 = v_fma(b3, a0, c21);
-        c22 = v_fma(b4, a0, c22);
-        c23 = v_fma(b5, a0, c23);
-    }
-
-    if (!init_c)
-    {
-        c0 += v_load(c);
-        c1 += v_load(c + 4);
-        c2 += v_load(c + 8);
-        c3 += v_load(c + 12);
-        c4 += v_load(c + 16);
-        c5 += v_load(c + 20);
-
-        c6  += v_load(c + ldc);
-        c7  += v_load(c + ldc + 4);
-        c8  += v_load(c + ldc + 8);
-        c9  += v_load(c + ldc + 12);
-        c10 += v_load(c + ldc + 16);
-        c11 += v_load(c + ldc + 20);
-
-        c12 += v_load(c + ldc*2);
-        c13 += v_load(c + ldc*2 + 4);
-        c14 += v_load(c + ldc*2 + 8);
-        c15 += v_load(c + ldc*2 + 12);
-        c16 += v_load(c + ldc*2 + 16);
-        c17 += v_load(c + ldc*2 + 20);
-
-        c18 += v_load(c + ldc*3);
-        c19 += v_load(c + ldc*3 + 4);
-        c20 += v_load(c + ldc*3 + 8);
-        c21 += v_load(c + ldc*3 + 12);
-        c22 += v_load(c + ldc*3 + 16);
-        c23 += v_load(c + ldc*3 + 20);
-    }
-
-    v_store(c, c0);
-    v_store(c + 4, c1);
-    v_store(c + 8, c2);
-    v_store(c + 12, c3);
-    v_store(c + 16, c4);
-    v_store(c + 20, c5);
-
-    v_store(c + ldc, c6);
-    v_store(c + ldc + 4, c7);
-    v_store(c + ldc + 8, c8);
-    v_store(c + ldc + 12, c9);
-    v_store(c + ldc + 16, c10);
-    v_store(c + ldc + 20, c11);
-
-    v_store(c + ldc * 2, c12);
-    v_store(c + ldc * 2 + 4, c13);
-    v_store(c + ldc * 2 + 8, c14);
-    v_store(c + ldc * 2 + 12, c15);
-    v_store(c + ldc * 2 + 16, c16);
-    v_store(c + ldc * 2 + 20, c17);
-
-    v_store(c + ldc * 3, c18);
-    v_store(c + ldc * 3 + 4, c19);
-    v_store(c + ldc * 3 + 8, c20);
-    v_store(c + ldc * 3 + 12, c21);
-    v_store(c + ldc * 3 + 16, c22);
-    v_store(c + ldc * 3 + 20, c23);
-}
-#endif
-
-static void convBlock4x8(int np, const float* a, const float* b, float* c, int ldc, bool init_c)
-{
-    CV_Assert(CONV_NR >= 4);
-    v_float32x4 c0  = v_setzero_f32(), c1 = c0, c2 = c0, c3 = c0;
-    v_float32x4 c4 = c0, c5 = c0, c6 = c0, c7 = c0;
-
-    for (int p = 0; p < np; p++, a += CONV_MR, b += CONV_NR)
-    {
-        v_float32x4 a0 = v_setall_f32(a[0]);
-        v_float32x4 a1 = v_setall_f32(a[1]);
-        v_float32x4 a2 = v_setall_f32(a[2]);
-        v_float32x4 a3 = v_setall_f32(a[3]);
-
-        v_float32x4 b0 = v_load(b), b1 = v_load(b + 4);
-
-        c0 = v_fma(b0, a0, c0);
-        c1 = v_fma(b1, a0, c1);
-
-        c2 = v_fma(b0, a1, c2);
-        c3 = v_fma(b1, a1, c3);
-
-        c4 = v_fma(b0, a2, c4);
-        c5 = v_fma(b1, a2, c5);
-
-        c6  = v_fma(b0, a3, c6);
-        c7  = v_fma(b1, a3, c7);
-    }
-
-    if (!init_c)
-    {
-        c0 += v_load(c);
-        c1 += v_load(c + 4);
-
-        c2  += v_load(c + ldc);
-        c3  += v_load(c + ldc + 4);
-
-        c4 += v_load(c + ldc*2);
-        c5 += v_load(c + ldc*2 + 4);
-
-        c6 += v_load(c + ldc*3);
-        c7 += v_load(c + ldc*3 + 4);
-    }
-
-    v_store(c, c0);
-    v_store(c + 4, c1);
-    v_store(c + ldc, c2);
-    v_store(c + ldc + 4, c3);
-    v_store(c + ldc * 2, c4);
-    v_store(c + ldc * 2 + 4, c5);
-    v_store(c + ldc * 3, c6);
-    v_store(c + ldc * 3 + 4, c7);
-}
-
-static void convBlock4x4(int np, const float* a, const float* b, float* c, int ldc, bool init_c)
-{
-    CV_Assert(CONV_NR >= 4);
-    v_float32x4 c0  = v_setzero_f32(), c1 = c0, c2 = c0, c3 = c0;
-
-    for (int p = 0; p < np; p++, a += CONV_MR, b += CONV_NR)
-    {
-        v_float32x4 a0 = v_setall_f32(a[0]);
-        v_float32x4 a1 = v_setall_f32(a[1]);
-        v_float32x4 a2 = v_setall_f32(a[2]);
-        v_float32x4 a3 = v_setall_f32(a[3]);
-
-        v_float32x4 b0 = v_load(b);
-
-        c0 = v_fma(b0, a0, c0);
-        c1 = v_fma(b0, a1, c1);
-        c2 = v_fma(b0, a2, c2);
-        c3 = v_fma(b0, a3, c3);
-    }
-
-    if (!init_c)
-    {
-        c0 += v_load(c);
-        c1 += v_load(c + ldc);
-        c2 += v_load(c + ldc*2);
-        c3 += v_load(c + ldc*3);
-    }
-
-    v_store(c, c0);
-    v_store(c + ldc, c1);
-    v_store(c + ldc * 2, c2);
-    v_store(c + ldc * 3, c3);
-}
-#endif
-
-static void convBlockNoSIMD(int np, const float* a, const float* b, float* c, int ldc, bool init_c, const int outLen)
-{
-    std::vector<float> cbuffer(CONV_MR * outLen, 0);
-    float* cbuf = cbuffer.data();
-    for( int p = 0; p < np; p++ )
-    {
-        for( int i = 0; i < CONV_MR; i++ )
-        {
-            float ai = a[CONV_MR*p + i];
-            for( int j = 0; j < outLen; j++ )
-                cbuf[i * outLen+j] += b[CONV_NR*p + j] * ai;
-        }
-    }
-
-    if (!init_c)
-    {
-        for(int i = 0; i < CONV_MR; i++)
-        {
-            for(int j = 0; j < outLen; j++)
-                c[i*ldc + j] += cbuf[i*outLen + j];
-        }
-    }
-    else
-    {
-        for(int i = 0; i < CONV_MR; i++)
-        {
-            for(int j = 0; j < outLen; j++)
-                c[i*ldc + j] = cbuf[i*outLen + j];
-        }
-    }
-}
-
-void convBlock(int np, const float* a, const float* b, float* c, int ldc, bool init_c, const int outLen)
-{
-    // The possible outLen range is [24, 8~1].
-#if CV_SIMD128
-#if CONV_MR == 4 && CONV_NR == 24
-    const int CONV_NRby3 = CONV_NR/3;
-    if (outLen > CONV_NRby3)
-    {
-        convBlock4x24(np, a, b, c, ldc, init_c);
-        return;
-    }
-#endif
-
-    if (outLen <= 8 && outLen > 4)
-    {
-        convBlock4x8(np, a, b, c, ldc, init_c);
-        return;
-    }
-
-    if (outLen <= 4 && outLen > 1)
-    {
-        convBlock4x4(np, a, b, c, ldc, init_c);
-        return;
-    }
-    convBlockNoSIMD(np, a, b, c, ldc, init_c, outLen);
-#else
-    convBlockNoSIMD(np, a, b, c, ldc, init_c, outLen);
-#endif
-}
-} // namespace dnn
-
-namespace opt_NEON
-{
-#if CV_TRY_NEON
-void convBlock_NEON(int np, const float* a, const float* b, float* c, int ldc, bool init_c)
-{
-#if CONV_MR == 4 && CONV_NR == 28  // AARCH64
-    {
-        float32x4_t c00 = vdupq_n_f32(0.f), c01 = c00, c02 = c00, c03 = c00, c04 = c00, c05 = c00, c06 = c00;
-        float32x4_t c10 = vdupq_n_f32(0.f), c11 = c10, c12 = c10, c13 = c10, c14 = c10, c15 = c10, c16 = c10;
-        float32x4_t c20 = vdupq_n_f32(0.f), c21 = c20, c22 = c20, c23 = c20, c24 = c20, c25 = c20, c26 = c20;
-        float32x4_t c30 = vdupq_n_f32(0.f), c31 = c30, c32 = c30, c33 = c30, c34 = c30, c35 = c30, c36 = c30;
-
-        for( int p = 0; p < np; p++, a += CONV_MR, b += CONV_NR )
-        {
-            float32x4_t a0 = vld1q_f32(a), b0, b1, b2;
-            b0 = vld1q_f32(b); b1 = vld1q_f32(b + 4); b2 = vld1q_f32(b + 8);
-
-            c00 = vfmaq_laneq_f32(c00, b0, a0, 0);
-            c01 = vfmaq_laneq_f32(c01, b1, a0, 0);
-            c02 = vfmaq_laneq_f32(c02, b2, a0, 0);
-            c10 = vfmaq_laneq_f32(c10, b0, a0, 1);
-            c11 = vfmaq_laneq_f32(c11, b1, a0, 1);
-            c12 = vfmaq_laneq_f32(c12, b2, a0, 1);
-            c20 = vfmaq_laneq_f32(c20, b0, a0, 2);
-            c21 = vfmaq_laneq_f32(c21, b1, a0, 2);
-            c22 = vfmaq_laneq_f32(c22, b2, a0, 2);
-            c30 = vfmaq_laneq_f32(c30, b0, a0, 3);
-            c31 = vfmaq_laneq_f32(c31, b1, a0, 3);
-            c32 = vfmaq_laneq_f32(c32, b2, a0, 3);
-
-            b0 = vld1q_f32(b + 12); b1 = vld1q_f32(b + 16); b2 = vld1q_f32(b + 20);
-
-            c03 = vfmaq_laneq_f32(c03, b0, a0, 0);
-            c04 = vfmaq_laneq_f32(c04, b1, a0, 0);
-            c05 = vfmaq_laneq_f32(c05, b2, a0, 0);
-            c13 = vfmaq_laneq_f32(c13, b0, a0, 1);
-            c14 = vfmaq_laneq_f32(c14, b1, a0, 1);
-            c15 = vfmaq_laneq_f32(c15, b2, a0, 1);
-            c23 = vfmaq_laneq_f32(c23, b0, a0, 2);
-            c24 = vfmaq_laneq_f32(c24, b1, a0, 2);
-            c25 = vfmaq_laneq_f32(c25, b2, a0, 2);
-            c33 = vfmaq_laneq_f32(c33, b0, a0, 3);
-            c34 = vfmaq_laneq_f32(c34, b1, a0, 3);
-            c35 = vfmaq_laneq_f32(c35, b2, a0, 3);
-
-            b0 = vld1q_f32(b + 24);
-            c06 = vfmaq_laneq_f32(c06, b0, a0, 0);
-            c16 = vfmaq_laneq_f32(c16, b0, a0, 1);
-            c26 = vfmaq_laneq_f32(c26, b0, a0, 2);
-            c36 = vfmaq_laneq_f32(c36, b0, a0, 3);
-        }
-
-        if (!init_c)
-        {
-            c00 = vaddq_f32(c00, vld1q_f32(c));
-            c01 = vaddq_f32(c01, vld1q_f32(c + 4));
-            c02 = vaddq_f32(c02, vld1q_f32(c + 8));
-            c03 = vaddq_f32(c03, vld1q_f32(c + 12));
-            c04 = vaddq_f32(c04, vld1q_f32(c + 16));
-            c05 = vaddq_f32(c05, vld1q_f32(c + 20));
-            c06 = vaddq_f32(c06, vld1q_f32(c + 24));
-
-            c10 = vaddq_f32(c10, vld1q_f32(c + ldc));
-            c11 = vaddq_f32(c11, vld1q_f32(c + ldc + 4));
-            c12 = vaddq_f32(c12, vld1q_f32(c + ldc + 8));
-            c13 = vaddq_f32(c13, vld1q_f32(c + ldc + 12));
-            c14 = vaddq_f32(c14, vld1q_f32(c + ldc + 16));
-            c15 = vaddq_f32(c15, vld1q_f32(c + ldc + 20));
-            c16 = vaddq_f32(c16, vld1q_f32(c + ldc + 24));
-
-            c20 = vaddq_f32(c20, vld1q_f32(c + ldc*2));
-            c21 = vaddq_f32(c21, vld1q_f32(c + ldc*2 + 4));
-            c22 = vaddq_f32(c22, vld1q_f32(c + ldc*2 + 8));
-            c23 = vaddq_f32(c23, vld1q_f32(c + ldc*2 + 12));
-            c24 = vaddq_f32(c24, vld1q_f32(c + ldc*2 + 16));
-            c25 = vaddq_f32(c25, vld1q_f32(c + ldc*2 + 20));
-            c26 = vaddq_f32(c26, vld1q_f32(c + ldc*2 + 24));
-
-            c30 = vaddq_f32(c30, vld1q_f32(c + ldc*3));
-            c31 = vaddq_f32(c31, vld1q_f32(c + ldc*3 + 4));
-            c32 = vaddq_f32(c32, vld1q_f32(c + ldc*3 + 8));
-            c33 = vaddq_f32(c33, vld1q_f32(c + ldc*3 + 12));
-            c34 = vaddq_f32(c34, vld1q_f32(c + ldc*3 + 16));
-            c35 = vaddq_f32(c35, vld1q_f32(c + ldc*3 + 20));
-            c36 = vaddq_f32(c36, vld1q_f32(c + ldc*3 + 24));
-        }
-
-        vst1q_f32(c, c00); vst1q_f32(c+4, c01);
-        vst1q_f32(c+8, c02); vst1q_f32(c+12, c03);
-        vst1q_f32(c+16, c04); vst1q_f32(c+20, c05);
-        vst1q_f32(c+24, c06);
-
-        vst1q_f32(c+ldc, c10); vst1q_f32(c+ldc+4, c11);
-        vst1q_f32(c+ldc+8, c12); vst1q_f32(c+ldc+12, c13);
-        vst1q_f32(c+ldc+16, c14); vst1q_f32(c+ldc+20, c15);
-        vst1q_f32(c+ldc+24, c16);
-
-        vst1q_f32(c+ldc*2, c20); vst1q_f32(c+ldc*2+4, c21);
-        vst1q_f32(c+ldc*2+8, c22); vst1q_f32(c+ldc*2+12, c23);
-        vst1q_f32(c+ldc*2+16, c24); vst1q_f32(c+ldc*2+20, c25);
-        vst1q_f32(c+ldc*2+24, c26);
-
-        vst1q_f32(c+ldc*3, c30); vst1q_f32(c+ldc*3+4, c31);
-        vst1q_f32(c+ldc*3+8, c32); vst1q_f32(c+ldc*3+12, c33);
-        vst1q_f32(c+ldc*3+16, c34); vst1q_f32(c+ldc*3+20, c35);
-        vst1q_f32(c+ldc*3+24, c36);
-    }
-#elif CONV_MR == 4 && CONV_NR == 12 // ARMv7
-    {
-        float32x4_t c0 = vdupq_n_f32(0.f), c1 = c0, c2 = c0;
-        float32x4_t c3 = vdupq_n_f32(0.f), c4 = c3, c5 = c3;
-        float32x4_t c6 = vdupq_n_f32(0.f), c7 = c6, c8 = c6;
-        float32x4_t c9 = vdupq_n_f32(0.f), c10 = c9, c11 = c9;
-
-
-        float32x2_t a0 = vdup_n_f32(0.0f), a1 = a0;
-        float32x4_t b0 = vdupq_n_f32(0.0f), b1 = vdupq_n_f32(0.0f), b2 = vdupq_n_f32(0.0f);
-
-        for (int p = 0; p < np; p++, a += CONV_MR, b += CONV_NR)
-        {
-            a0 = vld1_f32(a), a1 = vld1_f32(a+2);
-            b0 = vld1q_f32(b), b1 = vld1q_f32(b + 4), b2 = vld1q_f32(b + 8);
-
-            c0 = vmlaq_lane_f32(c0, b0, a0, 0);
-            c1 = vmlaq_lane_f32(c1, b1, a0, 0);
-            c2 = vmlaq_lane_f32(c2, b2, a0, 0);
-
-            c3 = vmlaq_lane_f32(c3, b0, a0, 1);
-            c4 = vmlaq_lane_f32(c4, b1, a0, 1);
-            c5 = vmlaq_lane_f32(c5, b2, a0, 1);
-
-            c6 = vmlaq_lane_f32(c6, b0, a1, 0);
-            c7 = vmlaq_lane_f32(c7, b1, a1, 0);
-            c8 = vmlaq_lane_f32(c8, b2, a1, 0);
-
-            c9  = vmlaq_lane_f32(c9 , b0, a1, 1);
-            c10 = vmlaq_lane_f32(c10, b1, a1, 1);
-            c11 = vmlaq_lane_f32(c11, b2, a1, 1);
-        }
-
-        if (!init_c)
-        {
-            c0 = vaddq_f32(c0, vld1q_f32(c));
-            c1 = vaddq_f32(c1, vld1q_f32(c + 4));
-            c2 = vaddq_f32(c2, vld1q_f32(c + 8));
-
-            c3 = vaddq_f32(c3, vld1q_f32(c + ldc));
-            c4 = vaddq_f32(c4, vld1q_f32(c + ldc + 4));
-            c5 = vaddq_f32(c5, vld1q_f32(c + ldc + 8));
-
-            c6 = vaddq_f32(c6, vld1q_f32(c + ldc * 2));
-            c7 = vaddq_f32(c7, vld1q_f32(c + ldc * 2 + 4));
-            c8 = vaddq_f32(c8, vld1q_f32(c + ldc * 2 + 8));
-
-            c9  = vaddq_f32(c9 , vld1q_f32(c + ldc * 3));
-            c10 = vaddq_f32(c10, vld1q_f32(c + ldc * 3 + 4));
-            c11 = vaddq_f32(c11, vld1q_f32(c + ldc * 3 + 8));
-        }
-
-        vst1q_f32(c, c0), vst1q_f32(c+4, c1), vst1q_f32(c+8, c2);
-        vst1q_f32(c + ldc, c3), vst1q_f32(c + ldc + 4, c4), vst1q_f32(c + ldc + 8, c5);
-        vst1q_f32(c + ldc*2, c6), vst1q_f32(c + ldc*2 + 4, c7), vst1q_f32(c + ldc*2 + 8, c8);
-        vst1q_f32(c + ldc*3, c9), vst1q_f32(c + ldc*3 + 4, c10), vst1q_f32(c + ldc*3 + 8, c11);
-    }
-//#else
-//#error "unsupported CONV_MR and/or CONV_NR in convBlock_NEON."
-#endif
-}
-#endif
-} // namespace opt_NEON
-
-} // namespace cv
-#endif //OPENCV_FAST_CONVOLUTION_SIMD_HPP

modules/dnn/src/layers/flatten_layer.cpp

@@ -176,15 +176,16 @@ public:
     }
 
 #ifdef HAVE_CANN
-    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
+    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputs,
+                                      const std::vector<Ptr<BackendWrapper> > &outputs,
+                                      const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
     {
-        auto x = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
+        auto x = inputs[0].dynamicCast<CannBackendWrapper>();
         auto x_desc = x->getTensorDesc();
         auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
         auto output_desc = std::make_shared<ge::TensorDesc>(ge::Shape(), ge::FORMAT_NCHW, ge::DT_FLOAT);
 
-        std::string op_name = cv::format("flatten_%d", index);
-        auto op = std::make_shared<ge::op::FlattenV2>(op_name);
+        auto op = std::make_shared<ge::op::FlattenV2>(name);
 
         // set attributes
         int num_axes = x->host->dims;
@@ -194,7 +195,7 @@ public:
         op->set_attr_end_axis(end_axis);
 
         // set inputs
-        op->set_input_x_by_name(*op_x, "y");
+        op->set_input_x_by_name(*op_x, x->name.c_str());
         op->update_input_desc_x(*x_desc);
         // set outputs
         op->update_output_desc_y(*output_desc);

modules/dnn/src/layers/fully_connected_layer.cpp

@@ -48,6 +48,7 @@
 #include "../ie_ngraph.hpp"
 #include "../op_webnn.hpp"
 #include "../op_cann.hpp"
+#include "../op_vkcom.hpp"
 
 #include <opencv2/dnn/shape_utils.hpp>
 
@@ -115,6 +116,8 @@ public:
                 biasMat = Mat::zeros(1, oriMat.size[oriMat.dims - 2], weightsMat.type());
             else
                 biasMat = Mat::zeros(1, numOutput, weightsMat.type());
+
+            transB = !transB;
         }
     }
 
@@ -155,7 +158,6 @@ public:
         }
         else
         {
-            CV_Assert(!transA && !transB);
             CV_CheckEQ(inputsTmp.size(), (size_t)1, "");
             CV_CheckEQ(blobs[0].dims, 2, "");
             if(isMatMul)
@@ -183,10 +185,11 @@ public:
             return axis == 1 && !tranAorB;
 #endif
         return backendId == DNN_BACKEND_OPENCV ||
-               (backendId == DNN_BACKEND_CUDA && !tranAorB) ||
+               backendId == DNN_BACKEND_CUDA ||
                (backendId == DNN_BACKEND_HALIDE && haveHalide() && axis == 1 && !tranAorB) ||
                (backendId == DNN_BACKEND_WEBNN && axis == 1 && !tranAorB) ||
-               backendId == DNN_BACKEND_CANN;;
+               backendId == DNN_BACKEND_CANN ||
+               (backendId == DNN_BACKEND_VKCOM && haveVulkan() && !tranAorB);
     }
 
     virtual bool setActivation(const Ptr<ActivationLayer>& layer) CV_OVERRIDE
@@ -527,7 +530,6 @@ public:
 
         if (!blobs.empty())
         {
-            CV_Assert(!transA && !transB);
             int inp1Dim = input[0].dims;
             if (isMatMul)
             {
@@ -611,12 +613,12 @@ public:
         const std::vector<Ptr<BackendWrapper>>& outputs
     ) override
     {
+        auto biasMat_ = bias ? biasMat : Mat();
         auto context = reinterpret_cast<csl::CSLContext*>(context_);
         auto input_wrapper = inputs[0].dynamicCast<CUDABackendWrapper>();
 
         if (weightsMat.empty() || isMatMul)
         {
-            CV_Assert(!bias);
             int inp2Dim;
             // broadcast is not supported with CUDA
             if(weightsMat.empty())
@@ -627,17 +629,82 @@ public:
                 inp2Dim = oriMat.dims;
 
             if(input_wrapper->getRank() == inp2Dim)
-                return make_cuda_node<cuda4dnn::MatMulOp>(preferableTarget, std::move(context->stream), std::move(context->cublas_handle), oriMat);
+                return make_cuda_node<cuda4dnn::MatMulOp>(preferableTarget, std::move(context->stream), std::move(context->cublas_handle), oriMat, biasMat_, transA, transB);
             else
                 return Ptr<BackendNode>();
         }
 
         auto flatten_start_axis = normalize_axis(axis, input_wrapper->getRank());
-        auto biasMat_ = bias ? biasMat : Mat();
         return make_cuda_node<cuda4dnn::InnerProductOp>(preferableTarget, std::move(context->stream), std::move(context->cublas_handle), flatten_start_axis, weightsMat, biasMat_);
     }
 #endif
 
+#ifdef HAVE_VULKAN
+    virtual Ptr<BackendNode> initVkCom(const std::vector<Ptr<BackendWrapper> > &inputs,
+                                       std::vector<Ptr<BackendWrapper> > &outputs) CV_OVERRIDE
+    {
+        auto biasMat_ = bias ? biasMat : Mat();
+        auto input_wrapper = inputs[0].dynamicCast<VkComBackendWrapper>();
+
+        CV_Assert((inputs.size() == 2 || inputs.size() == 1) && outputs.size() == 1);
+        std::vector<Mat> vkBlobs;
+        Ptr<vkcom::OpBase> op;
+
+        if (!biasMat_.empty() || !activ.empty())
+        {
+            return Ptr<BackendNode>();
+        }
+
+        Ptr<VkComBackendWrapper> outputWrap = outputs[0].dynamicCast<VkComBackendWrapper>();
+        CV_Assert(outputWrap);
+        // TODO: Currently, we only support the 2D MatMul. Need support the FC layer and bias case in the future.
+
+        if (inputs.size() == 2)
+        {
+            Ptr<VkComBackendWrapper> inputWrap0 = inputs[0].dynamicCast<VkComBackendWrapper>();
+            Ptr<VkComBackendWrapper> inputWrap1 = inputs[1].dynamicCast<VkComBackendWrapper>();
+            CV_Assert(inputWrap0 && inputWrap1);
+
+            MatShape inpShape0 = shape(*inputWrap0->getMat());
+            MatShape inpShape1 = shape(*inputWrap1->getMat());
+            MatShape outShape = shape(*outputWrap->getMat());
+
+            // TODO Currently, vulkan only support 2D matmul. Try to support 3D and 4D matmul.
+            if (inpShape0.size() != 2 || inpShape1.size() != 2)
+                return Ptr<BackendNode>();
+
+            op = (new vkcom::OpMatMul(vkBlobs, inpShape0[0], inpShape0[1], outShape[1]));
+        }
+        else
+        {
+            CV_Assert(!weightsMat.empty());
+            Mat wm;
+            weightsMat.copyTo(wm); // to handle the case of isContinuous() == false
+            wm = wm.reshape(1, blobs[0].dims, blobs[0].size);
+            vkBlobs.push_back(wm.t());
+
+            Ptr<VkComBackendWrapper> inputWrap = inputs[0].dynamicCast<VkComBackendWrapper>();
+            CV_Assert(inputWrap);
+
+            MatShape inpShape = shape(*inputWrap->getMat());
+            MatShape outShape = shape(*outputWrap->getMat());
+            MatShape wShape = shape(weightsMat);
+
+            // TODO Currently, vulkan only support 2D matmul. Try to support 3D and 4D matmul.
+            if (inpShape.size() != 2 || wShape.size() != 2)
+                return Ptr<BackendNode>();
+
+            // TODO: Currently, only focus on 2D MatMul.
+            CV_Assert(inpShape.size() == 2 && outShape.size() == 2 && wShape.size() == 2);
+            CV_Assert(inpShape[1] == outShape[0]);
+            op = (new vkcom::OpMatMul(vkBlobs, inpShape[0], inpShape[1], outShape[1]));
+        }
+
+        return Ptr<BackendNode>(new VkComBackendNode(inputs, op, outputs));
+    }
+#endif
+
+
     virtual Ptr<BackendNode> initHalide(const std::vector<Ptr<BackendWrapper> > &inputs) CV_OVERRIDE
     {
 #ifdef HAVE_HALIDE
@@ -663,15 +730,16 @@ public:
     }
 
 #ifdef HAVE_CANN
-    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
+    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputs,
+                                      const std::vector<Ptr<BackendWrapper> > &outputs,
+                                      const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
     {
-        auto x1 = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
+        auto x1 = inputs[0].dynamicCast<CannBackendWrapper>();
         auto x1_desc = x1->getTensorDesc();
         auto op_x1 = nodes[0].dynamicCast<CannBackendNode>()->getOp();
         auto output_desc = std::make_shared<ge::TensorDesc>(ge::Shape(), ge::FORMAT_NCHW, ge::DT_FLOAT);
 
-        std::string op_name = cv::format("matmul_%d", index);
-        auto op = std::make_shared<ge::op::MatMulV2>(op_name);
+        auto op = std::make_shared<ge::op::MatMulV2>(name);
 
         if (!blobs.empty()) // if B is const
         {
@@ -683,14 +751,14 @@ public:
 
             // set inputs
             // set inputs : x2 (weight)
-            auto op_const_weight = std::make_shared<CannConstOp>(weightsMat.data, weightsMat.type(), shape(weightsMat), cv::format("%s_w", op_name.c_str()));
+            auto op_const_weight = std::make_shared<CannConstOp>(weightsMat.data, weightsMat.type(), shape(weightsMat), cv::format("%s_w", name.c_str()));
             op->set_input_x2_by_name(*(op_const_weight->getOp()), "y");
             op->update_input_desc_x2(*(op_const_weight->getTensorDesc()));
         }
         else
         {
             // A and B are variable inputs; non-const bias is not considered
-            CV_Assert(inputsWrapper.size() == 2);
+            CV_Assert(inputs.size() == 2);
             CV_Assert(nodes.size() == 2);
 
             // set attributes
@@ -699,19 +767,19 @@ public:
 
             // set inputs : x2 (weight)
             auto op_x2 = nodes[1].dynamicCast<CannBackendNode>()->getOp();
-            auto x2_desc = inputsWrapper[1].dynamicCast<CannBackendWrapper>()->getTensorDesc();
+            auto x2_desc = inputs[1].dynamicCast<CannBackendWrapper>()->getTensorDesc();
             op->set_input_x2_by_name(*op_x2, "y");
             op->update_input_desc_x2(*x2_desc);
         }
 
         // set inputs
         // set inputs : x1 (input)
-        op->set_input_x1_by_name(*op_x1, "y");
+        op->set_input_x1_by_name(*op_x1, x1->name.c_str());
         op->update_input_desc_x1(*x1_desc);
         // set inputs : bias (bias)
         auto bias_mat = bias ? biasMat : Mat::zeros(1, weightsMat.size[0], weightsMat.type());
         std::vector<int> bias_shape{weightsMat.size[0]};
-        auto op_const_bias = std::make_shared<CannConstOp>(bias_mat.data, bias_mat.type(), bias_shape, cv::format("%s_b", op_name.c_str()));
+        auto op_const_bias = std::make_shared<CannConstOp>(bias_mat.data, bias_mat.type(), bias_shape, cv::format("%s_b", name.c_str()));
         op->set_input_bias(*(op_const_bias->getOp()));
         op->update_input_desc_bias(*(op_const_bias->getTensorDesc()));
 
@@ -844,15 +912,27 @@ public:
     {
         CV_UNUSED(inputs); // suppress unused variable warning
         long flops = 0;
+        int innerSize = 0;
+
+        if (!blobs.empty())
+        {
+            innerSize = blobs[0].size[1];
+        }
+        else
+        {
+            CV_Assert(inputs.size() == 2);
+            if (transB)
+                innerSize = inputs[1][1];
+            else
+                innerSize = inputs[1][0];
+        }
 
-        int innerSize = blobs[0].size[1];
         for(int i = 0; i < outputs.size(); i++)
         {
             flops += CV_BIG_INT(3)*innerSize*total(outputs[i]);
         }
 
         return flops;
-
     }
 
     bool bias;

modules/dnn/src/layers/layers_common.simd.hpp

@@ -46,16 +46,6 @@ namespace cv {
 namespace dnn {
 CV_CPU_OPTIMIZATION_NAMESPACE_BEGIN
 
-void fastDepthwiseConv( const float* weights,
-                      int kernel_h, int kernel_w,
-                      int stride_h, int stride_w,
-                      int dilation_h, int dilation_w,
-                      int pad_t, int pad_l,
-                      const float* bias, const float* relu,
-                      const float* inptr,
-                      int height, int width,
-                      float* outptr,
-                      int out_d, int outH, int outW );
 void fastGEMM1T( const float* vec, const float* weights,
                  size_t wstep, const float* bias,
                  float* dst, int nvecs, int vecsize );
@@ -70,185 +60,6 @@ void fastGEMM( const float* aptr, size_t astep, const float* bptr,
 #define _mm256_fmadd_ps(a, b, c) _mm256_add_ps(c, _mm256_mul_ps(a, b))
 #endif
 
-static inline void _mm256_load_deinterleave(const float* ptr, __m256& a, __m256& b)
-{
-    __m256 t0 = _mm256_loadu_ps(ptr);
-    __m256 t1 = _mm256_loadu_ps(ptr + 8);
-
-    __m256 lo = _mm256_permute2f128_ps(t0, t1, 0+2*16);
-    __m256 hi = _mm256_permute2f128_ps(t0, t1, 1+3*16);
-    a = _mm256_shuffle_ps(lo, hi, 0x88);
-    b = _mm256_shuffle_ps(lo, hi, 0xdd);
-}
-
-void fastDepthwiseConv( const float* wptr,
-                     int kernel_h, int kernel_w,
-                     int stride_h, int stride_w,
-                     int dilation_h, int dilation_w,
-                     int pad_t, int pad_l,
-                     const float* biasptr, const float* relu,
-                     const float* inptr_,
-                     int height, int width,
-                     float* outptr_,
-                     int out_d, int outH, int outW )
-{
-    const float w00_ = wptr[0], w01_ = wptr[1], w02_ = wptr[2],
-                w10 = wptr[3], w11 = wptr[4], w12 = wptr[5],
-                w20_ = wptr[6], w21_ = wptr[7], w22_ = wptr[8];
-    int outW1 = min(outW, (width - dilation_w*(kernel_w - 1) + pad_l)/stride_w);
-    float relu_coeff = relu ? relu[out_d] : 1.f, bias = biasptr[out_d];
-
-    for (int out_i = 0; out_i < outH; out_i++)
-    {
-        int in_i = out_i * stride_h - pad_t, out_j = 0;
-        const float* imgptr0 = inptr_ + in_i*width;
-        const float* imgptr1 = imgptr0 + dilation_h*width;
-        const float* imgptr2 = imgptr0 + (dilation_h*2)*width;
-        float out, w00 = w00_, w01 = w01_, w02 = w02_;
-        float w20 = w20_, w21 = w21_, w22 = w22_;
-        if (in_i < 0)
-        {
-            w00 = w01 = w02 = 0.f;
-            imgptr0 = imgptr1;
-        }
-        else if (in_i + dilation_h*(kernel_h-1) >= height)
-        {
-            w20 = w21 = w22 = 0.f;
-            imgptr2 = imgptr1;
-        }
-        float* outptr = outptr_ + out_i*outW;
-        if (pad_l > 0)
-        {
-            out = imgptr0[0]*w01 + imgptr0[dilation_w]*w02 +
-                  imgptr1[0]*w11 + imgptr1[dilation_w]*w12 +
-                  imgptr2[0]*w21 + imgptr2[dilation_w]*w22 + bias;
-            if (relu)
-                out = out > 0.f ? out : out*relu_coeff;
-            outptr[0] = out;
-            out_j = 1;
-        }
-
-        if (stride_w == 1 || (stride_w == 2 && dilation_w == 1))
-        {
-            const int VECSZ = 8;
-            __m256 vw00 = _mm256_set1_ps(w00), vw01 = _mm256_set1_ps(w01), vw02 = _mm256_set1_ps(w02),
-                      vw10 = _mm256_set1_ps(w10), vw11 = _mm256_set1_ps(w11), vw12 = _mm256_set1_ps(w12),
-                      vw20 = _mm256_set1_ps(w20), vw21 = _mm256_set1_ps(w21), vw22 = _mm256_set1_ps(w22);
-            __m256 z = _mm256_setzero_ps(), vbias = _mm256_set1_ps(bias), vrc = _mm256_set1_ps(relu_coeff);
-
-            if( stride_w == 1 )
-                for( ; out_j < outW1; out_j += VECSZ )
-                {
-                    if (out_j + VECSZ > outW1 && out_j > pad_l)
-                        out_j = outW1 - VECSZ;
-                    int in_j = out_j * stride_w - pad_l;
-                    __m256 v00 = _mm256_loadu_ps(imgptr0 + in_j),
-                           v01 = _mm256_loadu_ps(imgptr0 + in_j + dilation_w),
-                           v02 = _mm256_loadu_ps(imgptr0 + in_j + dilation_w*2),
-                           v10 = _mm256_loadu_ps(imgptr1 + in_j),
-                           v11 = _mm256_loadu_ps(imgptr1 + in_j + dilation_w),
-                           v12 = _mm256_loadu_ps(imgptr1 + in_j + dilation_w*2),
-                           v20 = _mm256_loadu_ps(imgptr2 + in_j),
-                           v21 = _mm256_loadu_ps(imgptr2 + in_j + dilation_w),
-                           v22 = _mm256_loadu_ps(imgptr2 + in_j + dilation_w*2);
-
-                    __m256 vout0 = _mm256_fmadd_ps(v00, vw00, vbias);
-                    __m256 vout1 = _mm256_mul_ps(v01, vw01);
-                    __m256 vout2 = _mm256_mul_ps(v02, vw02);
-
-                    vout0 = _mm256_fmadd_ps(v10, vw10, vout0);
-                    vout1 = _mm256_fmadd_ps(v11, vw11, vout1);
-                    vout2 = _mm256_fmadd_ps(v12, vw12, vout2);
-
-                    vout0 = _mm256_fmadd_ps(v20, vw20, vout0);
-                    vout1 = _mm256_fmadd_ps(v21, vw21, vout1);
-                    vout2 = _mm256_fmadd_ps(v22, vw22, vout2);
-
-                    vout0 = _mm256_add_ps(_mm256_add_ps(vout0, vout1), vout2);
-                    if (relu)
-                    {
-                        __m256 m = _mm256_cmp_ps(vout0, z, _CMP_GT_OQ);
-                        vout0 = _mm256_blendv_ps(_mm256_mul_ps(vout0, vrc), vout0, m);
-                    }
-                    _mm256_storeu_ps(outptr + out_j, vout0);
-                }
-            else
-                for( ; out_j < outW1; out_j += VECSZ )
-                {
-                    if (out_j + VECSZ > outW1 && out_j > pad_l)
-                        out_j = outW1 - VECSZ;
-                    int in_j = out_j * stride_w - pad_l;
-                    __m256 v00, v01, v02, v10, v11, v12, v20, v21, v22, unused;
-                    _mm256_load_deinterleave(imgptr0 + in_j, v00, v01);
-                    _mm256_load_deinterleave(imgptr0 + in_j + 2, v02, unused);
-                    _mm256_load_deinterleave(imgptr1 + in_j, v10, v11);
-                    _mm256_load_deinterleave(imgptr1 + in_j + 2, v12, unused);
-                    _mm256_load_deinterleave(imgptr2 + in_j, v20, v21);
-                    _mm256_load_deinterleave(imgptr2 + in_j + 2, v22, unused);
-
-                    __m256 vout0 = _mm256_fmadd_ps(v00, vw00, vbias);
-                    __m256 vout1 = _mm256_mul_ps(v01, vw01);
-                    __m256 vout2 = _mm256_mul_ps(v02, vw02);
-
-                    vout0 = _mm256_fmadd_ps(v10, vw10, vout0);
-                    vout1 = _mm256_fmadd_ps(v11, vw11, vout1);
-                    vout2 = _mm256_fmadd_ps(v12, vw12, vout2);
-
-                    vout0 = _mm256_fmadd_ps(v20, vw20, vout0);
-                    vout1 = _mm256_fmadd_ps(v21, vw21, vout1);
-                    vout2 = _mm256_fmadd_ps(v22, vw22, vout2);
-
-                    vout0 = _mm256_add_ps(_mm256_add_ps(vout0, vout1), vout2);
-                    if (relu)
-                    {
-                        __m256 m = _mm256_cmp_ps(vout0, z, _CMP_GT_OQ);
-                        vout0 = _mm256_blendv_ps(_mm256_mul_ps(vout0, vrc), vout0, m);
-                    }
-                    _mm256_storeu_ps(outptr + out_j, vout0);
-                }
-        }
-
-        for (; out_j < outW1; out_j++)
-        {
-            int in_j = out_j * stride_w - pad_l;
-            out = imgptr0[in_j]*w00 + imgptr0[in_j + dilation_w]*w01 + imgptr0[in_j + dilation_w*2]*w02 +
-                  imgptr1[in_j]*w10 + imgptr1[in_j + dilation_w]*w11 + imgptr1[in_j + dilation_w*2]*w12 +
-                  imgptr2[in_j]*w20 + imgptr2[in_j + dilation_w]*w21 + imgptr2[in_j + dilation_w*2]*w22 + bias;
-            if (relu)
-                out = out > 0.f ? out : out*relu_coeff;
-            outptr[out_j] = out;
-        }
-
-        for (; out_j < outW; out_j++ )
-        {
-            int in_j0 = out_j * stride_w - pad_l, in_j1 = in_j0 + dilation_w, in_j2 = in_j0 + dilation_w*2;
-            float s0 = 1.f, s1 = 1.f, s2 = 1.f;
-            if (in_j0 >= width)
-            {
-                in_j0 = 0;
-                s0 = 0.f;
-            }
-            if (in_j1 >= width)
-            {
-                in_j1 = 0;
-                s1 = 0.f;
-            }
-            if (in_j2 >= width)
-            {
-                in_j2 = 0;
-                s2 = 0.f;
-            }
-            out = imgptr0[in_j0]*w00*s0 + imgptr0[in_j1]*w01*s1 + imgptr0[in_j2]*w02*s2 +
-                  imgptr1[in_j0]*w10*s0 + imgptr1[in_j1]*w11*s1 + imgptr1[in_j2]*w12*s2 +
-                  imgptr2[in_j0]*w20*s0 + imgptr2[in_j1]*w21*s1 + imgptr2[in_j2]*w22*s2 + bias;
-            if (relu)
-                out = out > 0.f ? out : out*relu_coeff;
-            outptr[out_j] = out;
-        }
-    }
-    _mm256_zeroupper();
-}
-
 // Used to generate the mask used when calculating tails
 static const uint32_t tailMaskArray[15] = {
     0, 0, 0, 0, 0, 0, 0, 0,
@@ -654,382 +465,10 @@ void fastGEMM1T( const float* vec, const float* weights,
     }
 }
 
-/*
-Example for load_deinterleave:
-    input: ptr[16] = {1,2,3, ... ,14,15,16}
-    output: a = {1, 3, 5, 7, 9, 11, 13, 15}
-    output: b = {2, 4, 6, 8,10, 12, 14, 16}
-*/
-static inline void vfloat32m2_load_deinterleave(const float* ptr, vfloat32m2_t& a, vfloat32m2_t& b, int vl)
-{
-    vuint64m4_t mask = vmv_v_x_u64m4(1,vl*2);
-    vuint32m4_t mask_re = vreinterpret_v_u64m4_u32m4(mask);
-    vbool8_t mask0 = vmseq_vx_u32m4_b8 (mask_re, 1, vl*2);
-    vbool8_t mask1 = vmseq_vx_u32m4_b8 (mask_re, 0, vl*2);
-    vfloat32m4_t tempa = vundefined_f32m4(), tempb = vundefined_f32m4();
-    vfloat32m4_t vw = vle32_v_f32m4(ptr, vl*2);
-    tempa = vcompress_vm_f32m4(mask0, tempa, vw, vl*2);
-    tempb = vcompress_vm_f32m4(mask1, tempb, vw, vl*2);
-    /* The following instructions have not to be supported by the GNU toolchain.
-       So we temporarily use store and load instead.
-    // a = vlmul_trunc_v_f32m4_f32m2(tempa);
-    // b = vlmul_trunc_v_f32m4_f32m2(tempb);
-    */
-    cv::AutoBuffer<float> cvBuffer(sizeof(float)*vl*2);
-    float* buffer = (float*)cvBuffer.data();
-    vse32_v_f32m4(buffer, tempa, vl);
-    a = vle32_v_f32m2(buffer, vl);
-    vse32_v_f32m4(buffer, tempb, vl);
-    b = vle32_v_f32m2(buffer, vl);
-}
-
-void fastDepthwiseConv( const float* wptr,
-                     int kernel_h, int kernel_w,
-                     int stride_h, int stride_w,
-                     int dilation_h, int dilation_w,
-                     int pad_t, int pad_l,
-                     const float* biasptr, const float* relu,
-                     const float* inptr_,
-                     int height, int width,
-                     float* outptr_,
-                     int out_d, int outH, int outW )
-{
-    int vl;
-    const float w00_ = wptr[0], w01_ = wptr[1], w02_ = wptr[2],
-                w10 = wptr[3], w11 = wptr[4], w12 = wptr[5],
-                w20_ = wptr[6], w21_ = wptr[7], w22_ = wptr[8];
-    int outW1 = std::min(outW, (width - dilation_w*(kernel_w - 1) + pad_l)/stride_w);
-    float relu_coeff = relu ? relu[out_d] : 1.f, bias = biasptr[out_d];
-
-    for (int out_i = 0; out_i < outH; out_i++)
-    {
-        int in_i = out_i * stride_h - pad_t, out_j = 0;
-        const float* imgptr0 = inptr_ + in_i*width;
-        const float* imgptr1 = imgptr0 + dilation_h*width;
-        const float* imgptr2 = imgptr0 + (dilation_h*2)*width;
-        float out, w00 = w00_, w01 = w01_, w02 = w02_;
-        float w20 = w20_, w21 = w21_, w22 = w22_;
-        if (in_i < 0)
-        {
-            w00 = w01 = w02 = 0.f;
-            imgptr0 = imgptr1;
-        }
-        else if (in_i + dilation_h*(kernel_h-1) >= height)
-        {
-            w20 = w21 = w22 = 0.f;
-            imgptr2 = imgptr1;
-        }
-        float* outptr = outptr_ + out_i*outW;
-        if (pad_l > 0)
-        {
-            out = imgptr0[0]*w01 + imgptr0[dilation_w]*w02 +
-                  imgptr1[0]*w11 + imgptr1[dilation_w]*w12 +
-                  imgptr2[0]*w21 + imgptr2[dilation_w]*w22 + bias;
-            if (relu)
-                out = out > 0.f ? out : out*relu_coeff;
-            outptr[0] = out;
-            out_j = 1;
-        }
-
-        if (stride_w == 1 || (stride_w == 2 && dilation_w == 1))
-        {
-            int avl = outW1 - out_j;
-            if( stride_w == 1 )
-                for( ; out_j < outW1; out_j += vl, avl -= vl)
-                {
-                    vl = vsetvl_e32m2(avl);
-                    int in_j = out_j * stride_w - pad_l;
-                    vfloat32m2_t v00 = vle32_v_f32m2(imgptr0 + in_j, vl),
-                           v01 = vle32_v_f32m2(imgptr0 + in_j + dilation_w, vl),
-                           v02 = vle32_v_f32m2(imgptr0 + in_j + dilation_w*2, vl),
-                           v10 = vle32_v_f32m2(imgptr1 + in_j, vl),
-                           v11 = vle32_v_f32m2(imgptr1 + in_j + dilation_w, vl),
-                           v12 = vle32_v_f32m2(imgptr1 + in_j + dilation_w*2, vl),
-                           v20 = vle32_v_f32m2(imgptr2 + in_j, vl),
-                           v21 = vle32_v_f32m2(imgptr2 + in_j + dilation_w, vl),
-                           v22 = vle32_v_f32m2(imgptr2 + in_j + dilation_w*2, vl);
-
-                    vfloat32m2_t vout0 = vfmul_vf_f32m2(v00, w00, vl);
-                    vfloat32m2_t vout1 = vfmul_vf_f32m2(v01, w01, vl);
-                    vfloat32m2_t vout2 = vfmul_vf_f32m2(v02, w02, vl);
-                    vout0 = vfadd_vf_f32m2(vout0, bias, vl);
-
-                    vout0 = vfmacc_vf_f32m2(vout0, w10, v10, vl);
-                    vout1 = vfmacc_vf_f32m2(vout1, w11, v11, vl);
-                    vout2 = vfmacc_vf_f32m2(vout2, w12, v12, vl);
-
-                    vout0 = vfmacc_vf_f32m2(vout0, w20, v20, vl);
-                    vout1 = vfmacc_vf_f32m2(vout1, w21, v21, vl);
-                    vout2 = vfmacc_vf_f32m2(vout2, w22, v22, vl);
-
-                    vout0 = vfadd_vv_f32m2(vfadd_vv_f32m2(vout0, vout1, vl), vout2, vl);
-                    if (relu)
-                    {
-                        vbool16_t m = vmfgt_vf_f32m2_b16(vout0, 0, vl);
-                        vout0 = vmerge_vvm_f32m2(m, vfmul_vf_f32m2(vout0, relu_coeff, vl), vout0, vl);
-                    }
-                    vse32_v_f32m2(outptr + out_j, vout0, vl);
-                }
-            else //stride_w == 2 && dilation_w == 1
-                for( ; out_j < outW1; out_j += vl, avl -= vl)
-                {
-                    vl = vsetvl_e32m2(avl);
-                    int in_j = out_j * stride_w - pad_l;
-                    vfloat32m2_t v00, v01, v02, v10, v11, v12, v20, v21, v22, unused;
-                    vfloat32m2_load_deinterleave(imgptr0 + in_j, v00, v01, vl);
-                    vfloat32m2_load_deinterleave(imgptr0 + in_j + 2, v02, unused, vl);
-                    vfloat32m2_load_deinterleave(imgptr1 + in_j, v10, v11, vl);
-                    vfloat32m2_load_deinterleave(imgptr1 + in_j + 2, v12, unused, vl);
-                    vfloat32m2_load_deinterleave(imgptr2 + in_j, v20, v21, vl);
-                    vfloat32m2_load_deinterleave(imgptr2 + in_j + 2, v22, unused, vl);
-
-                    vfloat32m2_t vout0 = vfmul_vf_f32m2(v00, w00, vl);
-                    vfloat32m2_t vout1 = vfmul_vf_f32m2(v01, w01, vl);
-                    vfloat32m2_t vout2 = vfmul_vf_f32m2(v02, w02, vl);
-                    vout0 = vfadd_vf_f32m2(vout0, bias, vl);
-
-                    vout0 = vfmacc_vf_f32m2(vout0, w10, v10, vl);
-                    vout1 = vfmacc_vf_f32m2(vout1, w11, v11, vl);
-                    vout2 = vfmacc_vf_f32m2(vout2, w12, v12, vl);
-
-                    vout0 = vfmacc_vf_f32m2(vout0, w20, v20, vl);
-                    vout1 = vfmacc_vf_f32m2(vout1, w21, v21, vl);
-                    vout2 = vfmacc_vf_f32m2(vout2, w22, v22, vl);
-
-                    vout0 = vfadd_vv_f32m2(vfadd_vv_f32m2(vout0, vout1, vl), vout2, vl);
-                    if (relu)
-                    {
-                        vbool16_t m = vmfgt_vf_f32m2_b16(vout0, 0, vl);
-                        vout0 = vmerge_vvm_f32m2(m, vfmul_vf_f32m2(vout0, relu_coeff, vl), vout0, vl);
-                    }
-                    vse32_v_f32m2(outptr + out_j, vout0, vl);
-                }
-        }
-
-        for (; out_j < outW1; out_j++)
-        {
-            int in_j = out_j * stride_w - pad_l;
-            out = imgptr0[in_j]*w00 + imgptr0[in_j + dilation_w]*w01 + imgptr0[in_j + dilation_w*2]*w02 +
-                  imgptr1[in_j]*w10 + imgptr1[in_j + dilation_w]*w11 + imgptr1[in_j + dilation_w*2]*w12 +
-                  imgptr2[in_j]*w20 + imgptr2[in_j + dilation_w]*w21 + imgptr2[in_j + dilation_w*2]*w22 + bias;
-            if (relu)
-                out = out > 0.f ? out : out*relu_coeff;
-            outptr[out_j] = out;
-        }
-
-        for (; out_j < outW; out_j++ )
-        {
-            int in_j0 = out_j * stride_w - pad_l, in_j1 = in_j0 + dilation_w, in_j2 = in_j0 + dilation_w*2;
-            float s0 = 1.f, s1 = 1.f, s2 = 1.f;
-            if (in_j0 >= width)
-            {
-                in_j0 = 0;
-                s0 = 0.f;
-            }
-            if (in_j1 >= width)
-            {
-                in_j1 = 0;
-                s1 = 0.f;
-            }
-            if (in_j2 >= width)
-            {
-                in_j2 = 0;
-                s2 = 0.f;
-            }
-            out = imgptr0[in_j0]*w00*s0 + imgptr0[in_j1]*w01*s1 + imgptr0[in_j2]*w02*s2 +
-                  imgptr1[in_j0]*w10*s0 + imgptr1[in_j1]*w11*s1 + imgptr1[in_j2]*w12*s2 +
-                  imgptr2[in_j0]*w20*s0 + imgptr2[in_j1]*w21*s1 + imgptr2[in_j2]*w22*s2 + bias;
-            if (relu)
-                out = out > 0.f ? out : out*relu_coeff;
-            outptr[out_j] = out;
-        }
-    }
-}
-
 #endif // CV_RVV
 
 #if !defined(CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY) && CV_LASX
 
-static inline void _v256_load_deinterleave(const float* ptr, __m256& a, __m256& b)
-{
-    __m256 t0 = (__m256)__lasx_xvld(ptr, 0);
-    __m256 t1 = (__m256)__lasx_xvld(ptr, 8*4);
-
-    __m256 lo = (__m256)__lasx_xvpermi_q(t0, t1, 2+0*16);
-    __m256 hi = (__m256)__lasx_xvpermi_q(t0, t1, 3+1*16);
-
-    a = (__m256)__lasx_xvpermi_w(hi, lo, 0x88);
-    b = (__m256)__lasx_xvpermi_w(hi, lo, 0xdd);
-}
-
-void fastDepthwiseConv( const float* wptr,
-                     int kernel_h, int kernel_w,
-                     int stride_h, int stride_w,
-                     int dilation_h, int dilation_w,
-                     int pad_t, int pad_l,
-                     const float* biasptr, const float* relu,
-                     const float* inptr_,
-                     int height, int width,
-                     float* outptr_,
-                     int out_d, int outH, int outW )
-{
-    const float w00_ = wptr[0], w01_ = wptr[1], w02_ = wptr[2],
-                w10 = wptr[3], w11 = wptr[4], w12 = wptr[5],
-                w20_ = wptr[6], w21_ = wptr[7], w22_ = wptr[8];
-    int outW1 = min(outW, (width - dilation_w*(kernel_w - 1) + pad_l)/stride_w);
-    float relu_coeff = relu ? relu[out_d] : 1.f, bias = biasptr[out_d];
-
-    for (int out_i = 0; out_i < outH; out_i++)
-    {
-        int in_i = out_i * stride_h - pad_t, out_j = 0;
-        const float* imgptr0 = inptr_ + in_i*width;
-        const float* imgptr1 = imgptr0 + dilation_h*width;
-        const float* imgptr2 = imgptr0 + (dilation_h*2)*width;
-        float out, w00 = w00_, w01 = w01_, w02 = w02_;
-        float w20 = w20_, w21 = w21_, w22 = w22_;
-        if (in_i < 0)
-        {
-            w00 = w01 = w02 = 0.f;
-            imgptr0 = imgptr1;
-        }
-        else if (in_i + dilation_h*(kernel_h-1) >= height)
-        {
-            w20 = w21 = w22 = 0.f;
-            imgptr2 = imgptr1;
-        }
-        float* outptr = outptr_ + out_i*outW;
-        if (pad_l > 0)
-        {
-            out = imgptr0[0]*w01 + imgptr0[dilation_w]*w02 +
-                  imgptr1[0]*w11 + imgptr1[dilation_w]*w12 +
-                  imgptr2[0]*w21 + imgptr2[dilation_w]*w22 + bias;
-            if (relu)
-                out = out > 0.f ? out : out*relu_coeff;
-            outptr[0] = out;
-            out_j = 1;
-        }
-
-        if (stride_w == 1 || (stride_w == 2 && dilation_w == 1))
-        {
-            const int VECSZ = 8;
-            __m256 vw00 = _v256_setall_ps(w00), vw01 = _v256_setall_ps(w01), vw02 = _v256_setall_ps(w02),
-                   vw10 = _v256_setall_ps(w10), vw11 = _v256_setall_ps(w11), vw12 = _v256_setall_ps(w12),
-                   vw20 = _v256_setall_ps(w20), vw21 = _v256_setall_ps(w21), vw22 = _v256_setall_ps(w22);
-            __m256 z = (__m256)__lasx_xvxor_v((__m256i)vw00, (__m256i)vw00),
-            vbias = _v256_setall_ps(bias), vrc = _v256_setall_ps(relu_coeff);
-
-            if( stride_w == 1 )
-                for( ; out_j < outW1; out_j += VECSZ )
-                {
-                    if (out_j + VECSZ > outW1 && out_j > pad_l)
-                        out_j = outW1 - VECSZ;
-                    int in_j = out_j * stride_w - pad_l;
-                    __m256 v00 = (__m256)__lasx_xvld(imgptr0 + in_j, 0),
-                           v01 = (__m256)__lasx_xvld(imgptr0 + in_j + dilation_w, 0),
-                           v02 = (__m256)__lasx_xvld(imgptr0 + in_j + dilation_w*2, 0),
-                           v10 = (__m256)__lasx_xvld(imgptr1 + in_j, 0),
-                           v11 = (__m256)__lasx_xvld(imgptr1 + in_j + dilation_w, 0),
-                           v12 = (__m256)__lasx_xvld(imgptr1 + in_j + dilation_w*2, 0),
-                           v20 = (__m256)__lasx_xvld(imgptr2 + in_j, 0),
-                           v21 = (__m256)__lasx_xvld(imgptr2 + in_j + dilation_w, 0),
-                           v22 = (__m256)__lasx_xvld(imgptr2 + in_j + dilation_w*2, 0);
-
-                    __m256 vout0 = __lasx_xvfmadd_s(v00, vw00, vbias);
-                    __m256 vout1 = __lasx_xvfmul_s(v01, vw01);
-                    __m256 vout2 = __lasx_xvfmul_s(v02, vw02);
-
-                    vout0 = __lasx_xvfmadd_s(v10, vw10, vout0);
-                    vout1 = __lasx_xvfmadd_s(v11, vw11, vout1);
-                    vout2 = __lasx_xvfmadd_s(v12, vw12, vout2);
-
-                    vout0 = __lasx_xvfmadd_s(v20, vw20, vout0);
-                    vout1 = __lasx_xvfmadd_s(v21, vw21, vout1);
-                    vout2 = __lasx_xvfmadd_s(v22, vw22, vout2);
-
-                    vout0 = __lasx_xvfadd_s(__lasx_xvfadd_s(vout0, vout1), vout2);
-                    if (relu)
-                    {
-                        __m256i m = __lasx_xvfcmp_clt_s(z, vout0);
-                        vout0 = (__m256)__lasx_xvbitsel_v((__m256i)__lasx_xvfmul_s(vout0, vrc), (__m256i)vout0, m);
-                    }
-                    __lasx_xvst(vout0, outptr + out_j, 0);
-                }
-            else
-                for( ; out_j < outW1; out_j += VECSZ )
-                {
-                    if (out_j + VECSZ > outW1 && out_j > pad_l)
-                        out_j = outW1 - VECSZ;
-                    int in_j = out_j * stride_w - pad_l;
-                    __m256 v00, v01, v02, v10, v11, v12, v20, v21, v22, unused;
-                    _v256_load_deinterleave(imgptr0 + in_j, v00, v01);
-                    _v256_load_deinterleave(imgptr0 + in_j + 2, v02, unused);
-                    _v256_load_deinterleave(imgptr1 + in_j, v10, v11);
-                    _v256_load_deinterleave(imgptr1 + in_j + 2, v12, unused);
-                    _v256_load_deinterleave(imgptr2 + in_j, v20, v21);
-                    _v256_load_deinterleave(imgptr2 + in_j + 2, v22, unused);
-
-                    __m256 vout0 = __lasx_xvfmadd_s(v00, vw00, vbias);
-                    __m256 vout1 = __lasx_xvfmul_s(v01, vw01);
-                    __m256 vout2 = __lasx_xvfmul_s(v02, vw02);
-
-                    vout0 = __lasx_xvfmadd_s(v10, vw10, vout0);
-                    vout1 = __lasx_xvfmadd_s(v11, vw11, vout1);
-                    vout2 = __lasx_xvfmadd_s(v12, vw12, vout2);
-
-                    vout0 = __lasx_xvfmadd_s(v20, vw20, vout0);
-                    vout1 = __lasx_xvfmadd_s(v21, vw21, vout1);
-                    vout2 = __lasx_xvfmadd_s(v22, vw22, vout2);
-
-                    vout0 = __lasx_xvfadd_s(__lasx_xvfadd_s(vout0, vout1), vout2);
-                    if (relu)
-                    {
-                        __m256i m = __lasx_xvfcmp_clt_s(z, vout0);
-                        vout0 = (__m256)__lasx_xvbitsel_v((__m256i)__lasx_xvfmul_s(vout0, vrc), (__m256i)vout0, m);
-                    }
-                    __lasx_xvst(vout0, outptr + out_j, 0);
-                }
-        }
-
-        for (; out_j < outW1; out_j++)
-        {
-            int in_j = out_j * stride_w - pad_l;
-            out = imgptr0[in_j]*w00 + imgptr0[in_j + dilation_w]*w01 + imgptr0[in_j + dilation_w*2]*w02 +
-                  imgptr1[in_j]*w10 + imgptr1[in_j + dilation_w]*w11 + imgptr1[in_j + dilation_w*2]*w12 +
-                  imgptr2[in_j]*w20 + imgptr2[in_j + dilation_w]*w21 + imgptr2[in_j + dilation_w*2]*w22 + bias;
-            if (relu)
-                out = out > 0.f ? out : out*relu_coeff;
-            outptr[out_j] = out;
-        }
-
-        for (; out_j < outW; out_j++ )
-        {
-            int in_j0 = out_j * stride_w - pad_l, in_j1 = in_j0 + dilation_w, in_j2 = in_j0 + dilation_w*2;
-            float s0 = 1.f, s1 = 1.f, s2 = 1.f;
-            if (in_j0 >= width)
-            {
-                in_j0 = 0;
-                s0 = 0.f;
-            }
-            if (in_j1 >= width)
-            {
-                in_j1 = 0;
-                s1 = 0.f;
-            }
-            if (in_j2 >= width)
-            {
-                in_j2 = 0;
-                s2 = 0.f;
-            }
-            out = imgptr0[in_j0]*w00*s0 + imgptr0[in_j1]*w01*s1 + imgptr0[in_j2]*w02*s2 +
-                  imgptr1[in_j0]*w10*s0 + imgptr1[in_j1]*w11*s1 + imgptr1[in_j2]*w12*s2 +
-                  imgptr2[in_j0]*w20*s0 + imgptr2[in_j1]*w21*s1 + imgptr2[in_j2]*w22*s2 + bias;
-            if (relu)
-                out = out > 0.f ? out : out*relu_coeff;
-            outptr[out_j] = out;
-        }
-    }
-}
-
 // dst = vec * weights^t + bias
 void fastGEMM1T( const float* vec, const float* weights,
                  size_t wstep, const float* bias,

modules/dnn/src/layers/lrn_layer.cpp

@@ -107,7 +107,6 @@ public:
         return backendId == DNN_BACKEND_OPENCV ||
                backendId == DNN_BACKEND_CUDA ||
                backendId == DNN_BACKEND_HALIDE ||
-               (backendId == DNN_BACKEND_VKCOM && haveVulkan() && (size % 2 == 1) && (type == CHANNEL_NRM)) ||
                backendId == DNN_BACKEND_CANN;
     }
 
@@ -362,15 +361,6 @@ public:
     }
 #endif
 
-    virtual Ptr<BackendNode> initVkCom(const std::vector<Ptr<BackendWrapper> > &inputs) CV_OVERRIDE
-    {
-#ifdef HAVE_VULKAN
-        std::shared_ptr<vkcom::OpBase> op(new vkcom::OpLRN(size / 2, bias, alpha, beta, normBySize));
-        return Ptr<BackendNode>(new VkComBackendNode(inputs, op));
-#endif
-        return Ptr<BackendNode>();
-    }
-
     virtual Ptr<BackendNode> initHalide(const std::vector<Ptr<BackendWrapper> > &inputs) CV_OVERRIDE
     {
 #ifdef HAVE_HALIDE
@@ -445,13 +435,14 @@ public:
     }
 
 #ifdef HAVE_CANN
-    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
+    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputs,
+                                      const std::vector<Ptr<BackendWrapper> > &outputs,
+                                      const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
     {
-        auto x = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
+        auto x = inputs[0].dynamicCast<CannBackendWrapper>();
 
         // create operator
-        std::string op_name = cv::format("lrn_%d", index);
-        auto op = std::make_shared<ge::op::LRN>(op_name);
+        auto op = std::make_shared<ge::op::LRN>(name);
 
         // set attributes
         op->set_attr_depth_radius(size);
@@ -465,7 +456,7 @@ public:
         // set inputs
         // set inputs : x
         auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
-        op->set_input_x_by_name(*op_x, "y");
+        op->set_input_x_by_name(*op_x, x->name.c_str());
         auto x_desc = x->getTensorDesc();
         op->update_input_desc_x(*x_desc);