Chiebot-Mirror
/
opencv
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

core: avoid function type cast, make happy UBSAN

Browse Source 
backporting of commit: d3d13c41c4
pull/14784/head
Alexander Alekhin 6 years ago
parent b3e6c97d98
commit f8791f072d
3 changed files with 45 additions and 37 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      modules/core/src/convert.dispatch.cpp
  2. 64
      modules/core/src/convert.simd.hpp
  3. 14
      modules/core/src/convert_scale.simd.hpp

4
modules/core/src/convert.dispatch.cpp
Unescape View File

@ -228,12 +228,12 @@ void convertFp16(InputArray _src, OutputArray _dst)
} }
else else
ddepth = CV_16S; ddepth = CV_16S;
func = (BinaryFunc)get_cvt32f16f(); func = get_cvt32f16f();
break; break;
case CV_16S: case CV_16S:
//case CV_16F: //case CV_16F:
ddepth = CV_32F; ddepth = CV_32F;
func = (BinaryFunc)get_cvt16f32f(); func = get_cvt16f32f();
break; break;
default: default:
CV_Error(Error::StsUnsupportedFormat, "Unsupported input depth"); CV_Error(Error::StsUnsupportedFormat, "Unsupported input depth");

64
modules/core/src/convert.simd.hpp
Unescape View File

