vendor: OpenCV 5.0.0 snapshot at 40738fb16ceddb5fb3fea747585f7ce6abb0605b
This commit is contained in:
Gitea Mirror Bot
@@ -0,0 +1,332 @@
|
||||
// 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_RVV_HAL_CORE_HPP
|
||||
#define OPENCV_RVV_HAL_CORE_HPP
|
||||
|
||||
namespace cv { namespace rvv_hal { namespace core {
|
||||
|
||||
#if CV_HAL_RVV_1P0_ENABLED
|
||||
|
||||
/* ############ merge ############ */
|
||||
|
||||
int merge8u(const uchar** src, uchar* dst, int len, int cn);
|
||||
int merge16u(const ushort** src, ushort* dst, int len, int cn);
|
||||
int merge32s(const int** src, int* dst, int len, int cn);
|
||||
int merge64s(const int64** src, int64* dst, int len, int cn);
|
||||
|
||||
#undef cv_hal_merge8u
|
||||
#define cv_hal_merge8u cv::rvv_hal::core::merge8u
|
||||
#undef cv_hal_merge16u
|
||||
#define cv_hal_merge16u cv::rvv_hal::core::merge16u
|
||||
#undef cv_hal_merge32s
|
||||
#define cv_hal_merge32s cv::rvv_hal::core::merge32s
|
||||
#undef cv_hal_merge64s
|
||||
#define cv_hal_merge64s cv::rvv_hal::core::merge64s
|
||||
|
||||
/* ############ meanStdDev ############ */
|
||||
|
||||
int meanStdDev(const uchar* src_data, size_t src_step, int width, int height, int src_type,
|
||||
double* mean_val, double* stddev_val, uchar* mask, size_t mask_step);
|
||||
|
||||
#undef cv_hal_meanStdDev
|
||||
#define cv_hal_meanStdDev cv::rvv_hal::core::meanStdDev
|
||||
|
||||
/* ############ dft ############ */
|
||||
|
||||
int dft(const uchar* src, uchar* dst, int depth, int nf, int *factors, double scale,
|
||||
int* itab, void* wave, int tab_size, int n, bool isInverse, bool noPermute);
|
||||
|
||||
#undef cv_hal_dft
|
||||
#define cv_hal_dft cv::rvv_hal::core::dft
|
||||
|
||||
/* ############ norm ############ */
|
||||
|
||||
int norm(const uchar* src, size_t src_step, const uchar* mask, size_t mask_step,
|
||||
int width, int height, int type, int norm_type, double* result);
|
||||
|
||||
#undef cv_hal_norm
|
||||
#define cv_hal_norm cv::rvv_hal::core::norm
|
||||
|
||||
/* ############ normDiff ############ */
|
||||
|
||||
int normDiff(const uchar* src1, size_t src1_step, const uchar* src2, size_t src2_step,
|
||||
const uchar* mask, size_t mask_step, int width, int height, int type,
|
||||
int norm_type, double* result);
|
||||
|
||||
#undef cv_hal_normDiff
|
||||
#define cv_hal_normDiff cv::rvv_hal::core::normDiff
|
||||
|
||||
/* ############ normHamming ############ */
|
||||
|
||||
int normHamming8u(const uchar* a, int n, int cellSize, int* result);
|
||||
int normHammingDiff8u(const uchar* a, const uchar* b, int n, int cellSize, int* result);
|
||||
|
||||
#undef cv_hal_normHamming8u
|
||||
#define cv_hal_normHamming8u cv::rvv_hal::core::normHamming8u
|
||||
#undef cv_hal_normHammingDiff8u
|
||||
#define cv_hal_normHammingDiff8u cv::rvv_hal::core::normHammingDiff8u
|
||||
|
||||
/* ############ convertScale ############ */
|
||||
|
||||
int convertScale(const uchar* src, size_t src_step, uchar* dst, size_t dst_step,
|
||||
int width, int height, int sdepth, int ddepth, double alpha, double beta);
|
||||
|
||||
#undef cv_hal_convertScale
|
||||
#define cv_hal_convertScale cv::rvv_hal::core::convertScale
|
||||
|
||||
/* ############ minMaxIdx ############ */
|
||||
|
||||
int minMaxIdx(const uchar* src_data, size_t src_step, int width, int height, int depth,
|
||||
double* minVal, double* maxVal, int* minIdx, int* maxIdx, uchar* mask, size_t mask_step = 0);
|
||||
|
||||
#undef cv_hal_minMaxIdx
|
||||
#define cv_hal_minMaxIdx cv::rvv_hal::core::minMaxIdx
|
||||
#undef cv_hal_minMaxIdxMaskStep
|
||||
#define cv_hal_minMaxIdxMaskStep cv::rvv_hal::core::minMaxIdx
|
||||
|
||||
/* ############ fastAtan ############ */
|
||||
|
||||
int fast_atan_32(const float* y, const float* x, float* dst, size_t n, bool angle_in_deg);
|
||||
int fast_atan_64(const double* y, const double* x, double* dst, size_t n, bool angle_in_deg);
|
||||
|
||||
#undef cv_hal_fastAtan32f
|
||||
#define cv_hal_fastAtan32f cv::rvv_hal::core::fast_atan_32
|
||||
#undef cv_hal_fastAtan64f
|
||||
#define cv_hal_fastAtan64f cv::rvv_hal::core::fast_atan_64
|
||||
|
||||
/* ############ split ############ */
|
||||
|
||||
int split8u(const uchar* src, uchar** dst, int len, int cn);
|
||||
|
||||
#undef cv_hal_split8u
|
||||
#define cv_hal_split8u cv::rvv_hal::core::split8u
|
||||
|
||||
/* ############ sqrt ############ */
|
||||
|
||||
int sqrt32f(const float* src, float* dst, int _len);
|
||||
int sqrt64f(const double* src, double* dst, int _len);
|
||||
|
||||
#undef cv_hal_sqrt32f
|
||||
#define cv_hal_sqrt32f cv::rvv_hal::core::sqrt32f
|
||||
#undef cv_hal_sqrt64f
|
||||
#define cv_hal_sqrt64f cv::rvv_hal::core::sqrt64f
|
||||
|
||||
int invSqrt32f(const float* src, float* dst, int _len);
|
||||
int invSqrt64f(const double* src, double* dst, int _len);
|
||||
|
||||
#undef cv_hal_invSqrt32f
|
||||
#define cv_hal_invSqrt32f cv::rvv_hal::core::invSqrt32f
|
||||
#undef cv_hal_invSqrt64f
|
||||
#define cv_hal_invSqrt64f cv::rvv_hal::core::invSqrt64f
|
||||
|
||||
/* ############ magnitude ############ */
|
||||
|
||||
int magnitude32f(const float *x, const float *y, float *dst, int len);
|
||||
int magnitude64f(const double *x, const double *y, double *dst, int len);
|
||||
|
||||
#undef cv_hal_magnitude32f
|
||||
#define cv_hal_magnitude32f cv::rvv_hal::core::magnitude32f
|
||||
#undef cv_hal_magnitude64f
|
||||
#define cv_hal_magnitude64f cv::rvv_hal::core::magnitude64f
|
||||
|
||||
/* ############ cartToPolar ############ */
|
||||
|
||||
int cartToPolar32f(const float* x, const float* y, float* mag, float* angle, int len, bool angleInDegrees);
|
||||
int cartToPolar64f(const double* x, const double* y, double* mag, double* angle, int len, bool angleInDegrees);
|
||||
|
||||
#undef cv_hal_cartToPolar32f
|
||||
#define cv_hal_cartToPolar32f cv::rvv_hal::core::cartToPolar32f
|
||||
#undef cv_hal_cartToPolar64f
|
||||
#define cv_hal_cartToPolar64f cv::rvv_hal::core::cartToPolar64f
|
||||
|
||||
/* ############ polarToCart ############ */
|
||||
|
||||
int polarToCart32f(const float* mag, const float* angle, float* x, float* y, int len, bool angleInDegrees);
|
||||
int polarToCart64f(const double* mag, const double* angle, double* x, double* y, int len, bool angleInDegrees);
|
||||
|
||||
#undef cv_hal_polarToCart32f
|
||||
#define cv_hal_polarToCart32f cv::rvv_hal::core::polarToCart32f
|
||||
#undef cv_hal_polarToCart64f
|
||||
#define cv_hal_polarToCart64f cv::rvv_hal::core::polarToCart64f
|
||||
|
||||
/* ############ polarToCart ############ */
|
||||
|
||||
int flip(int src_type, const uchar* src_data, size_t src_step, int src_width, int src_height,
|
||||
uchar* dst_data, size_t dst_step, int flip_mode);
|
||||
|
||||
#undef cv_hal_flip
|
||||
#define cv_hal_flip cv::rvv_hal::core::flip
|
||||
|
||||
/* ############ lut ############ */
|
||||
|
||||
int lut(const uchar* src_data, size_t src_step, size_t src_type,
|
||||
const uchar* lut_data, size_t lut_channel_size, size_t lut_channels,
|
||||
uchar* dst_data, size_t dst_step, int width, int height);
|
||||
|
||||
#undef cv_hal_lut
|
||||
#define cv_hal_lut cv::rvv_hal::core::lut
|
||||
|
||||
/* ############ exp ############ */
|
||||
|
||||
int exp32f(const float* src, float* dst, int _len);
|
||||
int exp64f(const double* src, double* dst, int _len);
|
||||
|
||||
#undef cv_hal_exp32f
|
||||
#define cv_hal_exp32f cv::rvv_hal::core::exp32f
|
||||
#undef cv_hal_exp64f
|
||||
#define cv_hal_exp64f cv::rvv_hal::core::exp64f
|
||||
|
||||
/* ############ log ############ */
|
||||
|
||||
int log32f(const float* src, float* dst, int _len);
|
||||
int log64f(const double* src, double* dst, int _len);
|
||||
|
||||
#undef cv_hal_log32f
|
||||
#define cv_hal_log32f cv::rvv_hal::core::log32f
|
||||
#undef cv_hal_log64f
|
||||
#define cv_hal_log64f cv::rvv_hal::core::log64f
|
||||
|
||||
/* ############ lu ############ */
|
||||
|
||||
int LU32f(float* src1, size_t src1_step, int m, float* src2, size_t src2_step, int n, int* info);
|
||||
int LU64f(double* src1, size_t src1_step, int m, double* src2, size_t src2_step, int n, int* info);
|
||||
|
||||
#undef cv_hal_LU32f
|
||||
#define cv_hal_LU32f cv::rvv_hal::core::LU32f
|
||||
#undef cv_hal_LU64f
|
||||
#define cv_hal_LU64f cv::rvv_hal::core::LU64f
|
||||
|
||||
/* ############ cholesky ############ */
|
||||
|
||||
int Cholesky32f(float* src1, size_t src1_step, int m, float* src2, size_t src2_step, int n, bool* info);
|
||||
int Cholesky64f(double* src1, size_t src1_step, int m, double* src2, size_t src2_step, int n, bool* info);
|
||||
|
||||
#undef cv_hal_Cholesky32f
|
||||
#define cv_hal_Cholesky32f cv::rvv_hal::core::Cholesky32f
|
||||
#undef cv_hal_Cholesky64f
|
||||
#define cv_hal_Cholesky64f cv::rvv_hal::core::Cholesky64f
|
||||
|
||||
/* ############ qr ############ */
|
||||
|
||||
int QR32f(float* src1, size_t src1_step, int m, int n, int k, float* src2, size_t src2_step, float* dst, int* info);
|
||||
int QR64f(double* src1, size_t src1_step, int m, int n, int k, double* src2, size_t src2_step, double* dst, int* info);
|
||||
|
||||
#undef cv_hal_QR32f
|
||||
#define cv_hal_QR32f cv::rvv_hal::core::QR32f
|
||||
#undef cv_hal_QR64f
|
||||
#define cv_hal_QR64f cv::rvv_hal::core::QR64f
|
||||
|
||||
/* ############ SVD ############ */
|
||||
|
||||
int SVD32f(float* src, size_t src_step, float* w, float* u, size_t u_step, float* vt, size_t vt_step, int m, int n, int flags);
|
||||
int SVD64f(double* src, size_t src_step, double* w, double* u, size_t u_step, double* vt, size_t vt_step, int m, int n, int flags);
|
||||
|
||||
#undef cv_hal_SVD32f
|
||||
#define cv_hal_SVD32f cv::rvv_hal::core::SVD32f
|
||||
#undef cv_hal_SVD64f
|
||||
#define cv_hal_SVD64f cv::rvv_hal::core::SVD64f
|
||||
|
||||
/* ############ copyToMasked ############ */
|
||||
|
||||
int copyToMasked(const uchar *src_data, size_t src_step, uchar *dst_data, size_t dst_step, int width, int height,
|
||||
int type, const uchar *mask_data, size_t mask_step, int mask_type);
|
||||
|
||||
#undef cv_hal_copyToMasked
|
||||
#define cv_hal_copyToMasked cv::rvv_hal::core::copyToMasked
|
||||
|
||||
/* ############ div, recip ############ */
|
||||
|
||||
int div8u(const uchar *src1_data, size_t src1_step, const uchar *src2_data, size_t src2_step, uchar *dst_data, size_t dst_step, int width, int height, double scale);
|
||||
int div8s(const schar *src1_data, size_t src1_step, const schar *src2_data, size_t src2_step, schar *dst_data, size_t dst_step, int width, int height, double scale);
|
||||
int div16u(const ushort *src1_data, size_t src1_step, const ushort *src2_data, size_t src2_step, ushort *dst_data, size_t dst_step, int width, int height, double scale);
|
||||
int div16s(const short *src1_data, size_t src1_step, const short *src2_data, size_t src2_step, short *dst_data, size_t dst_step, int width, int height, double scale);
|
||||
int div32s(const int *src1_data, size_t src1_step, const int *src2_data, size_t src2_step, int *dst_data, size_t dst_step, int width, int height, double scale);
|
||||
int div32f(const float *src1_data, size_t src1_step, const float *src2_data, size_t src2_step, float *dst_data, size_t dst_step, int width, int height, double scale);
|
||||
// int div64f(const double *src1_data, size_t src1_step, const double *src2_data, size_t src2_step, double *dst_data, size_t dst_step, int width, int height, double scale);
|
||||
|
||||
#undef cv_hal_div8u
|
||||
#define cv_hal_div8u cv::rvv_hal::core::div8u
|
||||
#undef cv_hal_div8s
|
||||
#define cv_hal_div8s cv::rvv_hal::core::div8s
|
||||
#undef cv_hal_div16u
|
||||
#define cv_hal_div16u cv::rvv_hal::core::div16u
|
||||
#undef cv_hal_div16s
|
||||
#define cv_hal_div16s cv::rvv_hal::core::div16s
|
||||
#undef cv_hal_div32s
|
||||
#define cv_hal_div32s cv::rvv_hal::core::div32s
|
||||
#undef cv_hal_div32f
|
||||
#define cv_hal_div32f cv::rvv_hal::core::div32f
|
||||
// #undef cv_hal_div64f
|
||||
// #define cv_hal_div64f cv::rvv_hal::core::div64f
|
||||
|
||||
int recip8u(const uchar *src_data, size_t src_step, uchar *dst_data, size_t dst_step, int width, int height, double scale);
|
||||
int recip8s(const schar *src_data, size_t src_step, schar *dst_data, size_t dst_step, int width, int height, double scale);
|
||||
int recip16u(const ushort *src_data, size_t src_step, ushort *dst_data, size_t dst_step, int width, int height, double scale);
|
||||
int recip16s(const short *src_data, size_t src_step, short *dst_data, size_t dst_step, int width, int height, double scale);
|
||||
int recip32s(const int *src_data, size_t src_step, int *dst_data, size_t dst_step, int width, int height, double scale);
|
||||
int recip32f(const float *src_data, size_t src_step, float *dst_data, size_t dst_step, int width, int height, double scale);
|
||||
// int recip64f(const double *src_data, size_t src_step, double *dst_data, size_t dst_step, int width, int height, double scale);
|
||||
|
||||
#undef cv_hal_recip8u
|
||||
#define cv_hal_recip8u cv::rvv_hal::core::recip8u
|
||||
#undef cv_hal_recip8s
|
||||
#define cv_hal_recip8s cv::rvv_hal::core::recip8s
|
||||
#undef cv_hal_recip16u
|
||||
#define cv_hal_recip16u cv::rvv_hal::core::recip16u
|
||||
#undef cv_hal_recip16s
|
||||
#define cv_hal_recip16s cv::rvv_hal::core::recip16s
|
||||
#undef cv_hal_recip32s
|
||||
#define cv_hal_recip32s cv::rvv_hal::core::recip32s
|
||||
#undef cv_hal_recip32f
|
||||
#define cv_hal_recip32f cv::rvv_hal::core::recip32f
|
||||
// #undef cv_hal_recip64f
|
||||
// #define cv_hal_recip64f cv::rvv_hal::core::recip64f
|
||||
|
||||
/* ############ dotProduct ############ */
|
||||
|
||||
int dotprod(const uchar *a_data, size_t a_step, const uchar *b_data, size_t b_step,
|
||||
int width, int height, int type, double *dot_val);
|
||||
|
||||
#undef cv_hal_dotProduct
|
||||
#define cv_hal_dotProduct cv::rvv_hal::core::dotprod
|
||||
|
||||
/* ############ compare ############ */
|
||||
|
||||
int cmp8u(const uchar *src1_data, size_t src1_step, const uchar *src2_data, size_t src2_step, uchar *dst_data, size_t dst_step, int width, int height, int operation);
|
||||
int cmp8s(const schar *src1_data, size_t src1_step, const schar *src2_data, size_t src2_step, uchar *dst_data, size_t dst_step, int width, int height, int operation);
|
||||
int cmp16u(const ushort *src1_data, size_t src1_step, const ushort *src2_data, size_t src2_step, uchar *dst_data, size_t dst_step, int width, int height, int operation);
|
||||
int cmp16s(const short *src1_data, size_t src1_step, const short *src2_data, size_t src2_step, uchar *dst_data, size_t dst_step, int width, int height, int operation);
|
||||
int cmp32s(const int *src1_data, size_t src1_step, const int *src2_data, size_t src2_step, uchar *dst_data, size_t dst_step, int width, int height, int operation);
|
||||
int cmp32f(const float *src1_data, size_t src1_step, const float *src2_data, size_t src2_step, uchar *dst_data, size_t dst_step, int width, int height, int operation);
|
||||
// int cmp64f(const double *src1_data, size_t src1_step, const double *src2_data, size_t src2_step, uchar *dst_data, size_t dst_step, int width, int height, int operation);
|
||||
|
||||
#undef cv_hal_cmp8u
|
||||
#define cv_hal_cmp8u cv::rvv_hal::core::cmp8u
|
||||
#undef cv_hal_cmp8s
|
||||
#define cv_hal_cmp8s cv::rvv_hal::core::cmp8s
|
||||
#undef cv_hal_cmp16u
|
||||
#define cv_hal_cmp16u cv::rvv_hal::core::cmp16u
|
||||
#undef cv_hal_cmp16s
|
||||
#define cv_hal_cmp16s cv::rvv_hal::core::cmp16s
|
||||
#undef cv_hal_cmp32s
|
||||
#define cv_hal_cmp32s cv::rvv_hal::core::cmp32s
|
||||
#undef cv_hal_cmp32f
|
||||
#define cv_hal_cmp32f cv::rvv_hal::core::cmp32f
|
||||
// #undef cv_hal_cmp64f
|
||||
// #define cv_hal_cmp64f cv::rvv_hal::core::cmp64f
|
||||
|
||||
/* ############ transpose2d ############ */
|
||||
|
||||
int transpose2d(const uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step,
|
||||
int src_width, int src_height, int element_size);
|
||||
|
||||
#undef cv_hal_transpose2d
|
||||
#define cv_hal_transpose2d cv::rvv_hal::core::transpose2d
|
||||
|
||||
#endif // CV_HAL_RVV_1P0_ENABLED
|
||||
|
||||
}}} // cv::rvv_hal::core
|
||||
|
||||
#endif // OPENCV_RVV_HAL_CORE_HPP
|
||||
@@ -0,0 +1,26 @@
|
||||
// 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_RVV_HAL_FEATURES2D_HPP
|
||||
#define OPENCV_RVV_HAL_FEATURES2D_HPP
|
||||
|
||||
struct cvhalFilter2D;
|
||||
|
||||
namespace cv { namespace rvv_hal { namespace features2d {
|
||||
|
||||
#if CV_HAL_RVV_1P0_ENABLED
|
||||
|
||||
int FAST(const uchar* src_data, size_t src_step, int width, int height,
|
||||
void** keypoints_data, size_t* keypoints_count,
|
||||
int threshold, bool nonmax_suppression, int detector_type, void* (*realloc_func)(void*, size_t));
|
||||
|
||||
#undef cv_hal_FASTv2
|
||||
#define cv_hal_FASTv2 cv::rvv_hal::features2d::FAST
|
||||
|
||||
#endif // CV_HAL_RVV_1P0_ENABLED
|
||||
|
||||
|
||||
}}} // cv::rvv_hal::features2d
|
||||
|
||||
#endif // OPENCV_RVV_HAL_IMGPROC_HPP
|
||||
@@ -0,0 +1,299 @@
|
||||
// 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_RVV_HAL_IMGPROC_HPP
|
||||
#define OPENCV_RVV_HAL_IMGPROC_HPP
|
||||
|
||||
struct cvhalFilter2D;
|
||||
|
||||
namespace cv { namespace rvv_hal { namespace imgproc {
|
||||
|
||||
#if CV_HAL_RVV_1P0_ENABLED
|
||||
|
||||
/* ############ imageMoments ############ */
|
||||
|
||||
int imageMoments(const uchar* src_data, size_t src_step, int src_type,
|
||||
int width, int height, bool binary, double m[10]);
|
||||
|
||||
#undef cv_hal_imageMoments
|
||||
#define cv_hal_imageMoments cv::rvv_hal::imgproc::imageMoments
|
||||
|
||||
/* ############ filter ############ */
|
||||
|
||||
int filterInit(cvhalFilter2D** context, uchar* kernel_data, size_t kernel_step, int kernel_type, int kernel_width, int kernel_height, int /*max_width*/, int /*max_height*/, int src_type, int dst_type, int borderType, double delta, int anchor_x, int anchor_y, bool /*allowSubmatrix*/, bool /*allowInplace*/);
|
||||
int filter(cvhalFilter2D* context, uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step, int width, int height, int full_width, int full_height, int offset_x, int offset_y);
|
||||
int filterFree(cvhalFilter2D* context);
|
||||
|
||||
#undef cv_hal_filterInit
|
||||
#define cv_hal_filterInit cv::rvv_hal::imgproc::filterInit
|
||||
#undef cv_hal_filter
|
||||
#define cv_hal_filter cv::rvv_hal::imgproc::filter
|
||||
#undef cv_hal_filterFree
|
||||
#define cv_hal_filterFree cv::rvv_hal::imgproc::filterFree
|
||||
|
||||
/* ############ sepFilter ############ */
|
||||
|
||||
int sepFilterInit(cvhalFilter2D **context, int src_type, int dst_type, int kernel_type, uchar* kernelx_data, int kernelx_length, uchar* kernely_data, int kernely_length, int anchor_x, int anchor_y, double delta, int borderType);
|
||||
int sepFilter(cvhalFilter2D *context, uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step, int width, int height, int full_width, int full_height, int offset_x, int offset_y);
|
||||
int sepFilterFree(cvhalFilter2D* context);
|
||||
|
||||
#undef cv_hal_sepFilterInit
|
||||
#define cv_hal_sepFilterInit cv::rvv_hal::imgproc::sepFilterInit
|
||||
#undef cv_hal_sepFilter
|
||||
#define cv_hal_sepFilter cv::rvv_hal::imgproc::sepFilter
|
||||
#undef cv_hal_sepFilterFree
|
||||
#define cv_hal_sepFilterFree cv::rvv_hal::imgproc::sepFilterFree
|
||||
|
||||
/* ############ morph ############ */
|
||||
|
||||
int morphInit(cvhalFilter2D** context, int operation, int src_type, int dst_type, int /*max_width*/, int /*max_height*/, int kernel_type, uchar* kernel_data, size_t kernel_step, int kernel_width, int kernel_height, int anchor_x, int anchor_y, int borderType, const double borderValue[4], int iterations, bool /*allowSubmatrix*/, bool /*allowInplace*/);
|
||||
int morph(cvhalFilter2D* context, uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step, int width, int height, int src_full_width, int src_full_height, int src_roi_x, int src_roi_y, int /*dst_full_width*/, int /*dst_full_height*/, int /*dst_roi_x*/, int /*dst_roi_y*/);
|
||||
int morphFree(cvhalFilter2D* context);
|
||||
|
||||
#undef cv_hal_morphInit
|
||||
#undef cv_hal_morph
|
||||
#undef cv_hal_morphFree
|
||||
#define cv_hal_morphInit cv::rvv_hal::imgproc::morphInit
|
||||
#define cv_hal_morph cv::rvv_hal::imgproc::morph
|
||||
#define cv_hal_morphFree cv::rvv_hal::imgproc::morphFree
|
||||
|
||||
/* ############ gaussianBlur ############ */
|
||||
|
||||
int gaussianBlurBinomial(const uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step, int width, int height, int depth, int cn, size_t margin_left, size_t margin_top, size_t margin_right, size_t margin_bottom, size_t ksize, int border_type);
|
||||
|
||||
#undef cv_hal_gaussianBlurBinomial
|
||||
#define cv_hal_gaussianBlurBinomial cv::rvv_hal::imgproc::gaussianBlurBinomial
|
||||
|
||||
/* ############ medianBlur ############ */
|
||||
|
||||
int medianBlur(const uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step, int width, int height, int depth, int cn, int ksize);
|
||||
|
||||
#undef cv_hal_medianBlur
|
||||
#define cv_hal_medianBlur cv::rvv_hal::imgproc::medianBlur
|
||||
|
||||
/* ############ boxFilter ############ */
|
||||
|
||||
int boxFilter(const uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step, int width, int height, int src_depth, int dst_depth, int cn, int margin_left, int margin_top, int margin_right, int margin_bottom, size_t ksize_width, size_t ksize_height, int anchor_x, int anchor_y, bool normalize, int border_type);
|
||||
|
||||
#undef cv_hal_boxFilter
|
||||
#define cv_hal_boxFilter cv::rvv_hal::imgproc::boxFilter
|
||||
|
||||
/* ############ bilateralFilter ############ */
|
||||
|
||||
int bilateralFilter(const uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step,
|
||||
int width, int height, int depth, int cn, int d, double sigma_color,
|
||||
double sigma_space, int border_type);
|
||||
|
||||
#undef cv_hal_bilateralFilter
|
||||
#define cv_hal_bilateralFilter cv::rvv_hal::imgproc::bilateralFilter
|
||||
|
||||
/* ############ pyramid ############ */
|
||||
|
||||
int pyrDown(const uchar* src_data, size_t src_step, int src_width, int src_height, uchar* dst_data, size_t dst_step, int dst_width, int dst_height, int depth, int cn, int border_type);
|
||||
int pyrUp(const uchar* src_data, size_t src_step, int src_width, int src_height, uchar* dst_data, size_t dst_step, int dst_width, int dst_height, int depth, int cn, int border_type);
|
||||
|
||||
#undef cv_hal_pyrdown
|
||||
#define cv_hal_pyrdown cv::rvv_hal::imgproc::pyrDown
|
||||
#undef cv_hal_pyrup
|
||||
#define cv_hal_pyrup cv::rvv_hal::imgproc::pyrUp
|
||||
|
||||
/* ############ cvtColor ############ */
|
||||
|
||||
int cvtBGRtoBGR(const uchar * src_data, size_t src_step, uchar * dst_data, size_t dst_step, int width, int height, int depth, int scn, int dcn, bool swapBlue);
|
||||
int cvtGraytoBGR(const uchar * src_data, size_t src_step, uchar * dst_data, size_t dst_step, int width, int height, int depth, int dcn);
|
||||
int cvtBGRtoGray(const uchar * src_data, size_t src_step, uchar * dst_data, size_t dst_step, int width, int height, int depth, int scn, bool swapBlue);
|
||||
int cvtBGR5x5toBGR(const uchar * src_data, size_t src_step, uchar * dst_data, size_t dst_step, int width, int height, int dcn, bool swapBlue, int greenBits);
|
||||
int cvtBGRtoBGR5x5(const uchar * src_data, size_t src_step, uchar * dst_data, size_t dst_step, int width, int height, int scn, bool swapBlue, int greenBits);
|
||||
int cvtBGR5x5toGray(const uchar * src_data, size_t src_step, uchar * dst_data, size_t dst_step, int width, int height, int greenBits);
|
||||
int cvtGraytoBGR5x5(const uchar * src_data, size_t src_step, uchar * dst_data, size_t dst_step, int width, int height, int greenBits);
|
||||
int cvtYUVtoBGR(const uchar * src_data, size_t src_step, uchar * dst_data, size_t dst_step, int width, int height, int depth, int dcn, bool swapBlue, bool isCbCr);
|
||||
int cvtBGRtoYUV(const uchar * src_data, size_t src_step, uchar * dst_data, size_t dst_step, int width, int height, int depth, int scn, bool swapBlue, bool isCbCr);
|
||||
int cvtOnePlaneYUVtoBGR(const uchar * src_data, size_t src_step, uchar * dst_data, size_t dst_step, int dst_width, int dst_height, int dcn, bool swapBlue, int uIdx, int yIdx);
|
||||
int cvtTwoPlaneYUVtoBGR(const uchar * src_data, size_t src_step, uchar * dst_data, size_t dst_step, int dst_width, int dst_height, int dcn, bool swapBlue, int uIdx);
|
||||
int cvtThreePlaneYUVtoBGR(const uchar * src_data, size_t src_step, uchar * dst_data, size_t dst_step, int dst_width, int dst_height, int dcn, bool swapBlue, int uIdx);
|
||||
int cvtOnePlaneBGRtoYUV(const uchar * src_data, size_t src_step, uchar * dst_data, size_t dst_step, int width, int height, int scn, bool swapBlue, int uIdx, int yIdx);
|
||||
int cvtBGRtoTwoPlaneYUV(const uchar * src_data, size_t src_step, uchar * y_data, size_t y_step, uchar * uv_data, size_t uv_step, int width, int height, int scn, bool swapBlue, int uIdx);
|
||||
int cvtBGRtoThreePlaneYUV(const uchar * src_data, size_t src_step, uchar * dst_data, size_t dst_step, int width, int height, int scn, bool swapBlue, int uIdx);
|
||||
int cvtHSVtoBGR(const uchar * src_data, size_t src_step, uchar * dst_data, size_t dst_step, int width, int height, int depth, int dcn, bool swapBlue, bool isFullRange, bool isHSV);
|
||||
int cvtBGRtoHSV(const uchar * src_data, size_t src_step, uchar * dst_data, size_t dst_step, int width, int height, int depth, int scn, bool swapBlue, bool isFullRange, bool isHSV);
|
||||
int cvtXYZtoBGR(const uchar * src_data, size_t src_step, uchar * dst_data, size_t dst_step, int width, int height, int depth, int dcn, bool swapBlue);
|
||||
int cvtBGRtoXYZ(const uchar * src_data, size_t src_step, uchar * dst_data, size_t dst_step, int width, int height, int depth, int scn, bool swapBlue);
|
||||
int cvtLabtoBGR(const uchar * src_data, size_t src_step, uchar * dst_data, size_t dst_step, int width, int height, int depth, int dcn, bool swapBlue, bool isLab, bool srgb);
|
||||
int cvtBGRtoLab(const uchar * src_data, size_t src_step, uchar * dst_data, size_t dst_step, int width, int height, int depth, int scn, bool swapBlue, bool isLab, bool srgb);
|
||||
|
||||
#undef cv_hal_cvtBGRtoBGR
|
||||
#define cv_hal_cvtBGRtoBGR cv::rvv_hal::imgproc::cvtBGRtoBGR
|
||||
#undef cv_hal_cvtGraytoBGR
|
||||
#define cv_hal_cvtGraytoBGR cv::rvv_hal::imgproc::cvtGraytoBGR
|
||||
#undef cv_hal_cvtBGRtoGray
|
||||
#define cv_hal_cvtBGRtoGray cv::rvv_hal::imgproc::cvtBGRtoGray
|
||||
#undef cv_hal_cvtBGR5x5toBGR
|
||||
#define cv_hal_cvtBGR5x5toBGR cv::rvv_hal::imgproc::cvtBGR5x5toBGR
|
||||
#undef cv_hal_cvtBGRtoBGR5x5
|
||||
#define cv_hal_cvtBGRtoBGR5x5 cv::rvv_hal::imgproc::cvtBGRtoBGR5x5
|
||||
#undef cv_hal_cvtBGR5x5toGray
|
||||
#define cv_hal_cvtBGR5x5toGray cv::rvv_hal::imgproc::cvtBGR5x5toGray
|
||||
#undef cv_hal_cvtGraytoBGR5x5
|
||||
#define cv_hal_cvtGraytoBGR5x5 cv::rvv_hal::imgproc::cvtGraytoBGR5x5
|
||||
#undef cv_hal_cvtYUVtoBGR
|
||||
#define cv_hal_cvtYUVtoBGR cv::rvv_hal::imgproc::cvtYUVtoBGR
|
||||
#undef cv_hal_cvtBGRtoYUV
|
||||
#define cv_hal_cvtBGRtoYUV cv::rvv_hal::imgproc::cvtBGRtoYUV
|
||||
#undef cv_hal_cvtOnePlaneYUVtoBGR
|
||||
#define cv_hal_cvtOnePlaneYUVtoBGR cv::rvv_hal::imgproc::cvtOnePlaneYUVtoBGR
|
||||
#undef cv_hal_cvtTwoPlaneYUVtoBGR
|
||||
#define cv_hal_cvtTwoPlaneYUVtoBGR cv::rvv_hal::imgproc::cvtTwoPlaneYUVtoBGR
|
||||
#undef cv_hal_cvtThreePlaneYUVtoBGR
|
||||
#define cv_hal_cvtThreePlaneYUVtoBGR cv::rvv_hal::imgproc::cvtThreePlaneYUVtoBGR
|
||||
#undef cv_hal_cvtOnePlaneBGRtoYUV
|
||||
#define cv_hal_cvtOnePlaneBGRtoYUV cv::rvv_hal::imgproc::cvtOnePlaneBGRtoYUV
|
||||
#undef cv_hal_cvtBGRtoTwoPlaneYUV
|
||||
#define cv_hal_cvtBGRtoTwoPlaneYUV cv::rvv_hal::imgproc::cvtBGRtoTwoPlaneYUV
|
||||
#undef cv_hal_cvtBGRtoThreePlaneYUV
|
||||
#define cv_hal_cvtBGRtoThreePlaneYUV cv::rvv_hal::imgproc::cvtBGRtoThreePlaneYUV
|
||||
#undef cv_hal_cvtHSVtoBGR
|
||||
#define cv_hal_cvtHSVtoBGR cv::rvv_hal::imgproc::cvtHSVtoBGR
|
||||
#undef cv_hal_cvtBGRtoHSV
|
||||
#define cv_hal_cvtBGRtoHSV cv::rvv_hal::imgproc::cvtBGRtoHSV
|
||||
#undef cv_hal_cvtXYZtoBGR
|
||||
#define cv_hal_cvtXYZtoBGR cv::rvv_hal::imgproc::cvtXYZtoBGR
|
||||
#undef cv_hal_cvtBGRtoXYZ
|
||||
#define cv_hal_cvtBGRtoXYZ cv::rvv_hal::imgproc::cvtBGRtoXYZ
|
||||
#undef cv_hal_cvtLabtoBGR
|
||||
#define cv_hal_cvtLabtoBGR cv::rvv_hal::imgproc::cvtLabtoBGR
|
||||
#undef cv_hal_cvtBGRtoLab
|
||||
#define cv_hal_cvtBGRtoLab cv::rvv_hal::imgproc::cvtBGRtoLab
|
||||
|
||||
/* ############ warp ############ */
|
||||
|
||||
int remap32f(int src_type, const uchar *src_data, size_t src_step, int src_width, int src_height,
|
||||
uchar *dst_data, size_t dst_step, int dst_width, int dst_height,
|
||||
float* mapx, size_t mapx_step, float* mapy, size_t mapy_step,
|
||||
int interpolation, int border_type, const double border_value[4]);
|
||||
int remap32fc2(int src_type, const uchar *src_data, size_t src_step, int src_width, int src_height,
|
||||
uchar *dst_data, size_t dst_step, int dst_width, int dst_height,
|
||||
float* map, size_t map_step, int interpolation, int border_type, const double border_value[4]);
|
||||
int remap16s(int src_type, const uchar *src_data, size_t src_step, int src_width, int src_height,
|
||||
uchar *dst_data, size_t dst_step, int dst_width, int dst_height,
|
||||
short* mapx, size_t mapx_step, ushort* mapy, size_t mapy_step,
|
||||
int interpolation, int border_type, const double border_value[4]);
|
||||
|
||||
// BUG: https://github.com/opencv/opencv/issues/27279
|
||||
// #undef cv_hal_remap32f
|
||||
// #define cv_hal_remap32f cv::cv_hal_rvv::imgproc::remap32f
|
||||
// #undef cv_hal_remap32fc2
|
||||
// #define cv_hal_remap32fc2 cv::cv_hal_rvv::imgproc::remap32fc2
|
||||
// #undef cv_hal_remap16s
|
||||
// #define cv_hal_remap16s cv::cv_hal_rvv::imgproc::remap16s
|
||||
|
||||
int warpAffine(int src_type, const uchar *src_data, size_t src_step, int src_width, int src_height, uchar *dst_data, size_t dst_step, int dst_width, int dst_height, const double M[6], int interpolation, int borderType, const double borderValue[4]);
|
||||
int warpPerspective(int src_type, const uchar *src_data, size_t src_step, int src_width, int src_height, uchar *dst_data, size_t dst_step, int dst_width, int dst_height, const double M[9], int interpolation, int borderType, const double borderValue[4]);
|
||||
|
||||
// BUG: https://github.com/opencv/opencv/issues/27280
|
||||
//#undef cv_hal_warpAffine
|
||||
//#define cv_hal_warpAffine cv::cv_hal_rvv::imgproc::warpAffine
|
||||
//#undef cv_hal_warpPerspective
|
||||
//#define cv_hal_warpPerspective cv::cv_hal_rvv::imgproc::warpPerspective
|
||||
|
||||
/* ############ threshold ############ */
|
||||
|
||||
int threshold(const uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step, int width, int height, int depth, int cn, double thresh, double maxValue, int thresholdType);
|
||||
int threshold_otsu(const uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step, int width, int height, int depth, double maxValue, int thresholdType, double* thresh);
|
||||
int adaptiveThreshold(const uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step, int width, int height, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C);
|
||||
|
||||
// disabled since UI is fast enough, only called in threshold_otsu
|
||||
// #undef cv_hal_threshold
|
||||
// #define cv_hal_threshold cv::rvv_hal::imgproc::threshold
|
||||
#undef cv_hal_threshold_otsu
|
||||
#define cv_hal_threshold_otsu cv::rvv_hal::imgproc::threshold_otsu
|
||||
#undef cv_hal_adaptiveThreshold
|
||||
#define cv_hal_adaptiveThreshold cv::rvv_hal::imgproc::adaptiveThreshold
|
||||
|
||||
/* ############ histogram ############ */
|
||||
|
||||
int equalize_hist(const uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step, int width, int height);
|
||||
|
||||
#undef cv_hal_equalize_hist
|
||||
#define cv_hal_equalize_hist cv::rvv_hal::imgproc::equalize_hist
|
||||
|
||||
int calc_hist(const uchar* src_data, size_t src_step, int src_type, int src_width, int src_height, float* hist_data, int hist_size, const float** ranges, bool uniform, bool accumulate);
|
||||
|
||||
#undef cv_hal_calcHist
|
||||
#define cv_hal_calcHist cv::rvv_hal::imgproc::calc_hist
|
||||
|
||||
/* ############ resize ############ */
|
||||
|
||||
int resize(int src_type, const uchar *src_data, size_t src_step, int src_width, int src_height, uchar *dst_data, size_t dst_step, int dst_width, int dst_height, double inv_scale_x, double inv_scale_y, int interpolation);
|
||||
|
||||
#undef cv_hal_resize
|
||||
#define cv_hal_resize cv::rvv_hal::imgproc::resize
|
||||
|
||||
/* ############ resize ############ */
|
||||
|
||||
int integral(int depth, int sdepth, int sqdepth,
|
||||
const uchar* src_data, size_t src_step,
|
||||
uchar* sum_data, size_t sum_step,
|
||||
uchar* sqsum_data, size_t sqsum_step,
|
||||
uchar* tilted_data, [[maybe_unused]] size_t tilted_step,
|
||||
int width, int height, int cn);
|
||||
|
||||
#undef cv_hal_integral
|
||||
#define cv_hal_integral cv::rvv_hal::imgproc::integral
|
||||
|
||||
/* ############ laplacian ############ */
|
||||
int laplacian(const uint8_t* src_data, size_t src_step,
|
||||
uint8_t* dst_data, size_t dst_step,
|
||||
int width, int height,
|
||||
int src_depth, int dst_depth, int cn,
|
||||
int ksize, int border_type, uint8_t border_value);
|
||||
|
||||
#undef cv_hal_laplacian
|
||||
#define cv_hal_laplacian cv::rvv_hal::imgproc::laplacian
|
||||
|
||||
/* ############ scharr ############ */
|
||||
int scharr(const uint8_t *src_data, size_t src_step, uint8_t *dst_data, size_t dst_step, int width, int height, int src_depth, int dst_depth, int cn, int margin_left, int margin_top, int margin_right, int margin_bottom, int dx, int dy, double scale, double delta, int border_type);
|
||||
|
||||
#undef cv_hal_scharr
|
||||
#define cv_hal_scharr cv::rvv_hal::imgproc::scharr
|
||||
|
||||
/* ############ sobel ############ */
|
||||
|
||||
int sobel(const uint8_t *src_data, size_t src_step, uint8_t *dst_data, size_t dst_step, int width, int height, int src_depth, int dst_depth, int cn, int margin_left, int margin_top, int margin_right, int margin_bottom, int dx, int dy, int ksize, double scale, double delta, int border_type);
|
||||
|
||||
#undef cv_hal_sobel
|
||||
#define cv_hal_sobel cv::rvv_hal::imgproc::sobel
|
||||
|
||||
/* ############ canny ############ */
|
||||
int canny(const uint8_t *src_data, size_t src_step,
|
||||
uint8_t *dst_data, size_t dst_step,
|
||||
int width, int height, int cn,
|
||||
double low_thresh, double high_thresh,
|
||||
int ksize, bool L2gradient);
|
||||
|
||||
#undef cv_hal_canny
|
||||
#define cv_hal_canny cv::rvv_hal::imgproc::canny
|
||||
|
||||
/* ############ spatialGradient ############ */
|
||||
int spatialGradient(const uint8_t* src_data, size_t src_step,
|
||||
int16_t* dx_data, size_t dx_step,
|
||||
int16_t* dy_data, size_t dy_step,
|
||||
int width, int height,
|
||||
int ksize, int border_type);
|
||||
|
||||
#undef cv_hal_spatialGradient
|
||||
#define cv_hal_spatialGradient cv::rvv_hal::imgproc::spatialGradient
|
||||
|
||||
#endif // CV_HAL_RVV_1P0_ENABLED
|
||||
|
||||
#if CV_HAL_RVV_071_ENABLED
|
||||
|
||||
int cvtBGRtoBGR(const uchar * src_data, size_t src_step, uchar * dst_data, size_t dst_step, int width, int height, int depth, int scn, int dcn, bool swapBlue);
|
||||
#undef cv_hal_cvtBGRtoBGR
|
||||
#define cv_hal_cvtBGRtoBGR cv::rvv_hal::imgproc::cvtBGRtoBGR
|
||||
|
||||
#endif // CV_HAL_RVV_071_ENABLED
|
||||
|
||||
}}} // cv::rvv_hal::imgproc
|
||||
|
||||
#endif // OPENCV_RVV_HAL_IMGPROC_HPP
|
||||
@@ -0,0 +1,878 @@
|
||||
// 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.
|
||||
|
||||
// Copyright (C) 2025, Institute of Software, Chinese Academy of Sciences.
|
||||
|
||||
#ifndef OPENCV_RVV_HAL_TYPES_HPP
|
||||
#define OPENCV_RVV_HAL_TYPES_HPP
|
||||
|
||||
#include <riscv_vector.h>
|
||||
#include <type_traits>
|
||||
|
||||
namespace cv { namespace rvv_hal {
|
||||
|
||||
#if CV_HAL_RVV_1P0_ENABLED
|
||||
|
||||
enum RVV_LMUL
|
||||
{
|
||||
LMUL_1 = 1,
|
||||
LMUL_2 = 2,
|
||||
LMUL_4 = 4,
|
||||
LMUL_8 = 8,
|
||||
LMUL_f2,
|
||||
LMUL_f4,
|
||||
LMUL_f8,
|
||||
};
|
||||
|
||||
template <typename T, RVV_LMUL LMUL>
|
||||
struct RVV;
|
||||
|
||||
// -------------------------------Supported types--------------------------------
|
||||
|
||||
using RVV_U8M1 = struct RVV<uint8_t, LMUL_1>;
|
||||
using RVV_U8M2 = struct RVV<uint8_t, LMUL_2>;
|
||||
using RVV_U8M4 = struct RVV<uint8_t, LMUL_4>;
|
||||
using RVV_U8M8 = struct RVV<uint8_t, LMUL_8>;
|
||||
using RVV_U8MF2 = struct RVV<uint8_t, LMUL_f2>;
|
||||
using RVV_U8MF4 = struct RVV<uint8_t, LMUL_f4>;
|
||||
using RVV_U8MF8 = struct RVV<uint8_t, LMUL_f8>;
|
||||
|
||||
using RVV_I8M1 = struct RVV<int8_t, LMUL_1>;
|
||||
using RVV_I8M2 = struct RVV<int8_t, LMUL_2>;
|
||||
using RVV_I8M4 = struct RVV<int8_t, LMUL_4>;
|
||||
using RVV_I8M8 = struct RVV<int8_t, LMUL_8>;
|
||||
using RVV_I8MF2 = struct RVV<int8_t, LMUL_f2>;
|
||||
using RVV_I8MF4 = struct RVV<int8_t, LMUL_f4>;
|
||||
using RVV_I8MF8 = struct RVV<int8_t, LMUL_f8>;
|
||||
|
||||
using RVV_U16M1 = struct RVV<uint16_t, LMUL_1>;
|
||||
using RVV_U16M2 = struct RVV<uint16_t, LMUL_2>;
|
||||
using RVV_U16M4 = struct RVV<uint16_t, LMUL_4>;
|
||||
using RVV_U16M8 = struct RVV<uint16_t, LMUL_8>;
|
||||
using RVV_U16MF2 = struct RVV<uint16_t, LMUL_f2>;
|
||||
using RVV_U16MF4 = struct RVV<uint16_t, LMUL_f4>;
|
||||
|
||||
using RVV_I16M1 = struct RVV<int16_t, LMUL_1>;
|
||||
using RVV_I16M2 = struct RVV<int16_t, LMUL_2>;
|
||||
using RVV_I16M4 = struct RVV<int16_t, LMUL_4>;
|
||||
using RVV_I16M8 = struct RVV<int16_t, LMUL_8>;
|
||||
using RVV_I16MF2 = struct RVV<int16_t, LMUL_f2>;
|
||||
using RVV_I16MF4 = struct RVV<int16_t, LMUL_f4>;
|
||||
|
||||
using RVV_U32M1 = struct RVV<uint32_t, LMUL_1>;
|
||||
using RVV_U32M2 = struct RVV<uint32_t, LMUL_2>;
|
||||
using RVV_U32M4 = struct RVV<uint32_t, LMUL_4>;
|
||||
using RVV_U32M8 = struct RVV<uint32_t, LMUL_8>;
|
||||
using RVV_U32MF2 = struct RVV<uint32_t, LMUL_f2>;
|
||||
|
||||
using RVV_I32M1 = struct RVV<int32_t, LMUL_1>;
|
||||
using RVV_I32M2 = struct RVV<int32_t, LMUL_2>;
|
||||
using RVV_I32M4 = struct RVV<int32_t, LMUL_4>;
|
||||
using RVV_I32M8 = struct RVV<int32_t, LMUL_8>;
|
||||
using RVV_I32MF2 = struct RVV<int32_t, LMUL_f2>;
|
||||
|
||||
using RVV_U64M1 = struct RVV<uint64_t, LMUL_1>;
|
||||
using RVV_U64M2 = struct RVV<uint64_t, LMUL_2>;
|
||||
using RVV_U64M4 = struct RVV<uint64_t, LMUL_4>;
|
||||
using RVV_U64M8 = struct RVV<uint64_t, LMUL_8>;
|
||||
|
||||
using RVV_I64M1 = struct RVV<int64_t, LMUL_1>;
|
||||
using RVV_I64M2 = struct RVV<int64_t, LMUL_2>;
|
||||
using RVV_I64M4 = struct RVV<int64_t, LMUL_4>;
|
||||
using RVV_I64M8 = struct RVV<int64_t, LMUL_8>;
|
||||
|
||||
using RVV_F32M1 = struct RVV<float, LMUL_1>;
|
||||
using RVV_F32M2 = struct RVV<float, LMUL_2>;
|
||||
using RVV_F32M4 = struct RVV<float, LMUL_4>;
|
||||
using RVV_F32M8 = struct RVV<float, LMUL_8>;
|
||||
using RVV_F32MF2 = struct RVV<float, LMUL_f2>;
|
||||
|
||||
using RVV_F64M1 = struct RVV<double, LMUL_1>;
|
||||
using RVV_F64M2 = struct RVV<double, LMUL_2>;
|
||||
using RVV_F64M4 = struct RVV<double, LMUL_4>;
|
||||
using RVV_F64M8 = struct RVV<double, LMUL_8>;
|
||||
|
||||
template <typename Dst_T, typename RVV_T>
|
||||
using RVV_SameLen =
|
||||
RVV<Dst_T, RVV_LMUL(static_cast<int>((RVV_T::lmul <= 8 ? RVV_T::lmul * static_cast<float>(sizeof(Dst_T)) : RVV_T::lmul == 9 ? static_cast<float>(sizeof(Dst_T)) / 2 : RVV_T::lmul == 10 ? static_cast<float>(sizeof(Dst_T)) / 4 : static_cast<float>(sizeof(Dst_T)) / 8) / sizeof(typename RVV_T::ElemType) == 0.5 ? 9 : \
|
||||
(RVV_T::lmul <= 8 ? RVV_T::lmul * static_cast<float>(sizeof(Dst_T)) : RVV_T::lmul == 9 ? static_cast<float>(sizeof(Dst_T)) / 2 : RVV_T::lmul == 10 ? static_cast<float>(sizeof(Dst_T)) / 4 : static_cast<float>(sizeof(Dst_T)) / 8) / sizeof(typename RVV_T::ElemType) == 0.25 ? 10 : \
|
||||
(RVV_T::lmul <= 8 ? RVV_T::lmul * static_cast<float>(sizeof(Dst_T)) : RVV_T::lmul == 9 ? static_cast<float>(sizeof(Dst_T)) / 2 : RVV_T::lmul == 10 ? static_cast<float>(sizeof(Dst_T)) / 4 : static_cast<float>(sizeof(Dst_T)) / 8) / sizeof(typename RVV_T::ElemType) == 0.125 ? 11 : \
|
||||
(RVV_T::lmul <= 8 ? RVV_T::lmul * static_cast<float>(sizeof(Dst_T)) : RVV_T::lmul == 9 ? static_cast<float>(sizeof(Dst_T)) / 2 : RVV_T::lmul == 10 ? static_cast<float>(sizeof(Dst_T)) / 4 : static_cast<float>(sizeof(Dst_T)) / 8) / sizeof(typename RVV_T::ElemType)))>;
|
||||
|
||||
template <size_t DstSize> struct RVV_ToIntHelper;
|
||||
template <size_t DstSize> struct RVV_ToUintHelper;
|
||||
template <size_t DstSize> struct RVV_ToFloatHelper;
|
||||
|
||||
template <typename RVV_T>
|
||||
using RVV_ToInt =
|
||||
RVV<typename RVV_ToIntHelper<sizeof(typename RVV_T::ElemType)>::type, RVV_T::lmul>;
|
||||
|
||||
template <typename RVV_T>
|
||||
using RVV_ToUint =
|
||||
RVV<typename RVV_ToUintHelper<sizeof(typename RVV_T::ElemType)>::type, RVV_T::lmul>;
|
||||
|
||||
template <typename RVV_T>
|
||||
using RVV_ToFloat =
|
||||
RVV<typename RVV_ToFloatHelper<sizeof(typename RVV_T::ElemType)>::type, RVV_T::lmul>;
|
||||
|
||||
template <typename RVV_T>
|
||||
using RVV_BaseType = RVV<typename RVV_T::ElemType, LMUL_1>;
|
||||
|
||||
// -------------------------------Supported operations--------------------------------
|
||||
|
||||
#define HAL_RVV_SIZE_RELATED(EEW, TYPE, LMUL, S_OR_F, X_OR_F, IS_U, IS_F, IS_O) \
|
||||
static inline size_t setvlmax() { return __riscv_vsetvlmax_e##EEW##LMUL(); } \
|
||||
static inline size_t setvl(size_t vl) { return __riscv_vsetvl_e##EEW##LMUL(vl); } \
|
||||
static inline VecType vload(const ElemType* ptr, size_t vl) { \
|
||||
return __riscv_vle##EEW##_v_##TYPE##LMUL(ptr, vl); \
|
||||
} \
|
||||
static inline VecType vload(BoolType vm, const ElemType* ptr, size_t vl) { \
|
||||
return __riscv_vle##EEW(vm, ptr, vl); \
|
||||
} \
|
||||
static inline VecType vload_stride(const ElemType* ptr, ptrdiff_t unit, size_t vl) { \
|
||||
return __riscv_vlse##EEW##_v_##TYPE##LMUL(ptr, unit, vl); \
|
||||
} \
|
||||
static inline VecType vload_stride(BoolType vm, const ElemType* ptr, ptrdiff_t unit, size_t vl) { \
|
||||
return __riscv_vlse##EEW(vm, ptr, unit, vl); \
|
||||
} \
|
||||
static inline void vstore(ElemType* ptr, VecType v, size_t vl) { \
|
||||
__riscv_vse##EEW(ptr, v, vl); \
|
||||
} \
|
||||
static inline void vstore(BoolType vm, ElemType* ptr, VecType v, size_t vl) { \
|
||||
__riscv_vse##EEW(vm, ptr, v, vl); \
|
||||
} \
|
||||
static inline void vstore_stride(ElemType* ptr, ptrdiff_t unit, VecType v, size_t vl) { \
|
||||
__riscv_vsse##EEW(ptr, unit, v, vl); \
|
||||
} \
|
||||
static inline void vstore_stride(BoolType vm, ElemType* ptr, ptrdiff_t unit, VecType v, size_t vl) { \
|
||||
__riscv_vsse##EEW(vm, ptr, unit, v, vl); \
|
||||
} \
|
||||
static inline VecType vundefined() { return __riscv_vundefined_##TYPE##LMUL(); } \
|
||||
static inline VecType vmv(ElemType a, size_t vl) { \
|
||||
return __riscv_v##IS_F##mv_v_##X_OR_F##_##TYPE##LMUL(a, vl); \
|
||||
} \
|
||||
static inline VecType vmv_s(ElemType a, size_t vl) { \
|
||||
return __riscv_v##IS_F##mv_s_##X_OR_F##_##TYPE##LMUL(a, vl); \
|
||||
} \
|
||||
static inline VecType vslideup(VecType vs2, VecType vs1, size_t n, size_t vl) { \
|
||||
return __riscv_vslideup_vx_##TYPE##LMUL(vs2, vs1, n, vl); \
|
||||
} \
|
||||
static inline VecType vslidedown(VecType vs, size_t n, size_t vl) { \
|
||||
return __riscv_vslidedown_vx_##TYPE##LMUL(vs, n, vl); \
|
||||
} \
|
||||
HAL_RVV_SIZE_RELATED_CUSTOM(EEW, TYPE, LMUL)
|
||||
|
||||
#define HAL_RVV_SIZE_UNRELATED(S_OR_F, X_OR_F, IS_U, IS_F, IS_O) \
|
||||
static inline ElemType vmv_x(VecType vs2) { return __riscv_v##IS_F##mv_##X_OR_F(vs2); } \
|
||||
\
|
||||
static inline BoolType vmlt(VecType vs2, VecType vs1, size_t vl) { \
|
||||
return __riscv_vm##S_OR_F##lt##IS_U(vs2, vs1, vl); \
|
||||
} \
|
||||
static inline BoolType vmle(VecType vs2, VecType vs1, size_t vl) { \
|
||||
return __riscv_vm##S_OR_F##le##IS_U(vs2, vs1, vl); \
|
||||
} \
|
||||
static inline BoolType vmgt(VecType vs2, VecType vs1, size_t vl) { \
|
||||
return __riscv_vm##S_OR_F##gt##IS_U(vs2, vs1, vl); \
|
||||
} \
|
||||
static inline BoolType vmle(VecType vs2, ElemType vs1, size_t vl) { \
|
||||
return __riscv_vm##S_OR_F##le##IS_U(vs2, vs1, vl); \
|
||||
} \
|
||||
static inline BoolType vmgt(VecType vs2, ElemType vs1, size_t vl) { \
|
||||
return __riscv_vm##S_OR_F##gt##IS_U(vs2, vs1, vl); \
|
||||
} \
|
||||
static inline BoolType vmge(VecType vs2, VecType vs1, size_t vl) { \
|
||||
return __riscv_vm##S_OR_F##ge##IS_U(vs2, vs1, vl); \
|
||||
} \
|
||||
static inline BoolType vmeq(VecType vs2, ElemType vs1, size_t vl) { \
|
||||
return __riscv_vm##S_OR_F##eq(vs2, vs1, vl); \
|
||||
} \
|
||||
static inline BoolType vmne(VecType vs2, ElemType vs1, size_t vl) { \
|
||||
return __riscv_vm##S_OR_F##ne(vs2, vs1, vl); \
|
||||
} \
|
||||
static inline BoolType vmlt_mu(BoolType vm, BoolType vd, VecType vs2, VecType vs1, size_t vl) { \
|
||||
return __riscv_vm##S_OR_F##lt##IS_U##_mu(vm, vd, vs2, vs1, vl); \
|
||||
} \
|
||||
static inline BoolType vmle_mu(BoolType vm, BoolType vd, VecType vs2, VecType vs1, size_t vl) { \
|
||||
return __riscv_vm##S_OR_F##le##IS_U##_mu(vm, vd, vs2, vs1, vl); \
|
||||
} \
|
||||
static inline BoolType vmgt_mu(BoolType vm, BoolType vd, VecType vs2, VecType vs1, size_t vl) { \
|
||||
return __riscv_vm##S_OR_F##gt##IS_U##_mu(vm, vd, vs2, vs1, vl); \
|
||||
} \
|
||||
static inline BoolType vmge_mu(BoolType vm, BoolType vd, VecType vs2, VecType vs1, size_t vl) { \
|
||||
return __riscv_vm##S_OR_F##ge##IS_U##_mu(vm, vd, vs2, vs1, vl); \
|
||||
} \
|
||||
\
|
||||
static inline VecType vadd(VecType vs2, VecType vs1, size_t vl) { \
|
||||
return __riscv_v##IS_F##add(vs2, vs1, vl); \
|
||||
} \
|
||||
static inline VecType vsub(VecType vs2, VecType vs1, size_t vl) { \
|
||||
return __riscv_v##IS_F##sub(vs2, vs1, vl); \
|
||||
} \
|
||||
static inline VecType vadd_tu(VecType vd, VecType vs2, VecType vs1, size_t vl) { \
|
||||
return __riscv_v##IS_F##add_tu(vd, vs2, vs1, vl); \
|
||||
} \
|
||||
static inline VecType vsub_tu(VecType vd, VecType vs2, VecType vs1, size_t vl) { \
|
||||
return __riscv_v##IS_F##sub_tu(vd, vs2, vs1, vl); \
|
||||
} \
|
||||
static inline VecType vmul(VecType vs2, VecType vs1, size_t vl) { \
|
||||
return __riscv_v##IS_F##mul(vs2, vs1, vl); \
|
||||
} \
|
||||
\
|
||||
static inline VecType vslide1down(VecType vs2, ElemType vs1, size_t vl) { \
|
||||
return __riscv_v##IS_F##slide1down(vs2, vs1, vl); \
|
||||
} \
|
||||
static inline VecType vslide1up(VecType vs2, ElemType vs1, size_t vl) { \
|
||||
return __riscv_v##IS_F##slide1up(vs2, vs1, vl); \
|
||||
} \
|
||||
\
|
||||
static inline VecType vmin(VecType vs2, VecType vs1, size_t vl) { \
|
||||
return __riscv_v##IS_F##min##IS_U(vs2, vs1, vl); \
|
||||
} \
|
||||
static inline VecType vmax(VecType vs2, VecType vs1, size_t vl) { \
|
||||
return __riscv_v##IS_F##max##IS_U(vs2, vs1, vl); \
|
||||
} \
|
||||
static inline VecType vmin_tu(VecType vd, VecType vs2, VecType vs1, size_t vl) { \
|
||||
return __riscv_v##IS_F##min##IS_U##_tu(vd, vs2, vs1, vl); \
|
||||
} \
|
||||
static inline VecType vmax_tu(VecType vd, VecType vs2, VecType vs1, size_t vl) { \
|
||||
return __riscv_v##IS_F##max##IS_U##_tu(vd, vs2, vs1, vl); \
|
||||
} \
|
||||
static inline VecType vmin_tumu(BoolType vm, VecType vd, VecType vs2, VecType vs1, size_t vl) { \
|
||||
return __riscv_v##IS_F##min##IS_U##_tumu(vm, vd, vs2, vs1, vl); \
|
||||
} \
|
||||
static inline VecType vmax_tumu(BoolType vm, VecType vd, VecType vs2, VecType vs1, size_t vl) { \
|
||||
return __riscv_v##IS_F##max##IS_U##_tumu(vm, vd, vs2, vs1, vl); \
|
||||
} \
|
||||
\
|
||||
static inline BaseType vredmin(VecType vs2, BaseType vs1, size_t vl) { \
|
||||
return __riscv_v##IS_F##redmin##IS_U(vs2, vs1, vl); \
|
||||
} \
|
||||
static inline BaseType vredmax(VecType vs2, BaseType vs1, size_t vl) { \
|
||||
return __riscv_v##IS_F##redmax##IS_U(vs2, vs1, vl); \
|
||||
} \
|
||||
static inline BaseType vredsum(VecType vs2, BaseType vs1, size_t vl) { \
|
||||
return __riscv_v##IS_F##red##IS_O##sum(vs2, vs1, vl); \
|
||||
}
|
||||
|
||||
#define HAL_RVV_BOOL_TYPE(S_OR_F, X_OR_F, IS_U, IS_F, IS_O) \
|
||||
decltype(__riscv_vm##S_OR_F##eq(std::declval<VecType>(), std::declval<VecType>(), 0))
|
||||
|
||||
#define HAL_RVV_DEFINE_ONE(ELEM_TYPE, VEC_TYPE, LMUL_TYPE, \
|
||||
EEW, TYPE, LMUL, ...) \
|
||||
template <> struct RVV<ELEM_TYPE, LMUL_TYPE> \
|
||||
{ \
|
||||
using ElemType = ELEM_TYPE; \
|
||||
using VecType = v##VEC_TYPE##LMUL##_t; \
|
||||
using BoolType = HAL_RVV_BOOL_TYPE(__VA_ARGS__); \
|
||||
using BaseType = v##VEC_TYPE##m1_t; \
|
||||
\
|
||||
static constexpr RVV_LMUL lmul = LMUL_TYPE; \
|
||||
\
|
||||
HAL_RVV_SIZE_RELATED(EEW, TYPE, LMUL, __VA_ARGS__) \
|
||||
HAL_RVV_SIZE_UNRELATED(__VA_ARGS__) \
|
||||
\
|
||||
template <typename FROM> \
|
||||
inline static VecType cast(FROM v, size_t vl); \
|
||||
template <typename FROM> \
|
||||
inline static VecType reinterpret(FROM v); \
|
||||
}; \
|
||||
\
|
||||
template <> \
|
||||
inline RVV<ELEM_TYPE, LMUL_TYPE>::VecType \
|
||||
RVV<ELEM_TYPE, LMUL_TYPE>::cast( \
|
||||
RVV<ELEM_TYPE, LMUL_TYPE>::VecType v, \
|
||||
[[maybe_unused]] size_t vl \
|
||||
) \
|
||||
{ \
|
||||
return v; \
|
||||
}
|
||||
|
||||
// -------------------------------Define all types--------------------------------
|
||||
|
||||
#define HAL_RVV_DEFINE_ALL(ELEM_TYPE, VEC_TYPE, \
|
||||
EEW, TYPE, ...) \
|
||||
HAL_RVV_DEFINE_ONE(ELEM_TYPE, VEC_TYPE, LMUL_1, \
|
||||
EEW, TYPE, m1, __VA_ARGS__) \
|
||||
HAL_RVV_DEFINE_ONE(ELEM_TYPE, VEC_TYPE, LMUL_2, \
|
||||
EEW, TYPE, m2, __VA_ARGS__) \
|
||||
HAL_RVV_DEFINE_ONE(ELEM_TYPE, VEC_TYPE, LMUL_4, \
|
||||
EEW, TYPE, m4, __VA_ARGS__) \
|
||||
HAL_RVV_DEFINE_ONE(ELEM_TYPE, VEC_TYPE, LMUL_8, \
|
||||
EEW, TYPE, m8, __VA_ARGS__)
|
||||
|
||||
#define HAL_RVV_SIGNED_PARAM s,x, , ,
|
||||
#define HAL_RVV_UNSIGNED_PARAM s,x,u, ,
|
||||
#define HAL_RVV_FLOAT_PARAM f,f, ,f,o
|
||||
|
||||
// -------------------------------Define Unsigned Integer--------------------------------
|
||||
|
||||
#define HAL_RVV_SIZE_RELATED_CUSTOM(EEW, TYPE, LMUL) \
|
||||
static inline VecType vid(size_t vl) { return __riscv_vid_v_##TYPE##LMUL(vl); }
|
||||
|
||||
// LMUL = 1, 2, 4, 8
|
||||
HAL_RVV_DEFINE_ALL( uint8_t, uint8, 8, u8, HAL_RVV_UNSIGNED_PARAM)
|
||||
HAL_RVV_DEFINE_ALL(uint16_t, uint16, 16, u16, HAL_RVV_UNSIGNED_PARAM)
|
||||
HAL_RVV_DEFINE_ALL(uint32_t, uint32, 32, u32, HAL_RVV_UNSIGNED_PARAM)
|
||||
HAL_RVV_DEFINE_ALL(uint64_t, uint64, 64, u64, HAL_RVV_UNSIGNED_PARAM)
|
||||
|
||||
// LMUL = f2
|
||||
HAL_RVV_DEFINE_ONE( uint8_t, uint8, LMUL_f2, 8, u8, mf2, HAL_RVV_UNSIGNED_PARAM)
|
||||
HAL_RVV_DEFINE_ONE(uint16_t, uint16, LMUL_f2, 16, u16, mf2, HAL_RVV_UNSIGNED_PARAM)
|
||||
HAL_RVV_DEFINE_ONE(uint32_t, uint32, LMUL_f2, 32, u32, mf2, HAL_RVV_UNSIGNED_PARAM)
|
||||
|
||||
// LMUL = f4
|
||||
HAL_RVV_DEFINE_ONE( uint8_t, uint8, LMUL_f4, 8, u8, mf4, HAL_RVV_UNSIGNED_PARAM)
|
||||
HAL_RVV_DEFINE_ONE(uint16_t, uint16, LMUL_f4, 16, u16, mf4, HAL_RVV_UNSIGNED_PARAM)
|
||||
|
||||
// LMUL = f8
|
||||
HAL_RVV_DEFINE_ONE( uint8_t, uint8, LMUL_f8, 8, u8, mf8, HAL_RVV_UNSIGNED_PARAM)
|
||||
|
||||
#undef HAL_RVV_SIZE_RELATED_CUSTOM
|
||||
|
||||
// -------------------------------Define Signed Integer--------------------------------
|
||||
|
||||
#define HAL_RVV_SIZE_RELATED_CUSTOM(EEW, TYPE, LMUL)
|
||||
|
||||
// LMUL = 1, 2, 4, 8
|
||||
HAL_RVV_DEFINE_ALL( int8_t, int8, 8, i8, HAL_RVV_SIGNED_PARAM)
|
||||
HAL_RVV_DEFINE_ALL(int16_t, int16, 16, i16, HAL_RVV_SIGNED_PARAM)
|
||||
HAL_RVV_DEFINE_ALL(int32_t, int32, 32, i32, HAL_RVV_SIGNED_PARAM)
|
||||
HAL_RVV_DEFINE_ALL(int64_t, int64, 64, i64, HAL_RVV_SIGNED_PARAM)
|
||||
|
||||
// LMUL = f2
|
||||
HAL_RVV_DEFINE_ONE( int8_t, int8, LMUL_f2, 8, i8, mf2, HAL_RVV_SIGNED_PARAM)
|
||||
HAL_RVV_DEFINE_ONE(int16_t, int16, LMUL_f2, 16, i16, mf2, HAL_RVV_SIGNED_PARAM)
|
||||
HAL_RVV_DEFINE_ONE(int32_t, int32, LMUL_f2, 32, i32, mf2, HAL_RVV_SIGNED_PARAM)
|
||||
|
||||
// LMUL = f4
|
||||
HAL_RVV_DEFINE_ONE( int8_t, int8, LMUL_f4, 8, i8, mf4, HAL_RVV_SIGNED_PARAM)
|
||||
HAL_RVV_DEFINE_ONE(int16_t, int16, LMUL_f4, 16, i16, mf4, HAL_RVV_SIGNED_PARAM)
|
||||
|
||||
// LMUL = f8
|
||||
HAL_RVV_DEFINE_ONE( int8_t, int8, LMUL_f8, 8, i8, mf8, HAL_RVV_SIGNED_PARAM)
|
||||
|
||||
// -------------------------------Define Floating Point--------------------------------
|
||||
|
||||
// LMUL = 1, 2, 4, 8
|
||||
HAL_RVV_DEFINE_ALL( float, float32, 32, f32, HAL_RVV_FLOAT_PARAM)
|
||||
HAL_RVV_DEFINE_ALL(double, float64, 64, f64, HAL_RVV_FLOAT_PARAM)
|
||||
|
||||
// LMUL = f2
|
||||
HAL_RVV_DEFINE_ONE( float, float32, LMUL_f2, 32, f32, mf2, HAL_RVV_FLOAT_PARAM)
|
||||
|
||||
#undef HAL_RVV_SIZE_RELATED_CUSTOM
|
||||
#undef HAL_RVV_DEFINE_ALL
|
||||
#undef HAL_RVV_DEFINE_ONE
|
||||
#undef HAL_RVV_BOOL_TYPE
|
||||
#undef HAL_RVV_SIZE_UNRELATED
|
||||
#undef HAL_RVV_SIZE_RELATED
|
||||
|
||||
// -------------------------------Define cast--------------------------------
|
||||
|
||||
template <> struct RVV_ToIntHelper<1> {using type = int8_t;};
|
||||
template <> struct RVV_ToIntHelper<2> {using type = int16_t;};
|
||||
template <> struct RVV_ToIntHelper<4> {using type = int32_t;};
|
||||
template <> struct RVV_ToIntHelper<8> {using type = int64_t;};
|
||||
|
||||
template <> struct RVV_ToUintHelper<1> {using type = uint8_t;};
|
||||
template <> struct RVV_ToUintHelper<2> {using type = uint16_t;};
|
||||
template <> struct RVV_ToUintHelper<4> {using type = uint32_t;};
|
||||
template <> struct RVV_ToUintHelper<8> {using type = uint64_t;};
|
||||
|
||||
template <> struct RVV_ToFloatHelper<2> {using type = _Float16;};
|
||||
template <> struct RVV_ToFloatHelper<4> {using type = float;};
|
||||
template <> struct RVV_ToFloatHelper<8> {using type = double;};
|
||||
|
||||
#define HAL_RVV_CVT(ONE, TWO) \
|
||||
template <> \
|
||||
inline ONE::VecType ONE::cast(TWO::VecType v, size_t vl) { return __riscv_vncvt_x(v, vl); } \
|
||||
template <> \
|
||||
inline TWO::VecType TWO::cast(ONE::VecType v, size_t vl) { return __riscv_vsext_vf2(v, vl); }
|
||||
|
||||
HAL_RVV_CVT(RVV_I8M4, RVV_I16M8)
|
||||
HAL_RVV_CVT(RVV_I8M2, RVV_I16M4)
|
||||
HAL_RVV_CVT(RVV_I8M1, RVV_I16M2)
|
||||
HAL_RVV_CVT(RVV_I8MF2, RVV_I16M1)
|
||||
HAL_RVV_CVT(RVV_I8MF4, RVV_I16MF2)
|
||||
HAL_RVV_CVT(RVV_I8MF8, RVV_I16MF4)
|
||||
|
||||
HAL_RVV_CVT(RVV_I16M4, RVV_I32M8)
|
||||
HAL_RVV_CVT(RVV_I16M2, RVV_I32M4)
|
||||
HAL_RVV_CVT(RVV_I16M1, RVV_I32M2)
|
||||
HAL_RVV_CVT(RVV_I16MF2, RVV_I32M1)
|
||||
HAL_RVV_CVT(RVV_I16MF4, RVV_I32MF2)
|
||||
|
||||
HAL_RVV_CVT(RVV_I32M4, RVV_I64M8)
|
||||
HAL_RVV_CVT(RVV_I32M2, RVV_I64M4)
|
||||
HAL_RVV_CVT(RVV_I32M1, RVV_I64M2)
|
||||
HAL_RVV_CVT(RVV_I32MF2, RVV_I64M1)
|
||||
|
||||
#undef HAL_RVV_CVT
|
||||
|
||||
#define HAL_RVV_CVT(ONE, TWO) \
|
||||
template <> \
|
||||
inline ONE::VecType ONE::cast(TWO::VecType v, size_t vl) { return __riscv_vncvt_x(v, vl); } \
|
||||
template <> \
|
||||
inline TWO::VecType TWO::cast(ONE::VecType v, size_t vl) { return __riscv_vzext_vf2(v, vl); }
|
||||
|
||||
HAL_RVV_CVT(RVV_U8M4, RVV_U16M8)
|
||||
HAL_RVV_CVT(RVV_U8M2, RVV_U16M4)
|
||||
HAL_RVV_CVT(RVV_U8M1, RVV_U16M2)
|
||||
HAL_RVV_CVT(RVV_U8MF2, RVV_U16M1)
|
||||
HAL_RVV_CVT(RVV_U8MF4, RVV_U16MF2)
|
||||
HAL_RVV_CVT(RVV_U8MF8, RVV_U16MF4)
|
||||
|
||||
HAL_RVV_CVT(RVV_U16M4, RVV_U32M8)
|
||||
HAL_RVV_CVT(RVV_U16M2, RVV_U32M4)
|
||||
HAL_RVV_CVT(RVV_U16M1, RVV_U32M2)
|
||||
HAL_RVV_CVT(RVV_U16MF2, RVV_U32M1)
|
||||
HAL_RVV_CVT(RVV_U16MF4, RVV_U32MF2)
|
||||
|
||||
HAL_RVV_CVT(RVV_U32M4, RVV_U64M8)
|
||||
HAL_RVV_CVT(RVV_U32M2, RVV_U64M4)
|
||||
HAL_RVV_CVT(RVV_U32M1, RVV_U64M2)
|
||||
HAL_RVV_CVT(RVV_U32MF2, RVV_U64M1)
|
||||
|
||||
#undef HAL_RVV_CVT
|
||||
|
||||
#define HAL_RVV_CVT(ONE, FOUR) \
|
||||
template <> \
|
||||
inline FOUR::VecType FOUR::cast(ONE::VecType v, size_t vl) { return __riscv_vsext_vf4(v, vl); } \
|
||||
template <> \
|
||||
inline ONE::VecType ONE::cast(FOUR::VecType v, size_t vl) { \
|
||||
return __riscv_vncvt_x(__riscv_vncvt_x(v, vl), vl); \
|
||||
}
|
||||
|
||||
HAL_RVV_CVT(RVV_I8M2, RVV_I32M8)
|
||||
HAL_RVV_CVT(RVV_I8M1, RVV_I32M4)
|
||||
HAL_RVV_CVT(RVV_I8MF2, RVV_I32M2)
|
||||
HAL_RVV_CVT(RVV_I8MF4, RVV_I32M1)
|
||||
HAL_RVV_CVT(RVV_I8MF8, RVV_I32MF2)
|
||||
|
||||
HAL_RVV_CVT(RVV_I16M2, RVV_I64M8)
|
||||
HAL_RVV_CVT(RVV_I16M1, RVV_I64M4)
|
||||
HAL_RVV_CVT(RVV_I16MF2, RVV_I64M2)
|
||||
HAL_RVV_CVT(RVV_I16MF4, RVV_I64M1)
|
||||
|
||||
#undef HAL_RVV_CVT
|
||||
|
||||
#define HAL_RVV_CVT(ONE, FOUR) \
|
||||
template <> \
|
||||
inline FOUR::VecType FOUR::cast(ONE::VecType v, size_t vl) { return __riscv_vzext_vf4(v, vl); } \
|
||||
template <> \
|
||||
inline ONE::VecType ONE::cast(FOUR::VecType v, size_t vl) { \
|
||||
return __riscv_vncvt_x(__riscv_vncvt_x(v, vl), vl); \
|
||||
}
|
||||
|
||||
HAL_RVV_CVT(RVV_U8M2, RVV_U32M8)
|
||||
HAL_RVV_CVT(RVV_U8M1, RVV_U32M4)
|
||||
HAL_RVV_CVT(RVV_U8MF2, RVV_U32M2)
|
||||
HAL_RVV_CVT(RVV_U8MF4, RVV_U32M1)
|
||||
HAL_RVV_CVT(RVV_U8MF8, RVV_U32MF2)
|
||||
|
||||
HAL_RVV_CVT(RVV_U16M2, RVV_U64M8)
|
||||
HAL_RVV_CVT(RVV_U16M1, RVV_U64M4)
|
||||
HAL_RVV_CVT(RVV_U16MF2, RVV_U64M2)
|
||||
HAL_RVV_CVT(RVV_U16MF4, RVV_U64M1)
|
||||
|
||||
#undef HAL_RVV_CVT
|
||||
|
||||
#define HAL_RVV_CVT(ONE, EIGHT) \
|
||||
template <> \
|
||||
inline EIGHT::VecType EIGHT::cast(ONE::VecType v, size_t vl) { return __riscv_vsext_vf8(v, vl); } \
|
||||
template <> \
|
||||
inline ONE::VecType ONE::cast(EIGHT::VecType v, size_t vl) { \
|
||||
return __riscv_vncvt_x(__riscv_vncvt_x(__riscv_vncvt_x(v ,vl), vl), vl); \
|
||||
}
|
||||
|
||||
HAL_RVV_CVT(RVV_I8M1, RVV_I64M8)
|
||||
HAL_RVV_CVT(RVV_I8MF2, RVV_I64M4)
|
||||
HAL_RVV_CVT(RVV_I8MF4, RVV_I64M2)
|
||||
HAL_RVV_CVT(RVV_I8MF8, RVV_I64M1)
|
||||
|
||||
#undef HAL_RVV_CVT
|
||||
|
||||
#define HAL_RVV_CVT(ONE, EIGHT) \
|
||||
template <> \
|
||||
inline EIGHT::VecType EIGHT::cast(ONE::VecType v, size_t vl) { return __riscv_vzext_vf8(v, vl); } \
|
||||
template <> \
|
||||
inline ONE::VecType ONE::cast(EIGHT::VecType v, size_t vl) { \
|
||||
return __riscv_vncvt_x(__riscv_vncvt_x(__riscv_vncvt_x(v ,vl), vl), vl); \
|
||||
}
|
||||
|
||||
HAL_RVV_CVT(RVV_U8M1, RVV_U64M8)
|
||||
HAL_RVV_CVT(RVV_U8MF2, RVV_U64M4)
|
||||
HAL_RVV_CVT(RVV_U8MF4, RVV_U64M2)
|
||||
HAL_RVV_CVT(RVV_U8MF8, RVV_U64M1)
|
||||
|
||||
#undef HAL_RVV_CVT
|
||||
|
||||
#define HAL_RVV_CVT(F32, F64) \
|
||||
template <> \
|
||||
inline F32::VecType F32::cast(F64::VecType v, size_t vl) { return __riscv_vfncvt_f(v, vl); } \
|
||||
template <> \
|
||||
inline F64::VecType F64::cast(F32::VecType v, size_t vl) { return __riscv_vfwcvt_f(v, vl); }
|
||||
|
||||
HAL_RVV_CVT(RVV_F32M4, RVV_F64M8)
|
||||
HAL_RVV_CVT(RVV_F32M2, RVV_F64M4)
|
||||
HAL_RVV_CVT(RVV_F32M1, RVV_F64M2)
|
||||
HAL_RVV_CVT(RVV_F32MF2, RVV_F64M1)
|
||||
|
||||
#undef HAL_RVV_CVT
|
||||
|
||||
#define HAL_RVV_CVT(A, B, A_TYPE, B_TYPE, LMUL_TYPE, LMUL, IS_U) \
|
||||
template <> \
|
||||
inline RVV<A, LMUL_TYPE>::VecType RVV<A, LMUL_TYPE>::cast( \
|
||||
RVV<B, LMUL_TYPE>::VecType v, size_t vl \
|
||||
) { \
|
||||
return __riscv_vfcvt_f_x##IS_U##_v_##A_TYPE##LMUL(v, vl); \
|
||||
} \
|
||||
template <> \
|
||||
inline RVV<B, LMUL_TYPE>::VecType RVV<B, LMUL_TYPE>::cast( \
|
||||
RVV<A, LMUL_TYPE>::VecType v, size_t vl \
|
||||
) { \
|
||||
return __riscv_vfcvt_x##IS_U##_f_v_##B_TYPE##LMUL(v, vl); \
|
||||
}
|
||||
|
||||
HAL_RVV_CVT( float, int32_t, f32, i32, LMUL_1, m1, )
|
||||
HAL_RVV_CVT( float, int32_t, f32, i32, LMUL_2, m2, )
|
||||
HAL_RVV_CVT( float, int32_t, f32, i32, LMUL_4, m4, )
|
||||
HAL_RVV_CVT( float, int32_t, f32, i32, LMUL_8, m8, )
|
||||
HAL_RVV_CVT( float, int32_t, f32, i32, LMUL_f2, mf2, )
|
||||
|
||||
HAL_RVV_CVT( float, uint32_t, f32, u32, LMUL_1, m1, u)
|
||||
HAL_RVV_CVT( float, uint32_t, f32, u32, LMUL_2, m2, u)
|
||||
HAL_RVV_CVT( float, uint32_t, f32, u32, LMUL_4, m4, u)
|
||||
HAL_RVV_CVT( float, uint32_t, f32, u32, LMUL_8, m8, u)
|
||||
HAL_RVV_CVT( float, uint32_t, f32, u32, LMUL_f2, mf2, u)
|
||||
|
||||
HAL_RVV_CVT(double, int64_t, f64, i64, LMUL_1, m1, )
|
||||
HAL_RVV_CVT(double, int64_t, f64, i64, LMUL_2, m2, )
|
||||
HAL_RVV_CVT(double, int64_t, f64, i64, LMUL_4, m4, )
|
||||
HAL_RVV_CVT(double, int64_t, f64, i64, LMUL_8, m8, )
|
||||
|
||||
HAL_RVV_CVT(double, uint64_t, f64, u64, LMUL_1, m1, u)
|
||||
HAL_RVV_CVT(double, uint64_t, f64, u64, LMUL_2, m2, u)
|
||||
HAL_RVV_CVT(double, uint64_t, f64, u64, LMUL_4, m4, u)
|
||||
HAL_RVV_CVT(double, uint64_t, f64, u64, LMUL_8, m8, u)
|
||||
|
||||
#undef HAL_RVV_CVT
|
||||
|
||||
#define HAL_RVV_CVT(A, B, A_TYPE, B_TYPE, LMUL_TYPE, LMUL) \
|
||||
template <> \
|
||||
inline RVV<A, LMUL_TYPE>::VecType RVV<A, LMUL_TYPE>::reinterpret(RVV<B, LMUL_TYPE>::VecType v) { \
|
||||
return __riscv_vreinterpret_##A_TYPE##LMUL(v); \
|
||||
} \
|
||||
template <> \
|
||||
inline RVV<B, LMUL_TYPE>::VecType RVV<B, LMUL_TYPE>::reinterpret(RVV<A, LMUL_TYPE>::VecType v) { \
|
||||
return __riscv_vreinterpret_##B_TYPE##LMUL(v); \
|
||||
}
|
||||
|
||||
#define HAL_RVV_CVT2(A, B, A_TYPE, B_TYPE) \
|
||||
HAL_RVV_CVT(A, B, A_TYPE, B_TYPE, LMUL_1, m1) \
|
||||
HAL_RVV_CVT(A, B, A_TYPE, B_TYPE, LMUL_2, m2) \
|
||||
HAL_RVV_CVT(A, B, A_TYPE, B_TYPE, LMUL_4, m4) \
|
||||
HAL_RVV_CVT(A, B, A_TYPE, B_TYPE, LMUL_8, m8)
|
||||
|
||||
HAL_RVV_CVT2( uint8_t, int8_t, u8, i8)
|
||||
HAL_RVV_CVT2(uint16_t, int16_t, u16, i16)
|
||||
HAL_RVV_CVT2(uint32_t, int32_t, u32, i32)
|
||||
HAL_RVV_CVT2(uint64_t, int64_t, u64, i64)
|
||||
|
||||
HAL_RVV_CVT2( int32_t, float, i32, f32)
|
||||
HAL_RVV_CVT2(uint32_t, float, u32, f32)
|
||||
HAL_RVV_CVT2( int64_t, double, i64, f64)
|
||||
HAL_RVV_CVT2(uint64_t, double, u64, f64)
|
||||
|
||||
#undef HAL_RVV_CVT2
|
||||
|
||||
HAL_RVV_CVT( uint8_t, int8_t, u8, i8, LMUL_f2, mf2)
|
||||
HAL_RVV_CVT(uint16_t, int16_t, u16, i16, LMUL_f2, mf2)
|
||||
HAL_RVV_CVT(uint32_t, int32_t, u32, i32, LMUL_f2, mf2)
|
||||
HAL_RVV_CVT( int32_t, float, i32, f32, LMUL_f2, mf2)
|
||||
HAL_RVV_CVT(uint32_t, float, u32, f32, LMUL_f2, mf2)
|
||||
|
||||
HAL_RVV_CVT( uint8_t, int8_t, u8, i8, LMUL_f4, mf4)
|
||||
HAL_RVV_CVT(uint16_t, int16_t, u16, i16, LMUL_f4, mf4)
|
||||
|
||||
HAL_RVV_CVT( uint8_t, int8_t, u8, i8, LMUL_f8, mf8)
|
||||
|
||||
#undef HAL_RVV_CVT
|
||||
|
||||
#define HAL_RVV_CVT(A, B, A_TYPE, B_TYPE, LMUL_TYPE, LMUL) \
|
||||
template <> \
|
||||
inline RVV<A, LMUL_TYPE>::VecType RVV<A, LMUL_TYPE>::cast(RVV<B, LMUL_TYPE>::VecType v, [[maybe_unused]] size_t vl) { \
|
||||
return __riscv_vreinterpret_##A_TYPE##LMUL(v); \
|
||||
} \
|
||||
template <> \
|
||||
inline RVV<B, LMUL_TYPE>::VecType RVV<B, LMUL_TYPE>::cast(RVV<A, LMUL_TYPE>::VecType v, [[maybe_unused]] size_t vl) { \
|
||||
return __riscv_vreinterpret_##B_TYPE##LMUL(v); \
|
||||
}
|
||||
|
||||
#define HAL_RVV_CVT2(A, B, A_TYPE, B_TYPE) \
|
||||
HAL_RVV_CVT(A, B, A_TYPE, B_TYPE, LMUL_1, m1) \
|
||||
HAL_RVV_CVT(A, B, A_TYPE, B_TYPE, LMUL_2, m2) \
|
||||
HAL_RVV_CVT(A, B, A_TYPE, B_TYPE, LMUL_4, m4) \
|
||||
HAL_RVV_CVT(A, B, A_TYPE, B_TYPE, LMUL_8, m8)
|
||||
|
||||
HAL_RVV_CVT2( uint8_t, int8_t, u8, i8)
|
||||
HAL_RVV_CVT2(uint16_t, int16_t, u16, i16)
|
||||
HAL_RVV_CVT2(uint32_t, int32_t, u32, i32)
|
||||
HAL_RVV_CVT2(uint64_t, int64_t, u64, i64)
|
||||
|
||||
#undef HAL_RVV_CVT2
|
||||
#undef HAL_RVV_CVT
|
||||
|
||||
#define HAL_RVV_CVT(FROM, INTERMEDIATE, TO) \
|
||||
template <> \
|
||||
inline TO::VecType TO::cast(FROM::VecType v, size_t vl) { \
|
||||
return TO::cast(INTERMEDIATE::cast(v, vl), vl); \
|
||||
} \
|
||||
template <> \
|
||||
inline FROM::VecType FROM::cast(TO::VecType v, size_t vl) { \
|
||||
return FROM::cast(INTERMEDIATE::cast(v, vl), vl); \
|
||||
}
|
||||
|
||||
// Integer and Float conversions
|
||||
HAL_RVV_CVT(RVV_I8M1, RVV_I32M4, RVV_F32M4)
|
||||
HAL_RVV_CVT(RVV_I8M2, RVV_I32M8, RVV_F32M8)
|
||||
HAL_RVV_CVT(RVV_I8M1, RVV_I64M8, RVV_F64M8)
|
||||
|
||||
HAL_RVV_CVT(RVV_I16M1, RVV_I32M2, RVV_F32M2)
|
||||
HAL_RVV_CVT(RVV_I16M2, RVV_I32M4, RVV_F32M4)
|
||||
HAL_RVV_CVT(RVV_I16M4, RVV_I32M8, RVV_F32M8)
|
||||
HAL_RVV_CVT(RVV_I16M1, RVV_I64M4, RVV_F64M4)
|
||||
HAL_RVV_CVT(RVV_I16M2, RVV_I64M8, RVV_F64M8)
|
||||
|
||||
HAL_RVV_CVT(RVV_I32M1, RVV_I64M2, RVV_F64M2)
|
||||
HAL_RVV_CVT(RVV_I32M2, RVV_I64M4, RVV_F64M4)
|
||||
HAL_RVV_CVT(RVV_I32M4, RVV_I64M8, RVV_F64M8)
|
||||
|
||||
HAL_RVV_CVT(RVV_U8M1, RVV_U32M4, RVV_F32M4)
|
||||
HAL_RVV_CVT(RVV_U8M2, RVV_U32M8, RVV_F32M8)
|
||||
HAL_RVV_CVT(RVV_U8M1, RVV_U64M8, RVV_F64M8)
|
||||
|
||||
HAL_RVV_CVT(RVV_U16M1, RVV_U32M2, RVV_F32M2)
|
||||
HAL_RVV_CVT(RVV_U16M2, RVV_U32M4, RVV_F32M4)
|
||||
HAL_RVV_CVT(RVV_U16M4, RVV_U32M8, RVV_F32M8)
|
||||
HAL_RVV_CVT(RVV_U16M1, RVV_U64M4, RVV_F64M4)
|
||||
HAL_RVV_CVT(RVV_U16M2, RVV_U64M8, RVV_F64M8)
|
||||
|
||||
HAL_RVV_CVT(RVV_U32M1, RVV_U64M2, RVV_F64M2)
|
||||
HAL_RVV_CVT(RVV_U32M2, RVV_U64M4, RVV_F64M4)
|
||||
HAL_RVV_CVT(RVV_U32M4, RVV_U64M8, RVV_F64M8)
|
||||
|
||||
// Signed and Unsigned conversions
|
||||
HAL_RVV_CVT(RVV_U8M1, RVV_U16M2, RVV_I16M2)
|
||||
HAL_RVV_CVT(RVV_U8M2, RVV_U16M4, RVV_I16M4)
|
||||
HAL_RVV_CVT(RVV_U8M4, RVV_U16M8, RVV_I16M8)
|
||||
|
||||
HAL_RVV_CVT(RVV_U8M1, RVV_U32M4, RVV_I32M4)
|
||||
HAL_RVV_CVT(RVV_U8M2, RVV_U32M8, RVV_I32M8)
|
||||
|
||||
HAL_RVV_CVT(RVV_U8M1, RVV_U64M8, RVV_I64M8)
|
||||
|
||||
#undef HAL_RVV_CVT
|
||||
|
||||
// ---------------------------- Define Register Group Operations -------------------------------
|
||||
|
||||
#if defined(__clang__) && __clang_major__ <= 17
|
||||
#define HAL_RVV_GROUP(ONE, TWO, TYPE, ONE_LMUL, TWO_LMUL) \
|
||||
template <size_t idx> \
|
||||
inline ONE::VecType vget(TWO::VecType v) { \
|
||||
return __riscv_vget_v_##TYPE##TWO_LMUL##_##TYPE##ONE_LMUL(v, idx); \
|
||||
} \
|
||||
template <size_t idx> \
|
||||
inline void vset(TWO::VecType v, ONE::VecType val) { \
|
||||
__riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##TWO_LMUL(v, idx, val); \
|
||||
} \
|
||||
inline TWO::VecType vcreate(ONE::VecType v0, ONE::VecType v1) { \
|
||||
TWO::VecType v{}; \
|
||||
v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##TWO_LMUL(v, 0, v0); \
|
||||
v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##TWO_LMUL(v, 1, v1); \
|
||||
return v; \
|
||||
}
|
||||
#else
|
||||
#define HAL_RVV_GROUP(ONE, TWO, TYPE, ONE_LMUL, TWO_LMUL) \
|
||||
template <size_t idx> \
|
||||
inline ONE::VecType vget(TWO::VecType v) { \
|
||||
return __riscv_vget_v_##TYPE##TWO_LMUL##_##TYPE##ONE_LMUL(v, idx); \
|
||||
} \
|
||||
template <size_t idx> \
|
||||
inline void vset(TWO::VecType v, ONE::VecType val) { \
|
||||
__riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##TWO_LMUL(v, idx, val); \
|
||||
} \
|
||||
inline TWO::VecType vcreate(ONE::VecType v0, ONE::VecType v1) { \
|
||||
return __riscv_vcreate_v_##TYPE##ONE_LMUL##_##TYPE##TWO_LMUL(v0, v1); \
|
||||
}
|
||||
#endif
|
||||
|
||||
HAL_RVV_GROUP(RVV_I8M1, RVV_I8M2, i8, m1, m2)
|
||||
HAL_RVV_GROUP(RVV_I8M2, RVV_I8M4, i8, m2, m4)
|
||||
HAL_RVV_GROUP(RVV_I8M4, RVV_I8M8, i8, m4, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_I16M1, RVV_I16M2, i16, m1, m2)
|
||||
HAL_RVV_GROUP(RVV_I16M2, RVV_I16M4, i16, m2, m4)
|
||||
HAL_RVV_GROUP(RVV_I16M4, RVV_I16M8, i16, m4, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_I32M1, RVV_I32M2, i32, m1, m2)
|
||||
HAL_RVV_GROUP(RVV_I32M2, RVV_I32M4, i32, m2, m4)
|
||||
HAL_RVV_GROUP(RVV_I32M4, RVV_I32M8, i32, m4, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_I64M1, RVV_I64M2, i64, m1, m2)
|
||||
HAL_RVV_GROUP(RVV_I64M2, RVV_I64M4, i64, m2, m4)
|
||||
HAL_RVV_GROUP(RVV_I64M4, RVV_I64M8, i64, m4, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_U8M1, RVV_U8M2, u8, m1, m2)
|
||||
HAL_RVV_GROUP(RVV_U8M2, RVV_U8M4, u8, m2, m4)
|
||||
HAL_RVV_GROUP(RVV_U8M4, RVV_U8M8, u8, m4, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_U16M1, RVV_U16M2, u16, m1, m2)
|
||||
HAL_RVV_GROUP(RVV_U16M2, RVV_U16M4, u16, m2, m4)
|
||||
HAL_RVV_GROUP(RVV_U16M4, RVV_U16M8, u16, m4, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_U32M1, RVV_U32M2, u32, m1, m2)
|
||||
HAL_RVV_GROUP(RVV_U32M2, RVV_U32M4, u32, m2, m4)
|
||||
HAL_RVV_GROUP(RVV_U32M4, RVV_U32M8, u32, m4, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_U64M1, RVV_U64M2, u64, m1, m2)
|
||||
HAL_RVV_GROUP(RVV_U64M2, RVV_U64M4, u64, m2, m4)
|
||||
HAL_RVV_GROUP(RVV_U64M4, RVV_U64M8, u64, m4, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_F32M1, RVV_F32M2, f32, m1, m2)
|
||||
HAL_RVV_GROUP(RVV_F32M2, RVV_F32M4, f32, m2, m4)
|
||||
HAL_RVV_GROUP(RVV_F32M4, RVV_F32M8, f32, m4, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_F64M1, RVV_F64M2, f64, m1, m2)
|
||||
HAL_RVV_GROUP(RVV_F64M2, RVV_F64M4, f64, m2, m4)
|
||||
HAL_RVV_GROUP(RVV_F64M4, RVV_F64M8, f64, m4, m8)
|
||||
|
||||
#undef HAL_RVV_GROUP
|
||||
|
||||
#if defined(__clang__) && __clang_major__ <= 17
|
||||
#define HAL_RVV_GROUP(ONE, FOUR, TYPE, ONE_LMUL, FOUR_LMUL) \
|
||||
template <size_t idx> \
|
||||
inline ONE::VecType vget(FOUR::VecType v) { \
|
||||
return __riscv_vget_v_##TYPE##FOUR_LMUL##_##TYPE##ONE_LMUL(v, idx); \
|
||||
} \
|
||||
template <size_t idx> \
|
||||
inline void vset(FOUR::VecType v, ONE::VecType val) { \
|
||||
__riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##FOUR_LMUL(v, idx, val); \
|
||||
} \
|
||||
inline FOUR::VecType vcreate(ONE::VecType v0, ONE::VecType v1, ONE::VecType v2, ONE::VecType v3) { \
|
||||
FOUR::VecType v{}; \
|
||||
v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##FOUR_LMUL(v, 0, v0); \
|
||||
v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##FOUR_LMUL(v, 1, v1); \
|
||||
v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##FOUR_LMUL(v, 2, v2); \
|
||||
v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##FOUR_LMUL(v, 3, v3); \
|
||||
return v; \
|
||||
}
|
||||
#else
|
||||
#define HAL_RVV_GROUP(ONE, FOUR, TYPE, ONE_LMUL, FOUR_LMUL) \
|
||||
template <size_t idx> \
|
||||
inline ONE::VecType vget(FOUR::VecType v) { \
|
||||
return __riscv_vget_v_##TYPE##FOUR_LMUL##_##TYPE##ONE_LMUL(v, idx); \
|
||||
} \
|
||||
template <size_t idx> \
|
||||
inline void vset(FOUR::VecType v, ONE::VecType val) { \
|
||||
__riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##FOUR_LMUL(v, idx, val); \
|
||||
} \
|
||||
inline FOUR::VecType vcreate(ONE::VecType v0, ONE::VecType v1, ONE::VecType v2, ONE::VecType v3) { \
|
||||
return __riscv_vcreate_v_##TYPE##ONE_LMUL##_##TYPE##FOUR_LMUL(v0, v1, v2, v3); \
|
||||
}
|
||||
#endif
|
||||
|
||||
HAL_RVV_GROUP(RVV_I8M1, RVV_I8M4, i8, m1, m4)
|
||||
HAL_RVV_GROUP(RVV_I8M2, RVV_I8M8, i8, m2, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_U8M1, RVV_U8M4, u8, m1, m4)
|
||||
HAL_RVV_GROUP(RVV_U8M2, RVV_U8M8, u8, m2, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_I16M1, RVV_I16M4, i16, m1, m4)
|
||||
HAL_RVV_GROUP(RVV_I16M2, RVV_I16M8, i16, m2, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_U16M1, RVV_U16M4, u16, m1, m4)
|
||||
HAL_RVV_GROUP(RVV_U16M2, RVV_U16M8, u16, m2, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_I32M1, RVV_I32M4, i32, m1, m4)
|
||||
HAL_RVV_GROUP(RVV_I32M2, RVV_I32M8, i32, m2, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_U32M1, RVV_U32M4, u32, m1, m4)
|
||||
HAL_RVV_GROUP(RVV_U32M2, RVV_U32M8, u32, m2, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_I64M1, RVV_I64M4, i64, m1, m4)
|
||||
HAL_RVV_GROUP(RVV_I64M2, RVV_I64M8, i64, m2, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_U64M1, RVV_U64M4, u64, m1, m4)
|
||||
HAL_RVV_GROUP(RVV_U64M2, RVV_U64M8, u64, m2, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_F32M1, RVV_F32M4, f32, m1, m4)
|
||||
HAL_RVV_GROUP(RVV_F32M2, RVV_F32M8, f32, m2, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_F64M1, RVV_F64M4, f64, m1, m4)
|
||||
HAL_RVV_GROUP(RVV_F64M2, RVV_F64M8, f64, m2, m8)
|
||||
|
||||
#undef HAL_RVV_GROUP
|
||||
|
||||
#if defined(__clang__) && __clang_major__ <= 17
|
||||
#define HAL_RVV_GROUP(ONE, EIGHT, TYPE, ONE_LMUL, EIGHT_LMUL) \
|
||||
template <size_t idx> \
|
||||
inline ONE::VecType vget(EIGHT::VecType v) { \
|
||||
return __riscv_vget_v_##TYPE##EIGHT_LMUL##_##TYPE##ONE_LMUL(v, idx); \
|
||||
} \
|
||||
template <size_t idx> \
|
||||
inline void vset(EIGHT::VecType v, ONE::VecType val) { \
|
||||
__riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v, idx, val); \
|
||||
} \
|
||||
inline EIGHT::VecType vcreate(ONE::VecType v0, ONE::VecType v1, ONE::VecType v2, ONE::VecType v3, \
|
||||
ONE::VecType v4, ONE::VecType v5, ONE::VecType v6, ONE::VecType v7) { \
|
||||
EIGHT::VecType v{}; \
|
||||
v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v, 0, v0); \
|
||||
v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v, 1, v1); \
|
||||
v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v, 2, v2); \
|
||||
v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v, 3, v3); \
|
||||
v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v, 4, v4); \
|
||||
v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v, 5, v5); \
|
||||
v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v, 6, v6); \
|
||||
v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v, 7, v7); \
|
||||
return v; \
|
||||
}
|
||||
#else
|
||||
#define HAL_RVV_GROUP(ONE, EIGHT, TYPE, ONE_LMUL, EIGHT_LMUL) \
|
||||
template <size_t idx> \
|
||||
inline ONE::VecType vget(EIGHT::VecType v) { \
|
||||
return __riscv_vget_v_##TYPE##EIGHT_LMUL##_##TYPE##ONE_LMUL(v, idx); \
|
||||
} \
|
||||
template <size_t idx> \
|
||||
inline void vset(EIGHT::VecType v, ONE::VecType val) { \
|
||||
__riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v, idx, val); \
|
||||
} \
|
||||
inline EIGHT::VecType vcreate(ONE::VecType v0, ONE::VecType v1, ONE::VecType v2, ONE::VecType v3, \
|
||||
ONE::VecType v4, ONE::VecType v5, ONE::VecType v6, ONE::VecType v7) { \
|
||||
return __riscv_vcreate_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v0, v1, v2, v3, v4, v5, v6, v7); \
|
||||
}
|
||||
#endif
|
||||
|
||||
HAL_RVV_GROUP(RVV_I8M1, RVV_I8M8, i8, m1, m8)
|
||||
HAL_RVV_GROUP(RVV_U8M1, RVV_U8M8, u8, m1, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_I16M1, RVV_I16M8, i16, m1, m8)
|
||||
HAL_RVV_GROUP(RVV_U16M1, RVV_U16M8, u16, m1, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_I32M1, RVV_I32M8, i32, m1, m8)
|
||||
HAL_RVV_GROUP(RVV_U32M1, RVV_U32M8, u32, m1, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_I64M1, RVV_I64M8, i64, m1, m8)
|
||||
HAL_RVV_GROUP(RVV_U64M1, RVV_U64M8, u64, m1, m8)
|
||||
|
||||
HAL_RVV_GROUP(RVV_F32M1, RVV_F32M8, f32, m1, m8)
|
||||
HAL_RVV_GROUP(RVV_F64M1, RVV_F64M8, f64, m1, m8)
|
||||
|
||||
#undef HAL_RVV_GROUP
|
||||
|
||||
#endif // CV_HAL_RVV_1P0_ENABLED
|
||||
|
||||
}} // namespace cv::rvv_hal
|
||||
|
||||
#endif //OPENCV_RVV_HAL_TYPES_HPP
|
||||
Reference in New Issue
Block a user