mirror of
https://github.com/opencv/opencv.git
synced 2024-12-03 00:10:21 +08:00
533 lines
19 KiB
C++
533 lines
19 KiB
C++
// 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_NDSRVP_CORE_HPP
|
|
#define OPENCV_NDSRVP_CORE_HPP
|
|
|
|
namespace cv {
|
|
|
|
namespace ndsrvp {
|
|
|
|
template <typename srctype, typename dsttype,
|
|
typename vsrctype, typename vdsttype, int nlane,
|
|
template <typename src, typename dst> typename operators_t,
|
|
typename... params_t>
|
|
int elemwise_binop(const srctype* src1_data, size_t src1_step,
|
|
const srctype* src2_data, size_t src2_step,
|
|
dsttype* dst_data, size_t dst_step,
|
|
int width, int height, params_t... params)
|
|
{
|
|
src1_step /= sizeof(srctype);
|
|
src2_step /= sizeof(srctype);
|
|
dst_step /= sizeof(dsttype);
|
|
|
|
operators_t<srctype, dsttype> operators;
|
|
|
|
int i, j;
|
|
for (i = 0; i < height; ++i) {
|
|
const srctype* src1_row = src1_data + (src1_step * i);
|
|
const srctype* src2_row = src2_data + (src2_step * i);
|
|
dsttype* dst_row = dst_data + (dst_step * i);
|
|
|
|
j = 0;
|
|
for (; j + nlane <= width; j += nlane) {
|
|
register vsrctype vs1 = *(vsrctype*)(src1_row + j);
|
|
register vsrctype vs2 = *(vsrctype*)(src2_row + j);
|
|
|
|
*(vdsttype*)(dst_row + j) = operators.vector(vs1, vs2, params...);
|
|
}
|
|
for (; j < width; j++)
|
|
dst_row[j] = operators.scalar(src1_row[j], src2_row[j], params...);
|
|
}
|
|
|
|
return CV_HAL_ERROR_OK;
|
|
}
|
|
|
|
template <typename srctype, typename dsttype,
|
|
typename vsrctype, typename vdsttype, int nlane,
|
|
template <typename src, typename dst> typename operators_t,
|
|
typename... params_t>
|
|
int elemwise_unop(const srctype* src_data, size_t src_step,
|
|
dsttype* dst_data, size_t dst_step,
|
|
int width, int height, params_t... params)
|
|
{
|
|
src_step /= sizeof(srctype);
|
|
dst_step /= sizeof(dsttype);
|
|
|
|
operators_t<srctype, dsttype> operators;
|
|
|
|
int i, j;
|
|
for (i = 0; i < height; ++i) {
|
|
const srctype* src_row = src_data + (src_step * i);
|
|
dsttype* dst_row = dst_data + (dst_step * i);
|
|
|
|
j = 0;
|
|
for (; j + nlane <= width; j += nlane) {
|
|
register vsrctype vs = *(vsrctype*)(src_row + j);
|
|
|
|
*(vdsttype*)(dst_row + j) = operators.vector(vs, params...);
|
|
}
|
|
for (; j < width; j++)
|
|
dst_row[j] = operators.scalar(src_row[j], params...);
|
|
}
|
|
|
|
return CV_HAL_ERROR_OK;
|
|
}
|
|
|
|
// ################ add ################
|
|
|
|
template <typename src, typename dst>
|
|
struct operators_add_t {
|
|
inline uint8x8_t vector(uint8x8_t a, uint8x8_t b) { return __nds__v_ukadd8(a, b); }
|
|
inline uchar scalar(uchar a, uchar b) { return __nds__ukadd8(a, b); }
|
|
|
|
inline int8x8_t vector(int8x8_t a, int8x8_t b) { return __nds__v_kadd8(a, b); }
|
|
inline schar scalar(schar a, schar b) { return __nds__kadd8(a, b); }
|
|
|
|
inline uint16x4_t vector(uint16x4_t a, uint16x4_t b) { return __nds__v_ukadd16(a, b); }
|
|
inline ushort scalar(ushort a, ushort b) { return __nds__ukadd16(a, b); }
|
|
|
|
inline int16x4_t vector(int16x4_t a, int16x4_t b) { return __nds__v_kadd16(a, b); }
|
|
inline short scalar(short a, short b) { return __nds__kadd16(a, b); }
|
|
|
|
inline int32x2_t vector(int32x2_t a, int32x2_t b) { return __nds__v_kadd32(a, b); }
|
|
inline int scalar(int a, int b) { return __nds__kadd32(a, b); }
|
|
};
|
|
|
|
#undef cv_hal_add8u
|
|
#define cv_hal_add8u (cv::ndsrvp::elemwise_binop<uchar, uchar, uint8x8_t, uint8x8_t, 8, cv::ndsrvp::operators_add_t>)
|
|
|
|
#undef cv_hal_add8s
|
|
#define cv_hal_add8s (cv::ndsrvp::elemwise_binop<schar, schar, int8x8_t, int8x8_t, 8, cv::ndsrvp::operators_add_t>)
|
|
|
|
#undef cv_hal_add16u
|
|
#define cv_hal_add16u (cv::ndsrvp::elemwise_binop<ushort, ushort, uint16x4_t, uint16x4_t, 4, cv::ndsrvp::operators_add_t>)
|
|
|
|
#undef cv_hal_add16s
|
|
#define cv_hal_add16s (cv::ndsrvp::elemwise_binop<short, short, int16x4_t, int16x4_t, 4, cv::ndsrvp::operators_add_t>)
|
|
|
|
#undef cv_hal_add32s
|
|
#define cv_hal_add32s (cv::ndsrvp::elemwise_binop<int, int, int32x2_t, int32x2_t, 2, cv::ndsrvp::operators_add_t>)
|
|
|
|
// ################ sub ################
|
|
|
|
template <typename src, typename dst>
|
|
struct operators_sub_t {
|
|
inline uint8x8_t vector(uint8x8_t a, uint8x8_t b) { return __nds__v_uksub8(a, b); }
|
|
inline uchar scalar(uchar a, uchar b) { return __nds__uksub8(a, b); }
|
|
|
|
inline int8x8_t vector(int8x8_t a, int8x8_t b) { return __nds__v_ksub8(a, b); }
|
|
inline schar scalar(schar a, schar b) { return __nds__ksub8(a, b); }
|
|
|
|
inline uint16x4_t vector(uint16x4_t a, uint16x4_t b) { return __nds__v_uksub16(a, b); }
|
|
inline ushort scalar(ushort a, ushort b) { return __nds__uksub16(a, b); }
|
|
|
|
inline int16x4_t vector(int16x4_t a, int16x4_t b) { return __nds__v_ksub16(a, b); }
|
|
inline short scalar(short a, short b) { return __nds__ksub16(a, b); }
|
|
|
|
inline int32x2_t vector(int32x2_t a, int32x2_t b) { return __nds__v_ksub32(a, b); }
|
|
inline int scalar(int a, int b) { return __nds__ksub32(a, b); }
|
|
};
|
|
|
|
#undef cv_hal_sub8u
|
|
#define cv_hal_sub8u (cv::ndsrvp::elemwise_binop<uchar, uchar, uint8x8_t, uint8x8_t, 8, cv::ndsrvp::operators_sub_t>)
|
|
|
|
#undef cv_hal_sub8s
|
|
#define cv_hal_sub8s (cv::ndsrvp::elemwise_binop<schar, schar, int8x8_t, int8x8_t, 8, cv::ndsrvp::operators_sub_t>)
|
|
|
|
#undef cv_hal_sub16u
|
|
#define cv_hal_sub16u (cv::ndsrvp::elemwise_binop<ushort, ushort, uint16x4_t, uint16x4_t, 4, cv::ndsrvp::operators_sub_t>)
|
|
|
|
#undef cv_hal_sub16s
|
|
#define cv_hal_sub16s (cv::ndsrvp::elemwise_binop<short, short, int16x4_t, int16x4_t, 4, cv::ndsrvp::operators_sub_t>)
|
|
|
|
#undef cv_hal_sub32s
|
|
#define cv_hal_sub32s (cv::ndsrvp::elemwise_binop<int, int, int32x2_t, int32x2_t, 2, cv::ndsrvp::operators_sub_t>)
|
|
|
|
// ################ max ################
|
|
|
|
template <typename src, typename dst>
|
|
struct operators_max_t {
|
|
inline uint8x8_t vector(uint8x8_t a, uint8x8_t b) { return __nds__v_umax8(a, b); }
|
|
inline uchar scalar(uchar a, uchar b) { return __nds__umax8(a, b); }
|
|
|
|
inline int8x8_t vector(int8x8_t a, int8x8_t b) { return __nds__v_smax8(a, b); }
|
|
inline schar scalar(schar a, schar b) { return __nds__smax8(a, b); }
|
|
|
|
inline uint16x4_t vector(uint16x4_t a, uint16x4_t b) { return __nds__v_umax16(a, b); }
|
|
inline ushort scalar(ushort a, ushort b) { return __nds__umax16(a, b); }
|
|
|
|
inline int16x4_t vector(int16x4_t a, int16x4_t b) { return __nds__v_smax16(a, b); }
|
|
inline short scalar(short a, short b) { return __nds__smax16(a, b); }
|
|
|
|
inline int32x2_t vector(int32x2_t a, int32x2_t b) { return __nds__v_smax32(a, b); }
|
|
inline int scalar(int a, int b) { return __nds__smax32(a, b); }
|
|
};
|
|
|
|
#undef cv_hal_max8u
|
|
#define cv_hal_max8u (cv::ndsrvp::elemwise_binop<uchar, uchar, uint8x8_t, uint8x8_t, 8, cv::ndsrvp::operators_max_t>)
|
|
|
|
#undef cv_hal_max8s
|
|
#define cv_hal_max8s (cv::ndsrvp::elemwise_binop<schar, schar, int8x8_t, int8x8_t, 8, cv::ndsrvp::operators_max_t>)
|
|
|
|
#undef cv_hal_max16u
|
|
#define cv_hal_max16u (cv::ndsrvp::elemwise_binop<ushort, ushort, uint16x4_t, uint16x4_t, 4, cv::ndsrvp::operators_max_t>)
|
|
|
|
#undef cv_hal_max16s
|
|
#define cv_hal_max16s (cv::ndsrvp::elemwise_binop<short, short, int16x4_t, int16x4_t, 4, cv::ndsrvp::operators_max_t>)
|
|
|
|
#undef cv_hal_max32s
|
|
#define cv_hal_max32s (cv::ndsrvp::elemwise_binop<int, int, int32x2_t, int32x2_t, 2, cv::ndsrvp::operators_max_t>)
|
|
|
|
// ################ min ################
|
|
|
|
template <typename src, typename dst>
|
|
struct operators_min_t {
|
|
inline uint8x8_t vector(uint8x8_t a, uint8x8_t b) { return __nds__v_umin8(a, b); }
|
|
inline uchar scalar(uchar a, uchar b) { return __nds__umin8(a, b); }
|
|
|
|
inline int8x8_t vector(int8x8_t a, int8x8_t b) { return __nds__v_smin8(a, b); }
|
|
inline schar scalar(schar a, schar b) { return __nds__smin8(a, b); }
|
|
|
|
inline uint16x4_t vector(uint16x4_t a, uint16x4_t b) { return __nds__v_umin16(a, b); }
|
|
inline ushort scalar(ushort a, ushort b) { return __nds__umin16(a, b); }
|
|
|
|
inline int16x4_t vector(int16x4_t a, int16x4_t b) { return __nds__v_smin16(a, b); }
|
|
inline short scalar(short a, short b) { return __nds__smin16(a, b); }
|
|
|
|
inline int32x2_t vector(int32x2_t a, int32x2_t b) { return __nds__v_smin32(a, b); }
|
|
inline int scalar(int a, int b) { return __nds__smin32(a, b); }
|
|
};
|
|
|
|
#undef cv_hal_min8u
|
|
#define cv_hal_min8u (cv::ndsrvp::elemwise_binop<uchar, uchar, uint8x8_t, uint8x8_t, 8, cv::ndsrvp::operators_min_t>)
|
|
|
|
#undef cv_hal_min8s
|
|
#define cv_hal_min8s (cv::ndsrvp::elemwise_binop<schar, schar, int8x8_t, int8x8_t, 8, cv::ndsrvp::operators_min_t>)
|
|
|
|
#undef cv_hal_min16u
|
|
#define cv_hal_min16u (cv::ndsrvp::elemwise_binop<ushort, ushort, uint16x4_t, uint16x4_t, 4, cv::ndsrvp::operators_min_t>)
|
|
|
|
#undef cv_hal_min16s
|
|
#define cv_hal_min16s (cv::ndsrvp::elemwise_binop<short, short, int16x4_t, int16x4_t, 4, cv::ndsrvp::operators_min_t>)
|
|
|
|
#undef cv_hal_min32s
|
|
#define cv_hal_min32s (cv::ndsrvp::elemwise_binop<int, int, int32x2_t, int32x2_t, 2, cv::ndsrvp::operators_min_t>)
|
|
|
|
// ################ absdiff ################
|
|
|
|
template <typename src, typename dst>
|
|
struct operators_absdiff_t {
|
|
inline uint8x8_t vector(uint8x8_t a, uint8x8_t b) { return __nds__v_uksub8(__nds__v_umax8(a, b), __nds__v_umin8(a, b)); }
|
|
inline uchar scalar(uchar a, uchar b) { return __nds__uksub8(__nds__umax8(a, b), __nds__umin8(a, b)); }
|
|
|
|
inline int8x8_t vector(int8x8_t a, int8x8_t b) { return __nds__v_ksub8(__nds__v_smax8(a, b), __nds__v_smin8(a, b)); }
|
|
inline schar scalar(schar a, schar b) { return __nds__ksub8(__nds__smax8(a, b), __nds__smin8(a, b)); }
|
|
|
|
inline uint16x4_t vector(uint16x4_t a, uint16x4_t b) { return __nds__v_uksub16(__nds__v_umax16(a, b), __nds__v_umin16(a, b)); }
|
|
inline ushort scalar(ushort a, ushort b) { return __nds__uksub16(__nds__umax16(a, b), __nds__umin16(a, b)); }
|
|
|
|
inline int16x4_t vector(int16x4_t a, int16x4_t b) { return __nds__v_ksub16(__nds__v_smax16(a, b), __nds__v_smin16(a, b)); }
|
|
inline short scalar(short a, short b) { return __nds__ksub16(__nds__smax16(a, b), __nds__smin16(a, b)); }
|
|
|
|
inline int32x2_t vector(int32x2_t a, int32x2_t b) { return __nds__v_ksub32(__nds__v_smax32(a, b), __nds__v_smin32(a, b)); }
|
|
inline int scalar(int a, int b) { return __nds__ksub32(__nds__smax32(a, b), __nds__smin32(a, b)); }
|
|
};
|
|
|
|
#undef cv_hal_absdiff8u
|
|
#define cv_hal_absdiff8u (cv::ndsrvp::elemwise_binop<uchar, uchar, uint8x8_t, uint8x8_t, 8, cv::ndsrvp::operators_absdiff_t>)
|
|
|
|
#undef cv_hal_absdiff8s
|
|
#define cv_hal_absdiff8s (cv::ndsrvp::elemwise_binop<schar, schar, int8x8_t, int8x8_t, 8, cv::ndsrvp::operators_absdiff_t>)
|
|
|
|
#undef cv_hal_absdiff16u
|
|
#define cv_hal_absdiff16u (cv::ndsrvp::elemwise_binop<ushort, ushort, uint16x4_t, uint16x4_t, 4, cv::ndsrvp::operators_absdiff_t>)
|
|
|
|
#undef cv_hal_absdiff16s
|
|
#define cv_hal_absdiff16s (cv::ndsrvp::elemwise_binop<short, short, int16x4_t, int16x4_t, 4, cv::ndsrvp::operators_absdiff_t>)
|
|
|
|
#undef cv_hal_absdiff32s
|
|
#define cv_hal_absdiff32s (cv::ndsrvp::elemwise_binop<int, int, int32x2_t, int32x2_t, 2, cv::ndsrvp::operators_absdiff_t>)
|
|
|
|
// ################ bitwise ################
|
|
|
|
template <typename src, typename dst>
|
|
struct operators_and_t {
|
|
inline uint8x8_t vector(uint8x8_t a, uint8x8_t b) { return a & b; }
|
|
inline uchar scalar(uchar a, uchar b) { return a & b; }
|
|
};
|
|
|
|
#undef cv_hal_and8u
|
|
#define cv_hal_and8u (cv::ndsrvp::elemwise_binop<uchar, uchar, uint8x8_t, uint8x8_t, 8, cv::ndsrvp::operators_and_t>)
|
|
|
|
template <typename src, typename dst>
|
|
struct operators_or_t {
|
|
inline uint8x8_t vector(uint8x8_t a, uint8x8_t b) { return a | b; }
|
|
inline uchar scalar(uchar a, uchar b) { return a | b; }
|
|
};
|
|
|
|
#undef cv_hal_or8u
|
|
#define cv_hal_or8u (cv::ndsrvp::elemwise_binop<uchar, uchar, uint8x8_t, uint8x8_t, 8, cv::ndsrvp::operators_or_t>)
|
|
|
|
template <typename src, typename dst>
|
|
struct operators_xor_t {
|
|
inline uint8x8_t vector(uint8x8_t a, uint8x8_t b) { return a ^ b; }
|
|
inline uchar scalar(uchar a, uchar b) { return a ^ b; }
|
|
};
|
|
|
|
#undef cv_hal_xor8u
|
|
#define cv_hal_xor8u (cv::ndsrvp::elemwise_binop<uchar, uchar, uint8x8_t, uint8x8_t, 8, cv::ndsrvp::operators_xor_t>)
|
|
|
|
template <typename src, typename dst>
|
|
struct operators_not_t {
|
|
inline uint8x8_t vector(uint8x8_t a) { return ~a; }
|
|
inline uchar scalar(uchar a) { return ~a; }
|
|
};
|
|
|
|
#undef cv_hal_not8u
|
|
#define cv_hal_not8u (cv::ndsrvp::elemwise_unop<uchar, uchar, uint8x8_t, uint8x8_t, 8, cv::ndsrvp::operators_not_t>)
|
|
|
|
// ################ cmp ################
|
|
|
|
template <typename src, typename dst>
|
|
struct operators_cmp_t {
|
|
inline uint8x8_t vector(uint8x8_t a, uint8x8_t b, int operation)
|
|
{
|
|
switch (operation) {
|
|
case CV_HAL_CMP_EQ:
|
|
return __nds__v_ucmpeq8(a, b);
|
|
case CV_HAL_CMP_GT:
|
|
return __nds__v_ucmplt8(b, a);
|
|
case CV_HAL_CMP_GE:
|
|
return __nds__v_ucmple8(b, a);
|
|
case CV_HAL_CMP_LT:
|
|
return __nds__v_ucmplt8(a, b);
|
|
case CV_HAL_CMP_LE:
|
|
return __nds__v_ucmple8(a, b);
|
|
case CV_HAL_CMP_NE:
|
|
return ~__nds__v_ucmpeq8(a, b);
|
|
default:
|
|
return uint8x8_t();
|
|
}
|
|
}
|
|
inline uchar scalar(uchar a, uchar b, int operation)
|
|
{
|
|
switch (operation) {
|
|
case CV_HAL_CMP_EQ:
|
|
return __nds__cmpeq8(a, b);
|
|
case CV_HAL_CMP_GT:
|
|
return __nds__ucmplt8(b, a);
|
|
case CV_HAL_CMP_GE:
|
|
return __nds__ucmple8(b, a);
|
|
case CV_HAL_CMP_LT:
|
|
return __nds__ucmplt8(a, b);
|
|
case CV_HAL_CMP_LE:
|
|
return __nds__ucmple8(a, b);
|
|
case CV_HAL_CMP_NE:
|
|
return ~__nds__cmpeq8(a, b);
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
inline uint8x8_t vector(int8x8_t a, int8x8_t b, int operation)
|
|
{
|
|
switch (operation) {
|
|
case CV_HAL_CMP_EQ:
|
|
return __nds__v_scmpeq8(a, b);
|
|
case CV_HAL_CMP_GT:
|
|
return __nds__v_scmplt8(b, a);
|
|
case CV_HAL_CMP_GE:
|
|
return __nds__v_scmple8(b, a);
|
|
case CV_HAL_CMP_LT:
|
|
return __nds__v_scmplt8(a, b);
|
|
case CV_HAL_CMP_LE:
|
|
return __nds__v_scmple8(a, b);
|
|
case CV_HAL_CMP_NE:
|
|
return ~__nds__v_scmpeq8(a, b);
|
|
default:
|
|
return uint8x8_t();
|
|
}
|
|
}
|
|
inline uchar scalar(schar a, schar b, int operation)
|
|
{
|
|
switch (operation) {
|
|
case CV_HAL_CMP_EQ:
|
|
return __nds__cmpeq8(a, b);
|
|
case CV_HAL_CMP_GT:
|
|
return __nds__scmplt8(b, a);
|
|
case CV_HAL_CMP_GE:
|
|
return __nds__scmple8(b, a);
|
|
case CV_HAL_CMP_LT:
|
|
return __nds__scmplt8(a, b);
|
|
case CV_HAL_CMP_LE:
|
|
return __nds__scmple8(a, b);
|
|
case CV_HAL_CMP_NE:
|
|
return ~__nds__cmpeq8(a, b);
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
inline uint8x4_t vector(uint16x4_t a, uint16x4_t b, int operation)
|
|
{
|
|
register unsigned long cmp;
|
|
switch (operation) {
|
|
case CV_HAL_CMP_EQ:
|
|
cmp = (unsigned long)__nds__v_ucmpeq16(a, b) >> 8;
|
|
break;
|
|
case CV_HAL_CMP_GT:
|
|
cmp = (unsigned long)__nds__v_ucmplt16(b, a) >> 8;
|
|
break;
|
|
case CV_HAL_CMP_GE:
|
|
cmp = (unsigned long)__nds__v_ucmple16(b, a) >> 8;
|
|
break;
|
|
case CV_HAL_CMP_LT:
|
|
cmp = (unsigned long)__nds__v_ucmplt16(a, b) >> 8;
|
|
break;
|
|
case CV_HAL_CMP_LE:
|
|
cmp = (unsigned long)__nds__v_ucmple16(a, b) >> 8;
|
|
break;
|
|
case CV_HAL_CMP_NE:
|
|
cmp = ~(unsigned long)__nds__v_ucmpeq16(a, b) >> 8;
|
|
break;
|
|
default:
|
|
return uint8x4_t();
|
|
}
|
|
return (uint8x4_t)(unsigned int)__nds__pkbb16(cmp >> 32, cmp);
|
|
}
|
|
inline uchar scalar(ushort a, ushort b, int operation)
|
|
{
|
|
switch (operation) {
|
|
case CV_HAL_CMP_EQ:
|
|
return __nds__cmpeq16(a, b);
|
|
case CV_HAL_CMP_GT:
|
|
return __nds__ucmplt16(b, a);
|
|
case CV_HAL_CMP_GE:
|
|
return __nds__ucmple16(b, a);
|
|
case CV_HAL_CMP_LT:
|
|
return __nds__ucmplt16(a, b);
|
|
case CV_HAL_CMP_LE:
|
|
return __nds__ucmple16(a, b);
|
|
case CV_HAL_CMP_NE:
|
|
return ~__nds__cmpeq16(a, b);
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
inline uint8x4_t vector(int16x4_t a, int16x4_t b, int operation)
|
|
{
|
|
register unsigned long cmp;
|
|
switch (operation) {
|
|
case CV_HAL_CMP_EQ:
|
|
cmp = (unsigned long)__nds__v_scmpeq16(a, b) >> 8;
|
|
break;
|
|
case CV_HAL_CMP_GT:
|
|
cmp = (unsigned long)__nds__v_scmplt16(b, a) >> 8;
|
|
break;
|
|
case CV_HAL_CMP_GE:
|
|
cmp = (unsigned long)__nds__v_scmple16(b, a) >> 8;
|
|
break;
|
|
case CV_HAL_CMP_LT:
|
|
cmp = (unsigned long)__nds__v_scmplt16(a, b) >> 8;
|
|
break;
|
|
case CV_HAL_CMP_LE:
|
|
cmp = (unsigned long)__nds__v_scmple16(a, b) >> 8;
|
|
break;
|
|
case CV_HAL_CMP_NE:
|
|
cmp = ~(unsigned long)__nds__v_scmpeq16(a, b) >> 8;
|
|
break;
|
|
default:
|
|
return uint8x4_t();
|
|
}
|
|
return (uint8x4_t)(unsigned int)__nds__pkbb16(cmp >> 32, cmp);
|
|
}
|
|
inline uchar scalar(short a, short b, int operation)
|
|
{
|
|
switch (operation) {
|
|
case CV_HAL_CMP_EQ:
|
|
return __nds__cmpeq16(a, b);
|
|
case CV_HAL_CMP_GT:
|
|
return __nds__scmplt16(b, a);
|
|
case CV_HAL_CMP_GE:
|
|
return __nds__scmple16(b, a);
|
|
case CV_HAL_CMP_LT:
|
|
return __nds__scmplt16(a, b);
|
|
case CV_HAL_CMP_LE:
|
|
return __nds__scmple16(a, b);
|
|
case CV_HAL_CMP_NE:
|
|
return ~__nds__cmpeq16(a, b);
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
};
|
|
|
|
#undef cv_hal_cmp8u
|
|
#define cv_hal_cmp8u (cv::ndsrvp::elemwise_binop<uchar, uchar, uint8x8_t, uint8x8_t, 8, cv::ndsrvp::operators_cmp_t>)
|
|
|
|
#undef cv_hal_cmp8s
|
|
#define cv_hal_cmp8s (cv::ndsrvp::elemwise_binop<schar, uchar, int8x8_t, uint8x8_t, 8, cv::ndsrvp::operators_cmp_t>)
|
|
|
|
#undef cv_hal_cmp16u
|
|
#define cv_hal_cmp16u (cv::ndsrvp::elemwise_binop<ushort, uchar, uint16x4_t, uint8x4_t, 4, cv::ndsrvp::operators_cmp_t>)
|
|
|
|
#undef cv_hal_cmp16s
|
|
#define cv_hal_cmp16s (cv::ndsrvp::elemwise_binop<short, uchar, int16x4_t, uint8x4_t, 4, cv::ndsrvp::operators_cmp_t>)
|
|
|
|
// ################ split ################
|
|
|
|
/*template <typename srctype, typename vsrctype, int nlane>
|
|
int split(const srctype* src_data, srctype** dst_data, int len, int cn)
|
|
{
|
|
int i, j;
|
|
for (i = 0; i < len; i++) {
|
|
for (j = 0; j < cn; j++) {
|
|
dst_data[j][i] = src_data[i * cn + j];
|
|
}
|
|
}
|
|
|
|
return CV_HAL_ERROR_OK;
|
|
}
|
|
|
|
#undef cv_hal_split8u
|
|
#define cv_hal_split8u (cv::ndsrvp::split<uchar, uint8x8_t, 8>)
|
|
|
|
#undef cv_hal_split16u
|
|
#define cv_hal_split16u (cv::ndsrvp::split<ushort, uint16x4_t, 4>)
|
|
|
|
#undef cv_hal_split32s
|
|
#define cv_hal_split32s (cv::ndsrvp::split<int, int32x2_t, 2>)*/
|
|
|
|
// ################ merge ################
|
|
|
|
/*template <typename srctype, typename vsrctype, int nlane>
|
|
int merge(const srctype** src_data, srctype* dst_data, int len, int cn)
|
|
{
|
|
int i, j;
|
|
for (i = 0; i < len; i++) {
|
|
for (j = 0; j < cn; j++) {
|
|
dst_data[i * cn + j] = src_data[j][i];
|
|
}
|
|
}
|
|
|
|
return CV_HAL_ERROR_OK;
|
|
}
|
|
|
|
#undef cv_hal_merge8u
|
|
#define cv_hal_merge8u (cv::ndsrvp::merge<uchar, uint8x8_t, 8>)
|
|
|
|
#undef cv_hal_merge16u
|
|
#define cv_hal_merge16u (cv::ndsrvp::merge<ushort, uint16x4_t, 4>)
|
|
|
|
#undef cv_hal_merge32s
|
|
#define cv_hal_merge32s (cv::ndsrvp::merge<int, int32x2_t, 2>)*/
|
|
|
|
} // namespace ndsrvp
|
|
|
|
} // namespace cv
|
|
|
|
#endif
|