@ -144,10 +144,12 @@ static void cvtCopy( const uchar* src, size_t sstep,
} }
#define DEF_CVT_FUNC(suffix, cvtfunc, _Ts, _Td, _Twvec) \ #define DEF_CVT_FUNC(suffix, cvtfunc, _Ts, _Td, _Twvec) \
static void cvt##suffix(const _Ts* src, size_t sstep, uchar*, size_t, \ static void cvt##suffix(const uchar* src_, size_t sstep, const uchar*, size_t, \
_Td* dst, size_t dstep, Size size, void*) \ uchar* dst_, size_t dstep, Size size, void*) \
{ \ { \
CV_INSTRUMENT_REGION(); \ CV_INSTRUMENT_REGION(); \
const _Ts* src = (const _Ts*)src_; \
_Td* dst = (_Td*)dst_; \
cvtfunc<_Ts, _Td, _Twvec>(src, sstep, dst, dstep, size); \ cvtfunc<_Ts, _Td, _Twvec>(src, sstep, dst, dstep, size); \
} }
@ -233,16 +235,16 @@ DEF_CVT_FUNC(16f32f, cvt1_, float16_t, float, v_float32)
///////////// "conversion" w/o conversion /////////////// ///////////// "conversion" w/o conversion ///////////////
static void cvt8u(const uchar* src, size_t sstep, uchar*, size_t, uchar* dst, size_t dstep, Size size, void*) static void cvt8u(const uchar* src, size_t sstep, const uchar*, size_t, uchar* dst, size_t dstep, Size size, void*)
{ CV_INSTRUMENT_REGION(); cvtCopy(src, sstep, dst, dstep, size, 1); } { CV_INSTRUMENT_REGION(); cvtCopy(src, sstep, dst, dstep, size, 1); }
static void cvt16u(const ushort* src, size_t sstep, uchar*, size_t, ushort* dst, size_t dstep, Size size, void*) static void cvt16u(const uchar* src, size_t sstep, const uchar*, size_t, uchar* dst, size_t dstep, Size size, void*)
{ CV_INSTRUMENT_REGION(); cvtCopy((const uchar*)src, sstep, (uchar*)dst, dstep, size, 2); } { CV_INSTRUMENT_REGION(); cvtCopy((const uchar*)src, sstep, (uchar*)dst, dstep, size, 2); }
static void cvt32s(const int* src, size_t sstep, uchar*, size_t, int* dst, size_t dstep, Size size, void*) static void cvt32s(const uchar* src, size_t sstep, const uchar*, size_t, uchar* dst, size_t dstep, Size size, void*)
{ CV_INSTRUMENT_REGION(); cvtCopy((const uchar*)src, sstep, (uchar*)dst, dstep, size, 4); } { CV_INSTRUMENT_REGION(); cvtCopy((const uchar*)src, sstep, (uchar*)dst, dstep, size, 4); }
static void cvt64s(const int64* src, size_t sstep, uchar*, size_t, int64* dst, size_t dstep, Size size, void*) static void cvt64s(const uchar* src, size_t sstep, const uchar*, size_t, uchar* dst, size_t dstep, Size size, void*)
{ CV_INSTRUMENT_REGION(); cvtCopy((const uchar*)src, sstep, (uchar*)dst, dstep, size, 8); } { CV_INSTRUMENT_REGION(); cvtCopy((const uchar*)src, sstep, (uchar*)dst, dstep, size, 8); }
@ -346,44 +348,44 @@ BinaryFunc getConvertFunc(int sdepth, int ddepth)
static BinaryFunc cvtTab[][8] = static BinaryFunc cvtTab[][8] =
{ {
{ {
(BinaryFunc)(cvt8u), (BinaryFunc)GET_OPTIMIZED(cvt8s8u), (BinaryFunc)GET_OPTIMIZED(cvt16u8u), (cvt8u), (cvt8s8u), (cvt16u8u),
(BinaryFunc)GET_OPTIMIZED(cvt16s8u), (BinaryFunc)GET_OPTIMIZED(cvt32s8u), (BinaryFunc)GET_OPTIMIZED(cvt32f8u), (cvt16s8u), (cvt32s8u), (cvt32f8u),
(BinaryFunc)GET_OPTIMIZED(cvt64f8u), 0 //(BinaryFunc)(cvt16f8u) (cvt64f8u), 0 //(cvt16f8u)
}, },
{ {
(BinaryFunc)GET_OPTIMIZED(cvt8u8s), (BinaryFunc)cvt8u, (BinaryFunc)GET_OPTIMIZED(cvt16u8s), (cvt8u8s), cvt8u, (cvt16u8s),
(BinaryFunc)GET_OPTIMIZED(cvt16s8s), (BinaryFunc)GET_OPTIMIZED(cvt32s8s), (BinaryFunc)GET_OPTIMIZED(cvt32f8s), (cvt16s8s), (cvt32s8s), (cvt32f8s),
(BinaryFunc)GET_OPTIMIZED(cvt64f8s), 0 //(BinaryFunc)(cvt16f8s) (cvt64f8s), 0 //(cvt16f8s)
}, },
{ {
(BinaryFunc)GET_OPTIMIZED(cvt8u16u), (BinaryFunc)GET_OPTIMIZED(cvt8s16u), (BinaryFunc)cvt16u, (cvt8u16u), (cvt8s16u), cvt16u,
(BinaryFunc)GET_OPTIMIZED(cvt16s16u), (BinaryFunc)GET_OPTIMIZED(cvt32s16u), (BinaryFunc)GET_OPTIMIZED(cvt32f16u), (cvt16s16u), (cvt32s16u), (cvt32f16u),
(BinaryFunc)GET_OPTIMIZED(cvt64f16u), 0 //(BinaryFunc)(cvt16f16u) (cvt64f16u), 0 //(cvt16f16u)
}, },
{ {
(BinaryFunc)GET_OPTIMIZED(cvt8u16s), (BinaryFunc)GET_OPTIMIZED(cvt8s16s), (BinaryFunc)GET_OPTIMIZED(cvt16u16s), (cvt8u16s), (cvt8s16s), (cvt16u16s),
(BinaryFunc)cvt16u, (BinaryFunc)GET_OPTIMIZED(cvt32s16s), (BinaryFunc)GET_OPTIMIZED(cvt32f16s), cvt16u, (cvt32s16s), (cvt32f16s),
(BinaryFunc)GET_OPTIMIZED(cvt64f16s), 0 //(BinaryFunc)(cvt16f16s) (cvt64f16s), 0 //(cvt16f16s)
}, },
{ {
(BinaryFunc)GET_OPTIMIZED(cvt8u32s), (BinaryFunc)GET_OPTIMIZED(cvt8s32s), (BinaryFunc)GET_OPTIMIZED(cvt16u32s), (cvt8u32s), (cvt8s32s), (cvt16u32s),
(BinaryFunc)GET_OPTIMIZED(cvt16s32s), (BinaryFunc)cvt32s, (BinaryFunc)GET_OPTIMIZED(cvt32f32s), (cvt16s32s), cvt32s, (cvt32f32s),
(BinaryFunc)GET_OPTIMIZED(cvt64f32s), 0 //(BinaryFunc)(cvt16f32s) (cvt64f32s), 0 //(cvt16f32s)
}, },
{ {
(BinaryFunc)GET_OPTIMIZED(cvt8u32f), (BinaryFunc)GET_OPTIMIZED(cvt8s32f), (BinaryFunc)GET_OPTIMIZED(cvt16u32f), (cvt8u32f), (cvt8s32f), (cvt16u32f),
(BinaryFunc)GET_OPTIMIZED(cvt16s32f), (BinaryFunc)GET_OPTIMIZED(cvt32s32f), (BinaryFunc)cvt32s, (cvt16s32f), (cvt32s32f), cvt32s,
(BinaryFunc)GET_OPTIMIZED(cvt64f32f), 0 //(BinaryFunc)(cvt16f32f) (cvt64f32f), 0 //(cvt16f32f)
}, },
{ {
(BinaryFunc)GET_OPTIMIZED(cvt8u64f), (BinaryFunc)GET_OPTIMIZED(cvt8s64f), (BinaryFunc)GET_OPTIMIZED(cvt16u64f), (cvt8u64f), (cvt8s64f), (cvt16u64f),
(BinaryFunc)GET_OPTIMIZED(cvt16s64f), (BinaryFunc)GET_OPTIMIZED(cvt32s64f), (BinaryFunc)GET_OPTIMIZED(cvt32f64f), (cvt16s64f), (cvt32s64f), (cvt32f64f),
(BinaryFunc)(cvt64s), 0 //(BinaryFunc)(cvt16f64f) (cvt64s), 0 //(cvt16f64f)
}, },
{ {
0, 0, 0, 0, 0, 0, 0, 0 0, 0, 0, 0, 0, 0, 0, 0
//(BinaryFunc)(cvt8u16f), (BinaryFunc)(cvt8s16f), (BinaryFunc)(cvt16u16f), (BinaryFunc)(cvt16s16f), //(cvt8u16f), (cvt8s16f), (cvt16u16f), (cvt16s16f),
//(BinaryFunc)(cvt32s16f), (BinaryFunc)(cvt32f16f), (BinaryFunc)(cvt64f16f), (BinaryFunc)(cvt16u) //(cvt32s16f), (cvt32f16f), (cvt64f16f), (cvt16u)
} }
}; };
return cvtTab[CV_MAT_DEPTH(ddepth)][CV_MAT_DEPTH(sdepth)]; return cvtTab[CV_MAT_DEPTH(ddepth)][CV_MAT_DEPTH(sdepth)];
@ -391,12 +393,12 @@ BinaryFunc getConvertFunc(int sdepth, int ddepth)
BinaryFunc get_cvt32f16f() BinaryFunc get_cvt32f16f()
{ {
return (BinaryFunc)cvt32f16f; return cvt32f16f;
} }
BinaryFunc get_cvt16f32f() BinaryFunc get_cvt16f32f()
{ {
return (BinaryFunc)cvt16f32f; return cvt16f32f;
} }
#endif #endif

