Merge pull request #25598 from asmorkalov:as/tables_range_check_core

asmorkalov · web-flow · commit 00440477826a · 2024-05-17T10:48:40.000+03:00
Check range for type-dependant function tables #25598 Address #24703 ### Pull Request Readiness Checklist See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request - [x] I agree to contribute to the project under Apache 2 License. - [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV - [x] The PR is proposed to the proper branch - [x] There is a reference to the original bug report and related work - [ ] There is accuracy test, performance test and test data in opencv_extra repository, if applicable Patch to opencv_extra has the same branch name. - [ ] The feature is well documented and sample code can be built with the project CMake
diff --git a/modules/core/src/arithm.cpp b/modules/core/src/arithm.cpp
@@ -329,7 +329,7 @@ static void binary_op( InputArray _src1, InputArray _src2, OutputArray _dst,
 
 static BinaryFuncC* getMaxTab()
 {
-    static BinaryFuncC maxTab[] =
+    static BinaryFuncC maxTab[CV_DEPTH_MAX] =
     {
         (BinaryFuncC)GET_OPTIMIZED(cv::hal::max8u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::max8s),
         (BinaryFuncC)GET_OPTIMIZED(cv::hal::max16u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::max16s),
@@ -343,7 +343,7 @@ static BinaryFuncC* getMaxTab()
 
 static BinaryFuncC* getMinTab()
 {
-    static BinaryFuncC minTab[] =
+    static BinaryFuncC minTab[CV_DEPTH_MAX] =
     {
         (BinaryFuncC)GET_OPTIMIZED(cv::hal::min8u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::min8s),
         (BinaryFuncC)GET_OPTIMIZED(cv::hal::min16u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::min16s),
@@ -617,7 +617,9 @@ static void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
 
         Mat src1 = psrc1->getMat(), src2 = psrc2->getMat(), dst = _dst.getMat();
         Size sz = getContinuousSize2D(src1, src2, dst, src1.channels());
-        tab[depth1](src1.ptr(), src1.step, src2.ptr(), src2.step, dst.ptr(), dst.step, sz.width, sz.height, usrdata);
+        BinaryFuncC func = tab[depth1];
+        CV_Assert(func);
+        func(src1.ptr(), src1.step, src2.ptr(), src2.step, dst.ptr(), dst.step, sz.width, sz.height, usrdata);
         return;
     }
 
@@ -868,7 +870,7 @@ static void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
 
 static BinaryFuncC* getAddTab()
 {
-    static BinaryFuncC addTab[] =
+    static BinaryFuncC addTab[CV_DEPTH_MAX] =
     {
         (BinaryFuncC)GET_OPTIMIZED(cv::hal::add8u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::add8s),
         (BinaryFuncC)GET_OPTIMIZED(cv::hal::add16u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::add16s),
@@ -882,7 +884,7 @@ static BinaryFuncC* getAddTab()
 
 static BinaryFuncC* getSubTab()
 {
-    static BinaryFuncC subTab[] =
+    static BinaryFuncC subTab[CV_DEPTH_MAX] =
     {
         (BinaryFuncC)GET_OPTIMIZED(cv::hal::sub8u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::sub8s),
         (BinaryFuncC)GET_OPTIMIZED(cv::hal::sub16u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::sub16s),
@@ -896,7 +898,7 @@ static BinaryFuncC* getSubTab()
 
 static BinaryFuncC* getAbsDiffTab()
 {
-    static BinaryFuncC absDiffTab[] =
+    static BinaryFuncC absDiffTab[CV_DEPTH_MAX] =
     {
         (BinaryFuncC)GET_OPTIMIZED(cv::hal::absdiff8u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::absdiff8s),
         (BinaryFuncC)GET_OPTIMIZED(cv::hal::absdiff16u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::absdiff16s),
@@ -949,7 +951,7 @@ namespace cv
 
 static BinaryFuncC* getMulTab()
 {
-    static BinaryFuncC mulTab[] =
+    static BinaryFuncC mulTab[CV_DEPTH_MAX] =
     {
         (BinaryFuncC)cv::hal::mul8u, (BinaryFuncC)cv::hal::mul8s, (BinaryFuncC)cv::hal::mul16u,
         (BinaryFuncC)cv::hal::mul16s, (BinaryFuncC)cv::hal::mul32s, (BinaryFuncC)cv::hal::mul32f,
@@ -961,7 +963,7 @@ static BinaryFuncC* getMulTab()
 
 static BinaryFuncC* getDivTab()
 {
-    static BinaryFuncC divTab[] =
+    static BinaryFuncC divTab[CV_DEPTH_MAX] =
     {
         (BinaryFuncC)cv::hal::div8u, (BinaryFuncC)cv::hal::div8s, (BinaryFuncC)cv::hal::div16u,
         (BinaryFuncC)cv::hal::div16s, (BinaryFuncC)cv::hal::div32s, (BinaryFuncC)cv::hal::div32f,
@@ -973,7 +975,7 @@ static BinaryFuncC* getDivTab()
 
 static BinaryFuncC* getRecipTab()
 {
-    static BinaryFuncC recipTab[] =
+    static BinaryFuncC recipTab[CV_DEPTH_MAX] =
     {
         (BinaryFuncC)cv::hal::recip8u, (BinaryFuncC)cv::hal::recip8s, (BinaryFuncC)cv::hal::recip16u,
         (BinaryFuncC)cv::hal::recip16s, (BinaryFuncC)cv::hal::recip32s, (BinaryFuncC)cv::hal::recip32f,
@@ -1021,7 +1023,7 @@ UMat UMat::mul(InputArray m, double scale) const
 
 static BinaryFuncC* getAddWeightedTab()
 {
-    static BinaryFuncC addWeightedTab[] =
+    static BinaryFuncC addWeightedTab[CV_DEPTH_MAX] =
     {
         (BinaryFuncC)GET_OPTIMIZED(cv::hal::addWeighted8u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::addWeighted8s), (BinaryFuncC)GET_OPTIMIZED(cv::hal::addWeighted16u),
         (BinaryFuncC)GET_OPTIMIZED(cv::hal::addWeighted16s), (BinaryFuncC)GET_OPTIMIZED(cv::hal::addWeighted32s), (BinaryFuncC)cv::hal::addWeighted32f,
@@ -1052,7 +1054,7 @@ namespace cv
 
 static BinaryFuncC getCmpFunc(int depth)
 {
-    static BinaryFuncC cmpTab[] =
+    static BinaryFuncC cmpTab[CV_DEPTH_MAX] =
     {
         (BinaryFuncC)GET_OPTIMIZED(cv::hal::cmp8u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::cmp8s),
         (BinaryFuncC)GET_OPTIMIZED(cv::hal::cmp16u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::cmp16s),
@@ -1588,7 +1590,7 @@ typedef void (*InRangeFunc)( const uchar* src1, size_t step1, const uchar* src2,
 
 static InRangeFunc getInRangeFunc(int depth)
 {
-    static InRangeFunc inRangeTab[] =
+    static InRangeFunc inRangeTab[CV_DEPTH_MAX] =
     {
         (InRangeFunc)GET_OPTIMIZED(inRange8u), (InRangeFunc)GET_OPTIMIZED(inRange8s), (InRangeFunc)GET_OPTIMIZED(inRange16u),
         (InRangeFunc)GET_OPTIMIZED(inRange16s), (InRangeFunc)GET_OPTIMIZED(inRange32s), (InRangeFunc)GET_OPTIMIZED(inRange32f),
diff --git a/modules/core/src/channels.cpp b/modules/core/src/channels.cpp
@@ -79,7 +79,7 @@ typedef void (*MixChannelsFunc)( const void** src, const int* sdelta,
 
 static MixChannelsFunc getMixchFunc(int depth)
 {
-    static MixChannelsFunc mixchTab[] =
+    static MixChannelsFunc mixchTab[CV_DEPTH_MAX] =
     {
         mixChannels8u, mixChannels8u, mixChannels16u,
         mixChannels16u, mixChannels32s, mixChannels32s,
@@ -146,6 +146,7 @@ void cv::mixChannels( const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts, cons
     NAryMatIterator it(arrays, ptrs, (int)(nsrcs + ndsts));
     int total = (int)it.size, blocksize = std::min(total, (int)((BLOCK_SIZE + esz1-1)/esz1));
     MixChannelsFunc func = getMixchFunc(depth);
+    CV_Assert(func);
 
     for( i = 0; i < it.nplanes; i++, ++it )
     {
diff --git a/modules/core/src/convert.simd.hpp b/modules/core/src/convert.simd.hpp
@@ -372,7 +372,7 @@ DEF_CPY_FUNC(64s,    int64)
 
 BinaryFunc getConvertFunc(int sdepth, int ddepth)
 {
-    static BinaryFunc cvtTab[][8] =
+    static BinaryFunc cvtTab[CV_DEPTH_MAX][CV_DEPTH_MAX] =
     {
         {
             (cvt8u), (cvt8s8u), (cvt16u8u),
diff --git a/modules/core/src/convert_scale.simd.hpp b/modules/core/src/convert_scale.simd.hpp
@@ -299,7 +299,7 @@ DEF_CVT_SCALE_FUNC(16f,    cvt1_32f, hfloat, hfloat, float)
 
 BinaryFunc getCvtScaleAbsFunc(int depth)
 {
-    static BinaryFunc cvtScaleAbsTab[] =
+    static BinaryFunc cvtScaleAbsTab[CV_DEPTH_MAX] =
     {
         (BinaryFunc)cvtScaleAbs8u, (BinaryFunc)cvtScaleAbs8s8u, (BinaryFunc)cvtScaleAbs16u8u,
         (BinaryFunc)cvtScaleAbs16s8u, (BinaryFunc)cvtScaleAbs32s8u, (BinaryFunc)cvtScaleAbs32f8u,
@@ -311,7 +311,7 @@ BinaryFunc getCvtScaleAbsFunc(int depth)
 
 BinaryFunc getConvertScaleFunc(int sdepth, int ddepth)
 {
-    static BinaryFunc cvtScaleTab[][8] =
+    static BinaryFunc cvtScaleTab[CV_DEPTH_MAX][CV_DEPTH_MAX] =
     {
         {
             (BinaryFunc)GET_OPTIMIZED(cvtScale8u), (BinaryFunc)GET_OPTIMIZED(cvtScale8s8u), (BinaryFunc)GET_OPTIMIZED(cvtScale16u8u),
diff --git a/modules/core/src/count_non_zero.simd.hpp b/modules/core/src/count_non_zero.simd.hpp
@@ -196,7 +196,7 @@ static int countNonZero64f( const double* src, int len )
 
 CountNonZeroFunc getCountNonZeroTab(int depth)
 {
-    static CountNonZeroFunc countNonZeroTab[] =
+    static CountNonZeroFunc countNonZeroTab[CV_DEPTH_MAX] =
     {
         (CountNonZeroFunc)GET_OPTIMIZED(countNonZero8u), (CountNonZeroFunc)GET_OPTIMIZED(countNonZero8u),
         (CountNonZeroFunc)GET_OPTIMIZED(countNonZero16u), (CountNonZeroFunc)GET_OPTIMIZED(countNonZero16u),
diff --git a/modules/core/src/has_non_zero.simd.hpp b/modules/core/src/has_non_zero.simd.hpp
@@ -310,7 +310,7 @@ static bool hasNonZero64f( const double* src, size_t len )
 
 HasNonZeroFunc getHasNonZeroTab(int depth)
 {
-    static HasNonZeroFunc hasNonZeroTab[] =
+    static HasNonZeroFunc hasNonZeroTab[CV_DEPTH_MAX] =
     {
         (HasNonZeroFunc)GET_OPTIMIZED(hasNonZero8u), (HasNonZeroFunc)GET_OPTIMIZED(hasNonZero8u),
         (HasNonZeroFunc)GET_OPTIMIZED(hasNonZero16u), (HasNonZeroFunc)GET_OPTIMIZED(hasNonZero16u),
diff --git a/modules/core/src/lut.cpp b/modules/core/src/lut.cpp
@@ -68,7 +68,7 @@ static void LUT8u_64f( const uchar* src, const double* lut, double* dst, int len
 
 typedef void (*LUTFunc)( const uchar* src, const uchar* lut, uchar* dst, int len, int cn, int lutcn );
 
-static LUTFunc lutTab[] =
+static LUTFunc lutTab[CV_DEPTH_MAX] =
 {
     (LUTFunc)LUT8u_8u, (LUTFunc)LUT8u_8s, (LUTFunc)LUT8u_16u, (LUTFunc)LUT8u_16s,
     (LUTFunc)LUT8u_32s, (LUTFunc)LUT8u_32f, (LUTFunc)LUT8u_64f, 0
@@ -330,7 +330,7 @@ class LUTParallelBody : public ParallelLoopBody
 
     void operator()( const cv::Range& range ) const CV_OVERRIDE
     {
-        CV_DbgAssert(*ok);
+        CV_Assert(*ok);
 
         const int row0 = range.start;
         const int row1 = range.end;
diff --git a/modules/core/src/mathfuncs.cpp b/modules/core/src/mathfuncs.cpp
@@ -1184,7 +1184,7 @@ static void iPow64f(const double* src, double* dst, int len, int power)
 
 typedef void (*IPowFunc)( const uchar* src, uchar* dst, int len, int power );
 
-static IPowFunc ipowTab[] =
+static IPowFunc ipowTab[CV_DEPTH_MAX] =
 {
     (IPowFunc)iPow8u, (IPowFunc)iPow8s, (IPowFunc)iPow16u, (IPowFunc)iPow16s,
     (IPowFunc)iPow32s, (IPowFunc)iPow32f, (IPowFunc)iPow64f, 0
diff --git a/modules/core/src/matmul.dispatch.cpp b/modules/core/src/matmul.dispatch.cpp
@@ -979,7 +979,7 @@ typedef double (*DotProdFunc)(const uchar* src1, const uchar* src2, int len);
 
 static DotProdFunc getDotProdFunc(int depth)
 {
-    static DotProdFunc dotProdTab[] =
+    static DotProdFunc dotProdTab[CV_DEPTH_MAX] =
     {
         (DotProdFunc)GET_OPTIMIZED(dotProd_8u), (DotProdFunc)GET_OPTIMIZED(dotProd_8s),
         (DotProdFunc)dotProd_16u, (DotProdFunc)dotProd_16s,
diff --git a/modules/core/src/matmul.simd.hpp b/modules/core/src/matmul.simd.hpp
@@ -1792,7 +1792,7 @@ diagtransform_64f(const double* src, double* dst, const double* m, int len, int
 
 TransformFunc getTransformFunc(int depth)
 {
-    static TransformFunc transformTab[] =
+    static TransformFunc transformTab[CV_DEPTH_MAX] =
     {
         (TransformFunc)transform_8u, (TransformFunc)transform_8s, (TransformFunc)transform_16u,
         (TransformFunc)transform_16s, (TransformFunc)transform_32s, (TransformFunc)transform_32f,
@@ -1804,7 +1804,7 @@ TransformFunc getTransformFunc(int depth)
 
 TransformFunc getDiagTransformFunc(int depth)
 {
-    static TransformFunc diagTransformTab[] =
+    static TransformFunc diagTransformTab[CV_DEPTH_MAX] =
     {
         (TransformFunc)diagtransform_8u, (TransformFunc)diagtransform_8s, (TransformFunc)diagtransform_16u,
         (TransformFunc)diagtransform_16s, (TransformFunc)diagtransform_32s, (TransformFunc)diagtransform_32f,
diff --git a/modules/core/src/matrix_operations.cpp b/modules/core/src/matrix_operations.cpp
@@ -1259,7 +1259,7 @@ void cv::sort( InputArray _src, OutputArray _dst, int flags )
     Mat dst = _dst.getMat();
     CV_IPP_RUN_FAST(ipp_sort(src, dst, flags));
 
-    static SortFunc tab[] =
+    static SortFunc tab[CV_DEPTH_MAX] =
     {
         sort_<uchar>, sort_<schar>, sort_<ushort>, sort_<short>,
         sort_<int>, sort_<float>, sort_<double>, 0
@@ -1284,7 +1284,7 @@ void cv::sortIdx( InputArray _src, OutputArray _dst, int flags )
 
     CV_IPP_RUN_FAST(ipp_sortIdx(src, dst, flags));
 
-    static SortFunc tab[] =
+    static SortFunc tab[CV_DEPTH_MAX] =
     {
         sortIdx_<uchar>, sortIdx_<schar>, sortIdx_<ushort>, sortIdx_<short>,
         sortIdx_<int>, sortIdx_<float>, sortIdx_<double>, 0
diff --git a/modules/core/src/matrix_sparse.cpp b/modules/core/src/matrix_sparse.cpp
@@ -37,7 +37,7 @@ typedef void (*ConvertScaleData)(const void* from, void* to, int cn, double alph
 
 static ConvertData getConvertElem(int fromType, int toType)
 {
-    static ConvertData tab[][8] =
+    static ConvertData tab[CV_DEPTH_MAX][CV_DEPTH_MAX] =
     {{ convertData_<uchar, uchar>, convertData_<uchar, schar>,
       convertData_<uchar, ushort>, convertData_<uchar, short>,
       convertData_<uchar, int>, convertData_<uchar, float>,
@@ -82,7 +82,7 @@ static ConvertData getConvertElem(int fromType, int toType)
 
 static ConvertScaleData getConvertScaleElem(int fromType, int toType)
 {
-    static ConvertScaleData tab[][8] =
+    static ConvertScaleData tab[CV_DEPTH_MAX][CV_DEPTH_MAX] =
     {{ convertScaleData_<uchar, uchar>, convertScaleData_<uchar, schar>,
       convertScaleData_<uchar, ushort>, convertScaleData_<uchar, short>,
       convertScaleData_<uchar, int>, convertScaleData_<uchar, float>,
@@ -389,6 +389,7 @@ void SparseMat::convertTo( SparseMat& m, int rtype, double alpha ) const
     if( alpha == 1 )
     {
         ConvertData cvtfunc = getConvertElem(type(), rtype);
+        CV_Assert(cvtfunc);
         for( size_t i = 0; i < N; i++, ++from )
         {
             const Node* n = from.node();
@@ -399,6 +400,7 @@ void SparseMat::convertTo( SparseMat& m, int rtype, double alpha ) const
     else
     {
         ConvertScaleData cvtfunc = getConvertScaleElem(type(), rtype);
+        CV_Assert(cvtfunc);
         for( size_t i = 0; i < N; i++, ++from )
         {
             const Node* n = from.node();
diff --git a/modules/core/src/mean.simd.hpp b/modules/core/src/mean.simd.hpp
@@ -311,7 +311,7 @@ static int sqsum64f( const double* src, const uchar* mask, double* sum, double*
 SumSqrFunc getSumSqrFunc(int depth)
 {
     CV_INSTRUMENT_REGION();
-    static SumSqrFunc sumSqrTab[] =
+    static SumSqrFunc sumSqrTab[CV_DEPTH_MAX] =
     {
         (SumSqrFunc)GET_OPTIMIZED(sqsum8u), (SumSqrFunc)sqsum8s, (SumSqrFunc)sqsum16u, (SumSqrFunc)sqsum16s,
         (SumSqrFunc)sqsum32s, (SumSqrFunc)GET_OPTIMIZED(sqsum32f), (SumSqrFunc)sqsum64f, 0
diff --git a/modules/core/src/merge.dispatch.cpp b/modules/core/src/merge.dispatch.cpp
@@ -50,7 +50,7 @@ typedef void (*MergeFunc)(const uchar** src, uchar* dst, int len, int cn);
 
 static MergeFunc getMergeFunc(int depth)
 {
-    static MergeFunc mergeTab[] =
+    static MergeFunc mergeTab[CV_DEPTH_MAX] =
     {
         (MergeFunc)GET_OPTIMIZED(cv::hal::merge8u), (MergeFunc)GET_OPTIMIZED(cv::hal::merge8u),
         (MergeFunc)GET_OPTIMIZED(cv::hal::merge16u), (MergeFunc)GET_OPTIMIZED(cv::hal::merge16u),
diff --git a/modules/core/src/minmax.cpp b/modules/core/src/minmax.cpp
@@ -834,7 +834,7 @@ typedef void (*MinMaxIdxFunc)(const uchar*, const uchar*, int*, int*, size_t*, s
 
 static MinMaxIdxFunc getMinmaxTab(int depth)
 {
-    static MinMaxIdxFunc minmaxTab[] =
+    static MinMaxIdxFunc minmaxTab[CV_DEPTH_MAX] =
     {
         (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_8u), (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_8s),
         (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_16u), (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_16s),
diff --git a/modules/core/src/rand.cpp b/modules/core/src/rand.cpp
@@ -215,7 +215,7 @@ static void randf_16f( hfloat* arr, int len, uint64* state, const Vec2f* p, floa
 typedef void (*RandFunc)(uchar* arr, int len, uint64* state, const void* p, void* tempbuf, bool small_flag);
 
 
-static RandFunc randTab[][8] =
+static RandFunc randTab[CV_DEPTH_MAX][CV_DEPTH_MAX] =
 {
     {
         (RandFunc)randi_8u, (RandFunc)randi_8s, (RandFunc)randi_16u, (RandFunc)randi_16s,
diff --git a/modules/core/src/split.dispatch.cpp b/modules/core/src/split.dispatch.cpp
@@ -53,7 +53,7 @@ typedef void (*SplitFunc)(const uchar* src, uchar** dst, int len, int cn);
 
 static SplitFunc getSplitFunc(int depth)
 {
-    static SplitFunc splitTab[] =
+    static SplitFunc splitTab[CV_DEPTH_MAX] =
     {
         (SplitFunc)GET_OPTIMIZED(cv::hal::split8u), (SplitFunc)GET_OPTIMIZED(cv::hal::split8u),
         (SplitFunc)GET_OPTIMIZED(cv::hal::split16u), (SplitFunc)GET_OPTIMIZED(cv::hal::split16u),
diff --git a/modules/core/src/sum.simd.hpp b/modules/core/src/sum.simd.hpp
@@ -434,7 +434,7 @@ static int sum64f( const double* src, const uchar* mask, double* dst, int len, i
 
 SumFunc getSumFunc(int depth)
 {
-    static SumFunc sumTab[] =
+    static SumFunc sumTab[CV_DEPTH_MAX] =
     {
         (SumFunc)GET_OPTIMIZED(sum8u), (SumFunc)sum8s,
         (SumFunc)sum16u, (SumFunc)sum16s,

Original file line number	Diff line number	Diff line change
`@@ -329,7 +329,7 @@ static void binary_op( InputArray _src1, InputArray _src2, OutputArray _dst,`
`329`	`329`
`330`	`330`	`static BinaryFuncC* getMaxTab()`
`331`	`331`	`{`
`332`		`- static BinaryFuncC maxTab[] =`
	`332`	`+ static BinaryFuncC maxTab[CV_DEPTH_MAX] =`
`333`	`333`	`{`
`334`	`334`	`(BinaryFuncC)GET_OPTIMIZED(cv::hal::max8u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::max8s),`
`335`	`335`	`(BinaryFuncC)GET_OPTIMIZED(cv::hal::max16u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::max16s),`
`@@ -343,7 +343,7 @@ static BinaryFuncC* getMaxTab()`
`343`	`343`
`344`	`344`	`static BinaryFuncC* getMinTab()`
`345`	`345`	`{`
`346`		`- static BinaryFuncC minTab[] =`
	`346`	`+ static BinaryFuncC minTab[CV_DEPTH_MAX] =`
`347`	`347`	`{`
`348`	`348`	`(BinaryFuncC)GET_OPTIMIZED(cv::hal::min8u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::min8s),`
`349`	`349`	`(BinaryFuncC)GET_OPTIMIZED(cv::hal::min16u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::min16s),`
`@@ -617,7 +617,9 @@ static void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,`
`617`	`617`
`618`	`618`	`Mat src1 = psrc1->getMat(), src2 = psrc2->getMat(), dst = _dst.getMat();`
`619`	`619`	`Size sz = getContinuousSize2D(src1, src2, dst, src1.channels());`
`620`		`- tab[depth1](src1.ptr(), src1.step, src2.ptr(), src2.step, dst.ptr(), dst.step, sz.width, sz.height, usrdata);`
	`620`	`+ BinaryFuncC func = tab[depth1];`
	`621`	`+ CV_Assert(func);`
	`622`	`+ func(src1.ptr(), src1.step, src2.ptr(), src2.step, dst.ptr(), dst.step, sz.width, sz.height, usrdata);`
`621`	`623`	`return;`
`622`	`624`	`}`
`623`	`625`
`@@ -868,7 +870,7 @@ static void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,`
`868`	`870`
`869`	`871`	`static BinaryFuncC* getAddTab()`
`870`	`872`	`{`
`871`		`- static BinaryFuncC addTab[] =`
	`873`	`+ static BinaryFuncC addTab[CV_DEPTH_MAX] =`
`872`	`874`	`{`
`873`	`875`	`(BinaryFuncC)GET_OPTIMIZED(cv::hal::add8u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::add8s),`
`874`	`876`	`(BinaryFuncC)GET_OPTIMIZED(cv::hal::add16u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::add16s),`
`@@ -882,7 +884,7 @@ static BinaryFuncC* getAddTab()`
`882`	`884`
`883`	`885`	`static BinaryFuncC* getSubTab()`
`884`	`886`	`{`
`885`		`- static BinaryFuncC subTab[] =`
	`887`	`+ static BinaryFuncC subTab[CV_DEPTH_MAX] =`
`886`	`888`	`{`
`887`	`889`	`(BinaryFuncC)GET_OPTIMIZED(cv::hal::sub8u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::sub8s),`
`888`	`890`	`(BinaryFuncC)GET_OPTIMIZED(cv::hal::sub16u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::sub16s),`
`@@ -896,7 +898,7 @@ static BinaryFuncC* getSubTab()`
`896`	`898`
`897`	`899`	`static BinaryFuncC* getAbsDiffTab()`
`898`	`900`	`{`
`899`		`- static BinaryFuncC absDiffTab[] =`
	`901`	`+ static BinaryFuncC absDiffTab[CV_DEPTH_MAX] =`
`900`	`902`	`{`
`901`	`903`	`(BinaryFuncC)GET_OPTIMIZED(cv::hal::absdiff8u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::absdiff8s),`
`902`	`904`	`(BinaryFuncC)GET_OPTIMIZED(cv::hal::absdiff16u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::absdiff16s),`
`@@ -949,7 +951,7 @@ namespace cv`
`949`	`951`
`950`	`952`	`static BinaryFuncC* getMulTab()`
`951`	`953`	`{`
`952`		`- static BinaryFuncC mulTab[] =`
	`954`	`+ static BinaryFuncC mulTab[CV_DEPTH_MAX] =`
`953`	`955`	`{`
`954`	`956`	`(BinaryFuncC)cv::hal::mul8u, (BinaryFuncC)cv::hal::mul8s, (BinaryFuncC)cv::hal::mul16u,`
`955`	`957`	`(BinaryFuncC)cv::hal::mul16s, (BinaryFuncC)cv::hal::mul32s, (BinaryFuncC)cv::hal::mul32f,`
`@@ -961,7 +963,7 @@ static BinaryFuncC* getMulTab()`
`961`	`963`
`962`	`964`	`static BinaryFuncC* getDivTab()`
`963`	`965`	`{`
`964`		`- static BinaryFuncC divTab[] =`
	`966`	`+ static BinaryFuncC divTab[CV_DEPTH_MAX] =`
`965`	`967`	`{`
`966`	`968`	`(BinaryFuncC)cv::hal::div8u, (BinaryFuncC)cv::hal::div8s, (BinaryFuncC)cv::hal::div16u,`
`967`	`969`	`(BinaryFuncC)cv::hal::div16s, (BinaryFuncC)cv::hal::div32s, (BinaryFuncC)cv::hal::div32f,`
`@@ -973,7 +975,7 @@ static BinaryFuncC* getDivTab()`
`973`	`975`
`974`	`976`	`static BinaryFuncC* getRecipTab()`
`975`	`977`	`{`
`976`		`- static BinaryFuncC recipTab[] =`
	`978`	`+ static BinaryFuncC recipTab[CV_DEPTH_MAX] =`
`977`	`979`	`{`
`978`	`980`	`(BinaryFuncC)cv::hal::recip8u, (BinaryFuncC)cv::hal::recip8s, (BinaryFuncC)cv::hal::recip16u,`
`979`	`981`	`(BinaryFuncC)cv::hal::recip16s, (BinaryFuncC)cv::hal::recip32s, (BinaryFuncC)cv::hal::recip32f,`
`@@ -1021,7 +1023,7 @@ UMat UMat::mul(InputArray m, double scale) const`
`1021`	`1023`
`1022`	`1024`	`static BinaryFuncC* getAddWeightedTab()`
`1023`	`1025`	`{`
`1024`		`- static BinaryFuncC addWeightedTab[] =`
	`1026`	`+ static BinaryFuncC addWeightedTab[CV_DEPTH_MAX] =`
`1025`	`1027`	`{`
`1026`	`1028`	`(BinaryFuncC)GET_OPTIMIZED(cv::hal::addWeighted8u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::addWeighted8s), (BinaryFuncC)GET_OPTIMIZED(cv::hal::addWeighted16u),`
`1027`	`1029`	`(BinaryFuncC)GET_OPTIMIZED(cv::hal::addWeighted16s), (BinaryFuncC)GET_OPTIMIZED(cv::hal::addWeighted32s), (BinaryFuncC)cv::hal::addWeighted32f,`
`@@ -1052,7 +1054,7 @@ namespace cv`
`1052`	`1054`
`1053`	`1055`	`static BinaryFuncC getCmpFunc(int depth)`
`1054`	`1056`	`{`
`1055`		`- static BinaryFuncC cmpTab[] =`
	`1057`	`+ static BinaryFuncC cmpTab[CV_DEPTH_MAX] =`
`1056`	`1058`	`{`
`1057`	`1059`	`(BinaryFuncC)GET_OPTIMIZED(cv::hal::cmp8u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::cmp8s),`
`1058`	`1060`	`(BinaryFuncC)GET_OPTIMIZED(cv::hal::cmp16u), (BinaryFuncC)GET_OPTIMIZED(cv::hal::cmp16s),`
`@@ -1588,7 +1590,7 @@ typedef void (InRangeFunc)( const uchar src1, size_t step1, const uchar* src2,`
`1588`	`1590`
`1589`	`1591`	`static InRangeFunc getInRangeFunc(int depth)`
`1590`	`1592`	`{`
`1591`		`- static InRangeFunc inRangeTab[] =`
	`1593`	`+ static InRangeFunc inRangeTab[CV_DEPTH_MAX] =`
`1592`	`1594`	`{`
`1593`	`1595`	`(InRangeFunc)GET_OPTIMIZED(inRange8u), (InRangeFunc)GET_OPTIMIZED(inRange8s), (InRangeFunc)GET_OPTIMIZED(inRange16u),`
`1594`	`1596`	`(InRangeFunc)GET_OPTIMIZED(inRange16s), (InRangeFunc)GET_OPTIMIZED(inRange32s), (InRangeFunc)GET_OPTIMIZED(inRange32f),`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ typedef void (MixChannelsFunc)( const void* src, const int* sdelta,`
`79`	`79`
`80`	`80`	`static MixChannelsFunc getMixchFunc(int depth)`
`81`	`81`	`{`
`82`		`- static MixChannelsFunc mixchTab[] =`
	`82`	`+ static MixChannelsFunc mixchTab[CV_DEPTH_MAX] =`
`83`	`83`	`{`
`84`	`84`	`mixChannels8u, mixChannels8u, mixChannels16u,`
`85`	`85`	`mixChannels16u, mixChannels32s, mixChannels32s,`
`@@ -146,6 +146,7 @@ void cv::mixChannels( const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts, cons`
`146`	`146`	`NAryMatIterator it(arrays, ptrs, (int)(nsrcs + ndsts));`
`147`	`147`	`int total = (int)it.size, blocksize = std::min(total, (int)((BLOCK_SIZE + esz1-1)/esz1));`
`148`	`148`	`MixChannelsFunc func = getMixchFunc(depth);`
	`149`	`+ CV_Assert(func);`
`149`	`150`
`150`	`151`	`for( i = 0; i < it.nplanes; i++, ++it )`
`151`	`152`	`{`
Original file line number	Diff line number	Diff line change
`@@ -372,7 +372,7 @@ DEF_CPY_FUNC(64s, int64)`
`372`	`372`
`373`	`373`	`BinaryFunc getConvertFunc(int sdepth, int ddepth)`
`374`	`374`	`{`
`375`		`- static BinaryFunc cvtTab[][8] =`
	`375`	`+ static BinaryFunc cvtTab[CV_DEPTH_MAX][CV_DEPTH_MAX] =`
`376`	`376`	`{`
`377`	`377`	`{`
`378`	`378`	`(cvt8u), (cvt8s8u), (cvt16u8u),`
Original file line number	Diff line number	Diff line change
`@@ -299,7 +299,7 @@ DEF_CVT_SCALE_FUNC(16f, cvt1_32f, hfloat, hfloat, float)`
`299`	`299`
`300`	`300`	`BinaryFunc getCvtScaleAbsFunc(int depth)`
`301`	`301`	`{`
`302`		`- static BinaryFunc cvtScaleAbsTab[] =`
	`302`	`+ static BinaryFunc cvtScaleAbsTab[CV_DEPTH_MAX] =`
`303`	`303`	`{`
`304`	`304`	`(BinaryFunc)cvtScaleAbs8u, (BinaryFunc)cvtScaleAbs8s8u, (BinaryFunc)cvtScaleAbs16u8u,`
`305`	`305`	`(BinaryFunc)cvtScaleAbs16s8u, (BinaryFunc)cvtScaleAbs32s8u, (BinaryFunc)cvtScaleAbs32f8u,`
`@@ -311,7 +311,7 @@ BinaryFunc getCvtScaleAbsFunc(int depth)`
`311`	`311`
`312`	`312`	`BinaryFunc getConvertScaleFunc(int sdepth, int ddepth)`
`313`	`313`	`{`
`314`		`- static BinaryFunc cvtScaleTab[][8] =`
	`314`	`+ static BinaryFunc cvtScaleTab[CV_DEPTH_MAX][CV_DEPTH_MAX] =`
`315`	`315`	`{`
`316`	`316`	`{`
`317`	`317`	`(BinaryFunc)GET_OPTIMIZED(cvtScale8u), (BinaryFunc)GET_OPTIMIZED(cvtScale8s8u), (BinaryFunc)GET_OPTIMIZED(cvtScale16u8u),`
Original file line number	Diff line number	Diff line change
`@@ -196,7 +196,7 @@ static int countNonZero64f( const double* src, int len )`
`196`	`196`
`197`	`197`	`CountNonZeroFunc getCountNonZeroTab(int depth)`
`198`	`198`	`{`
`199`		`- static CountNonZeroFunc countNonZeroTab[] =`
	`199`	`+ static CountNonZeroFunc countNonZeroTab[CV_DEPTH_MAX] =`
`200`	`200`	`{`
`201`	`201`	`(CountNonZeroFunc)GET_OPTIMIZED(countNonZero8u), (CountNonZeroFunc)GET_OPTIMIZED(countNonZero8u),`
`202`	`202`	`(CountNonZeroFunc)GET_OPTIMIZED(countNonZero16u), (CountNonZeroFunc)GET_OPTIMIZED(countNonZero16u),`
Original file line number	Diff line number	Diff line change
`@@ -310,7 +310,7 @@ static bool hasNonZero64f( const double* src, size_t len )`
`310`	`310`
`311`	`311`	`HasNonZeroFunc getHasNonZeroTab(int depth)`
`312`	`312`	`{`
`313`		`- static HasNonZeroFunc hasNonZeroTab[] =`
	`313`	`+ static HasNonZeroFunc hasNonZeroTab[CV_DEPTH_MAX] =`
`314`	`314`	`{`
`315`	`315`	`(HasNonZeroFunc)GET_OPTIMIZED(hasNonZero8u), (HasNonZeroFunc)GET_OPTIMIZED(hasNonZero8u),`
`316`	`316`	`(HasNonZeroFunc)GET_OPTIMIZED(hasNonZero16u), (HasNonZeroFunc)GET_OPTIMIZED(hasNonZero16u),`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ static void LUT8u_64f( const uchar* src, const double* lut, double* dst, int len`
`68`	`68`
`69`	`69`	`typedef void (LUTFunc)( const uchar src, const uchar* lut, uchar* dst, int len, int cn, int lutcn );`
`70`	`70`
`71`		`-static LUTFunc lutTab[] =`
	`71`	`+static LUTFunc lutTab[CV_DEPTH_MAX] =`
`72`	`72`	`{`
`73`	`73`	`(LUTFunc)LUT8u_8u, (LUTFunc)LUT8u_8s, (LUTFunc)LUT8u_16u, (LUTFunc)LUT8u_16s,`
`74`	`74`	`(LUTFunc)LUT8u_32s, (LUTFunc)LUT8u_32f, (LUTFunc)LUT8u_64f, 0`
`@@ -330,7 +330,7 @@ class LUTParallelBody : public ParallelLoopBody`
`330`	`330`
`331`	`331`	`void operator()( const cv::Range& range ) const CV_OVERRIDE`
`332`	`332`	`{`
`333`		`- CV_DbgAssert(*ok);`
	`333`	`+ CV_Assert(*ok);`
`334`	`334`
`335`	`335`	`const int row0 = range.start;`
`336`	`336`	`const int row1 = range.end;`
Original file line number	Diff line number	Diff line change
`@@ -1184,7 +1184,7 @@ static void iPow64f(const double* src, double* dst, int len, int power)`
`1184`	`1184`
`1185`	`1185`	`typedef void (IPowFunc)( const uchar src, uchar* dst, int len, int power );`
`1186`	`1186`
`1187`		`-static IPowFunc ipowTab[] =`
	`1187`	`+static IPowFunc ipowTab[CV_DEPTH_MAX] =`
`1188`	`1188`	`{`
`1189`	`1189`	`(IPowFunc)iPow8u, (IPowFunc)iPow8s, (IPowFunc)iPow16u, (IPowFunc)iPow16s,`
`1190`	`1190`	`(IPowFunc)iPow32s, (IPowFunc)iPow32f, (IPowFunc)iPow64f, 0`
Original file line number	Diff line number	Diff line change
`@@ -979,7 +979,7 @@ typedef double (DotProdFunc)(const uchar src1, const uchar* src2, int len);`
`979`	`979`
`980`	`980`	`static DotProdFunc getDotProdFunc(int depth)`
`981`	`981`	`{`
`982`		`- static DotProdFunc dotProdTab[] =`
	`982`	`+ static DotProdFunc dotProdTab[CV_DEPTH_MAX] =`
`983`	`983`	`{`
`984`	`984`	`(DotProdFunc)GET_OPTIMIZED(dotProd_8u), (DotProdFunc)GET_OPTIMIZED(dotProd_8s),`
`985`	`985`	`(DotProdFunc)dotProd_16u, (DotProdFunc)dotProd_16s,`
Original file line number	Diff line number	Diff line change
`@@ -1792,7 +1792,7 @@ diagtransform_64f(const double* src, double* dst, const double* m, int len, int`
`1792`	`1792`
`1793`	`1793`	`TransformFunc getTransformFunc(int depth)`
`1794`	`1794`	`{`
`1795`		`- static TransformFunc transformTab[] =`
	`1795`	`+ static TransformFunc transformTab[CV_DEPTH_MAX] =`
`1796`	`1796`	`{`
`1797`	`1797`	`(TransformFunc)transform_8u, (TransformFunc)transform_8s, (TransformFunc)transform_16u,`
`1798`	`1798`	`(TransformFunc)transform_16s, (TransformFunc)transform_32s, (TransformFunc)transform_32f,`
`@@ -1804,7 +1804,7 @@ TransformFunc getTransformFunc(int depth)`
`1804`	`1804`
`1805`	`1805`	`TransformFunc getDiagTransformFunc(int depth)`
`1806`	`1806`	`{`
`1807`		`- static TransformFunc diagTransformTab[] =`
	`1807`	`+ static TransformFunc diagTransformTab[CV_DEPTH_MAX] =`
`1808`	`1808`	`{`
`1809`	`1809`	`(TransformFunc)diagtransform_8u, (TransformFunc)diagtransform_8s, (TransformFunc)diagtransform_16u,`
`1810`	`1810`	`(TransformFunc)diagtransform_16s, (TransformFunc)diagtransform_32s, (TransformFunc)diagtransform_32f,`