14
modules/core/src/convert_scale.simd.hpp
Unescape View File

@ -197,17 +197,23 @@ cvt_64f( const _Ts* src, size_t sstep, _Td* dst, size_t dstep,
//================================================================================================== //==================================================================================================
#define DEF_CVT_SCALE_ABS_FUNC(suffix, cvt, stype, dtype, wtype) \ #define DEF_CVT_SCALE_ABS_FUNC(suffix, cvt, stype, dtype, wtype) \
static void cvtScaleAbs##suffix( const stype* src, size_t sstep, const uchar*, size_t, \ static void cvtScaleAbs##suffix( const uchar* src_, size_t sstep, const uchar*, size_t, \
dtype* dst, size_t dstep, Size size, double* scale) \ uchar* dst_, size_t dstep, Size size, void* scale_) \
{ \ { \
const stype* src = (const stype*)src_; \
dtype* dst = (dtype*)dst_; \
double* scale = (double*)scale_; \
cvt(src, sstep, dst, dstep, size, (wtype)scale[0], (wtype)scale[1]); \ cvt(src, sstep, dst, dstep, size, (wtype)scale[0], (wtype)scale[1]); \
} }
#define DEF_CVT_SCALE_FUNC(suffix, cvt, stype, dtype, wtype) \ #define DEF_CVT_SCALE_FUNC(suffix, cvt, stype, dtype, wtype) \
static void cvtScale##suffix( const stype* src, size_t sstep, const uchar*, size_t, \ static void cvtScale##suffix( const uchar* src_, size_t sstep, const uchar*, size_t, \
dtype* dst, size_t dstep, Size size, double* scale) \ uchar* dst_, size_t dstep, Size size, void* scale_) \
{ \ { \
const stype* src = (const stype*)src_; \
dtype* dst = (dtype*)dst_; \
double* scale = (double*)scale_; \
cvt(src, sstep, dst, dstep, size, (wtype)scale[0], (wtype)scale[1]); \ cvt(src, sstep, dst, dstep, size, (wtype)scale[0], (wtype)scale[1]); \
} }

Write Preview
Loading…
Cancel
Save