All optimized function tables wrapped to getters to change its

initialization time.

modules/core/src/convert.cpp

@@ -194,17 +194,27 @@ static void merge64s(const int64** src, int64* dst, int len, int cn )
 typedef void (*SplitFunc)(const uchar* src, uchar** dst, int len, int cn);
 typedef void (*MergeFunc)(const uchar** src, uchar* dst, int len, int cn);
 
-static SplitFunc splitTab[] =
+static SplitFunc getSplitFunc(int depth)
 {
+    static SplitFunc splitTab[] =
+    {
         (SplitFunc)GET_OPTIMIZED(split8u), (SplitFunc)GET_OPTIMIZED(split8u), (SplitFunc)GET_OPTIMIZED(split16u), (SplitFunc)GET_OPTIMIZED(split16u),
         (SplitFunc)GET_OPTIMIZED(split32s), (SplitFunc)GET_OPTIMIZED(split32s), (SplitFunc)GET_OPTIMIZED(split64s), 0
-};
+    };
+
+    return splitTab[depth];
+}
 
-static MergeFunc mergeTab[] =
+static MergeFunc getMergeFunc(int depth)
 {
+    static MergeFunc mergeTab[] =
+    {
         (MergeFunc)GET_OPTIMIZED(merge8u), (MergeFunc)GET_OPTIMIZED(merge8u), (MergeFunc)GET_OPTIMIZED(merge16u), (MergeFunc)GET_OPTIMIZED(merge16u),
         (MergeFunc)GET_OPTIMIZED(merge32s), (MergeFunc)GET_OPTIMIZED(merge32s), (MergeFunc)GET_OPTIMIZED(merge64s), 0
-};
+    };
+
+    return mergeTab[depth];
+}
 
 }
 
@@ -217,7 +227,7 @@ void cv::split(const Mat& src, Mat* mv)
         return;
     }
 
-    SplitFunc func = splitTab[depth];
+    SplitFunc func = getSplitFunc(depth);
     CV_Assert( func != 0 );
 
     int esz = (int)src.elemSize(), esz1 = (int)src.elemSize1();
@@ -328,7 +338,7 @@ void cv::merge(const Mat* mv, size_t n, OutputArray _dst)
 
     NAryMatIterator it(arrays, ptrs, cn+1);
     int total = (int)it.size, blocksize = cn <= 4 ? total : std::min(total, blocksize0);
-    MergeFunc func = mergeTab[depth];
+    MergeFunc func = getMergeFunc(depth);
 
     for( i = 0; i < it.nplanes; i++, ++it )
     {
@@ -429,12 +439,17 @@ static void mixChannels64s( const int64** src, const int* sdelta,
 typedef void (*MixChannelsFunc)( const uchar** src, const int* sdelta,
         uchar** dst, const int* ddelta, int len, int npairs );
 
-static MixChannelsFunc mixchTab[] =
+static MixChannelsFunc getMixchFunc(int depth)
 {
+    static MixChannelsFunc mixchTab[] =
+    {
         (MixChannelsFunc)mixChannels8u, (MixChannelsFunc)mixChannels8u, (MixChannelsFunc)mixChannels16u,
         (MixChannelsFunc)mixChannels16u, (MixChannelsFunc)mixChannels32s, (MixChannelsFunc)mixChannels32s,
         (MixChannelsFunc)mixChannels64s, 0
-};
+    };
+
+    return mixchTab[depth];
+}
 
 }
 
@@ -489,7 +504,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 = mixchTab[depth];
+    MixChannelsFunc func = getMixchFunc(depth);
 
     for( i = 0; i < it.nplanes; i++, ++it )
     {
@@ -941,57 +956,22 @@ DEF_CVT_FUNC(32s64f, int, double);
 DEF_CVT_FUNC(32f64f, float, double);
 DEF_CPY_FUNC(64s,    int64);
 
-static BinaryFunc cvtScaleAbsTab[] =
+static BinaryFunc getCvtScaleAbsFunc(int depth)
 {
+    static BinaryFunc cvtScaleAbsTab[] =
+    {
         (BinaryFunc)cvtScaleAbs8u, (BinaryFunc)cvtScaleAbs8s8u, (BinaryFunc)cvtScaleAbs16u8u,
         (BinaryFunc)cvtScaleAbs16s8u, (BinaryFunc)cvtScaleAbs32s8u, (BinaryFunc)cvtScaleAbs32f8u,
         (BinaryFunc)cvtScaleAbs64f8u, 0
-};
+    };
 
-static BinaryFunc cvtScaleTab[][8] =
-{
-    {
-        (BinaryFunc)GET_OPTIMIZED(cvtScale8u), (BinaryFunc)GET_OPTIMIZED(cvtScale8s8u), (BinaryFunc)GET_OPTIMIZED(cvtScale16u8u),
-        (BinaryFunc)GET_OPTIMIZED(cvtScale16s8u), (BinaryFunc)GET_OPTIMIZED(cvtScale32s8u), (BinaryFunc)GET_OPTIMIZED(cvtScale32f8u),
-        (BinaryFunc)cvtScale64f8u, 0
-    },
-    {
-        (BinaryFunc)GET_OPTIMIZED(cvtScale8u8s), (BinaryFunc)GET_OPTIMIZED(cvtScale8s), (BinaryFunc)GET_OPTIMIZED(cvtScale16u8s),
-        (BinaryFunc)GET_OPTIMIZED(cvtScale16s8s), (BinaryFunc)GET_OPTIMIZED(cvtScale32s8s), (BinaryFunc)GET_OPTIMIZED(cvtScale32f8s),
-        (BinaryFunc)cvtScale64f8s, 0
-    },
-    {
-        (BinaryFunc)GET_OPTIMIZED(cvtScale8u16u), (BinaryFunc)GET_OPTIMIZED(cvtScale8s16u), (BinaryFunc)GET_OPTIMIZED(cvtScale16u),
-        (BinaryFunc)GET_OPTIMIZED(cvtScale16s16u), (BinaryFunc)GET_OPTIMIZED(cvtScale32s16u), (BinaryFunc)GET_OPTIMIZED(cvtScale32f16u),
-        (BinaryFunc)cvtScale64f16u, 0
-    },
-    {
-        (BinaryFunc)GET_OPTIMIZED(cvtScale8u16s), (BinaryFunc)GET_OPTIMIZED(cvtScale8s16s), (BinaryFunc)GET_OPTIMIZED(cvtScale16u16s),
-        (BinaryFunc)GET_OPTIMIZED(cvtScale16s), (BinaryFunc)GET_OPTIMIZED(cvtScale32s16s), (BinaryFunc)GET_OPTIMIZED(cvtScale32f16s),
-        (BinaryFunc)cvtScale64f16s, 0
-    },
-    {
-        (BinaryFunc)GET_OPTIMIZED(cvtScale8u32s), (BinaryFunc)GET_OPTIMIZED(cvtScale8s32s), (BinaryFunc)GET_OPTIMIZED(cvtScale16u32s),
-        (BinaryFunc)GET_OPTIMIZED(cvtScale16s32s), (BinaryFunc)GET_OPTIMIZED(cvtScale32s), (BinaryFunc)GET_OPTIMIZED(cvtScale32f32s),
-        (BinaryFunc)cvtScale64f32s, 0
-    },
-    {
-        (BinaryFunc)GET_OPTIMIZED(cvtScale8u32f), (BinaryFunc)GET_OPTIMIZED(cvtScale8s32f), (BinaryFunc)GET_OPTIMIZED(cvtScale16u32f),
-        (BinaryFunc)GET_OPTIMIZED(cvtScale16s32f), (BinaryFunc)GET_OPTIMIZED(cvtScale32s32f), (BinaryFunc)GET_OPTIMIZED(cvtScale32f),
-        (BinaryFunc)cvtScale64f32f, 0
-    },
-    {
-        (BinaryFunc)cvtScale8u64f, (BinaryFunc)cvtScale8s64f, (BinaryFunc)cvtScale16u64f,
-        (BinaryFunc)cvtScale16s64f, (BinaryFunc)cvtScale32s64f, (BinaryFunc)cvtScale32f64f,
-        (BinaryFunc)cvtScale64f, 0
-    },
-    {
-        0, 0, 0, 0, 0, 0, 0, 0
-    }
-};
+    return cvtScaleAbsTab[depth];
+}
 
-static BinaryFunc cvtTab[][8] =
+BinaryFunc getConvertFunc(int sdepth, int ddepth)
 {
+    static BinaryFunc cvtTab[][8] =
+    {
         {
             (BinaryFunc)(cvt8u), (BinaryFunc)GET_OPTIMIZED(cvt8s8u), (BinaryFunc)GET_OPTIMIZED(cvt16u8u),
             (BinaryFunc)GET_OPTIMIZED(cvt16s8u), (BinaryFunc)GET_OPTIMIZED(cvt32s8u), (BinaryFunc)GET_OPTIMIZED(cvt32f8u),
@@ -1030,15 +1010,55 @@ static BinaryFunc cvtTab[][8] =
         {
             0, 0, 0, 0, 0, 0, 0, 0
         }
-};
+    };
 
-BinaryFunc getConvertFunc(int sdepth, int ddepth)
-{
     return cvtTab[CV_MAT_DEPTH(ddepth)][CV_MAT_DEPTH(sdepth)];
 }
 
 BinaryFunc getConvertScaleFunc(int sdepth, int ddepth)
 {
+    static BinaryFunc cvtScaleTab[][8] =
+    {
+        {
+            (BinaryFunc)GET_OPTIMIZED(cvtScale8u), (BinaryFunc)GET_OPTIMIZED(cvtScale8s8u), (BinaryFunc)GET_OPTIMIZED(cvtScale16u8u),
+            (BinaryFunc)GET_OPTIMIZED(cvtScale16s8u), (BinaryFunc)GET_OPTIMIZED(cvtScale32s8u), (BinaryFunc)GET_OPTIMIZED(cvtScale32f8u),
+            (BinaryFunc)cvtScale64f8u, 0
+        },
+        {
+            (BinaryFunc)GET_OPTIMIZED(cvtScale8u8s), (BinaryFunc)GET_OPTIMIZED(cvtScale8s), (BinaryFunc)GET_OPTIMIZED(cvtScale16u8s),
+            (BinaryFunc)GET_OPTIMIZED(cvtScale16s8s), (BinaryFunc)GET_OPTIMIZED(cvtScale32s8s), (BinaryFunc)GET_OPTIMIZED(cvtScale32f8s),
+            (BinaryFunc)cvtScale64f8s, 0
+        },
+        {
+            (BinaryFunc)GET_OPTIMIZED(cvtScale8u16u), (BinaryFunc)GET_OPTIMIZED(cvtScale8s16u), (BinaryFunc)GET_OPTIMIZED(cvtScale16u),
+            (BinaryFunc)GET_OPTIMIZED(cvtScale16s16u), (BinaryFunc)GET_OPTIMIZED(cvtScale32s16u), (BinaryFunc)GET_OPTIMIZED(cvtScale32f16u),
+            (BinaryFunc)cvtScale64f16u, 0
+        },
+        {
+            (BinaryFunc)GET_OPTIMIZED(cvtScale8u16s), (BinaryFunc)GET_OPTIMIZED(cvtScale8s16s), (BinaryFunc)GET_OPTIMIZED(cvtScale16u16s),
+            (BinaryFunc)GET_OPTIMIZED(cvtScale16s), (BinaryFunc)GET_OPTIMIZED(cvtScale32s16s), (BinaryFunc)GET_OPTIMIZED(cvtScale32f16s),
+            (BinaryFunc)cvtScale64f16s, 0
+        },
+        {
+            (BinaryFunc)GET_OPTIMIZED(cvtScale8u32s), (BinaryFunc)GET_OPTIMIZED(cvtScale8s32s), (BinaryFunc)GET_OPTIMIZED(cvtScale16u32s),
+            (BinaryFunc)GET_OPTIMIZED(cvtScale16s32s), (BinaryFunc)GET_OPTIMIZED(cvtScale32s), (BinaryFunc)GET_OPTIMIZED(cvtScale32f32s),
+            (BinaryFunc)cvtScale64f32s, 0
+        },
+        {
+            (BinaryFunc)GET_OPTIMIZED(cvtScale8u32f), (BinaryFunc)GET_OPTIMIZED(cvtScale8s32f), (BinaryFunc)GET_OPTIMIZED(cvtScale16u32f),
+            (BinaryFunc)GET_OPTIMIZED(cvtScale16s32f), (BinaryFunc)GET_OPTIMIZED(cvtScale32s32f), (BinaryFunc)GET_OPTIMIZED(cvtScale32f),
+            (BinaryFunc)cvtScale64f32f, 0
+        },
+        {
+            (BinaryFunc)cvtScale8u64f, (BinaryFunc)cvtScale8s64f, (BinaryFunc)cvtScale16u64f,
+            (BinaryFunc)cvtScale16s64f, (BinaryFunc)cvtScale32s64f, (BinaryFunc)cvtScale32f64f,
+            (BinaryFunc)cvtScale64f, 0
+        },
+        {
+            0, 0, 0, 0, 0, 0, 0, 0
+        }
+    };
+
     return cvtScaleTab[CV_MAT_DEPTH(ddepth)][CV_MAT_DEPTH(sdepth)];
 }
 
@@ -1051,7 +1071,7 @@ void cv::convertScaleAbs( InputArray _src, OutputArray _dst, double alpha, doubl
     double scale[] = {alpha, beta};
     _dst.create( src.dims, src.size, CV_8UC(cn) );
     Mat dst = _dst.getMat();
-    BinaryFunc func = cvtScaleAbsTab[src.depth()];
+    BinaryFunc func = getCvtScaleAbsFunc(src.depth());
     CV_Assert( func != 0 );
 
     if( src.dims <= 2 )

modules/core/src/matmul.cpp

@@ -1725,19 +1725,29 @@ diagtransform_64f(const double* src, double* dst, const double* m, int len, int
 
 typedef void (*TransformFunc)( const uchar* src, uchar* dst, const uchar* m, int, int, int );
 
-static TransformFunc transformTab[] =
+static TransformFunc getTransformFunc(int depth)
 {
+    static TransformFunc transformTab[] =
+    {
         (TransformFunc)transform_8u, (TransformFunc)transform_8s, (TransformFunc)transform_16u,
         (TransformFunc)transform_16s, (TransformFunc)transform_32s, (TransformFunc)transform_32f,
         (TransformFunc)transform_64f, 0
-};
+    };
+
+    return transformTab[depth];
+}
 
-static TransformFunc diagTransformTab[] =
+static TransformFunc getDiagTransformFunc(int depth)
 {
+    static TransformFunc diagTransformTab[] =
+    {
         (TransformFunc)diagtransform_8u, (TransformFunc)diagtransform_8s, (TransformFunc)diagtransform_16u,
         (TransformFunc)diagtransform_16s, (TransformFunc)diagtransform_32s, (TransformFunc)diagtransform_32f,
         (TransformFunc)diagtransform_64f, 0
-};
+    };
+
+    return diagTransformTab[depth];
+}
 
 }
 
@@ -1800,7 +1810,7 @@ void cv::transform( InputArray _src, OutputArray _dst, InputArray _mtx )
         }
     }
 
-    TransformFunc func = isDiag ? diagTransformTab[depth] : transformTab[depth];
+    TransformFunc func = isDiag ? getDiagTransformFunc(depth): getTransformFunc(depth);
     CV_Assert( func != 0 );
 
     const Mat* arrays[] = {&src, &dst, 0};
@@ -2766,19 +2776,24 @@ static double dotProd_64f(const double* src1, const double* src2, int len)
 
 typedef double (*DotProdFunc)(const uchar* src1, const uchar* src2, int len);
 
-static DotProdFunc dotProdTab[] =
+static DotProdFunc getDotProdFunc(int depth)
 {
+    static DotProdFunc dotProdTab[] =
+    {
         (DotProdFunc)GET_OPTIMIZED(dotProd_8u), (DotProdFunc)GET_OPTIMIZED(dotProd_8s),
         (DotProdFunc)dotProd_16u, (DotProdFunc)dotProd_16s,
         (DotProdFunc)dotProd_32s, (DotProdFunc)GET_OPTIMIZED(dotProd_32f),
         (DotProdFunc)dotProd_64f, 0
-};
+    };
+
+    return dotProdTab[depth];
+}
 
 double Mat::dot(InputArray _mat) const
 {
     Mat mat = _mat.getMat();
     int cn = channels();
-    DotProdFunc func = dotProdTab[depth()];
+    DotProdFunc func = getDotProdFunc(depth());
     CV_Assert( mat.type() == type() && mat.size == size && func != 0 );
 
     if( isContinuous() && mat.isContinuous() )

modules/core/src/stat.cpp

@@ -199,14 +199,19 @@ static int sum64f( const double* src, const uchar* mask, double* dst, int len, i
 
 typedef int (*SumFunc)(const uchar*, const uchar* mask, uchar*, int, int);
 
-static SumFunc sumTab[] =
+static SumFunc getSumFunc(int depth)
 {
+    static SumFunc sumTab[] =
+    {
         (SumFunc)GET_OPTIMIZED(sum8u), (SumFunc)sum8s,
         (SumFunc)sum16u, (SumFunc)sum16s,
         (SumFunc)sum32s,
         (SumFunc)GET_OPTIMIZED(sum32f), (SumFunc)sum64f,
         0
-};
+    };
+
+    return sumTab[depth];
+}
 
 template<typename T>
 static int countNonZero_(const T* src, int len )
@@ -271,14 +276,18 @@ static int countNonZero64f( const double* src, int len )
 
 typedef int (*CountNonZeroFunc)(const uchar*, int);
 
-static CountNonZeroFunc countNonZeroTab[] =
+static CountNonZeroFunc getCountNonZeroTab(int depth)
 {
+    static CountNonZeroFunc countNonZeroTab[] =
+    {
         (CountNonZeroFunc)GET_OPTIMIZED(countNonZero8u), (CountNonZeroFunc)GET_OPTIMIZED(countNonZero8u),
         (CountNonZeroFunc)GET_OPTIMIZED(countNonZero16u), (CountNonZeroFunc)GET_OPTIMIZED(countNonZero16u),
         (CountNonZeroFunc)GET_OPTIMIZED(countNonZero32s), (CountNonZeroFunc)GET_OPTIMIZED(countNonZero32f),
         (CountNonZeroFunc)GET_OPTIMIZED(countNonZero64f), 0
-};
+    };
 
+    return countNonZeroTab[depth];
+}
 
 template<typename T, typename ST, typename SQT>
 static int sumsqr_(const T* src0, const uchar* mask, ST* sum, SQT* sqsum, int len, int cn )
@@ -427,11 +436,16 @@ static int sqsum64f( const double* src, const uchar* mask, double* sum, double*
 
 typedef int (*SumSqrFunc)(const uchar*, const uchar* mask, uchar*, uchar*, int, int);
 
-static SumSqrFunc sumSqrTab[] =
+static SumSqrFunc getSumSqrTab(int depth)
 {
+    static SumSqrFunc sumSqrTab[] =
+    {
         (SumSqrFunc)GET_OPTIMIZED(sqsum8u), (SumSqrFunc)sqsum8s, (SumSqrFunc)sqsum16u, (SumSqrFunc)sqsum16s,
         (SumSqrFunc)sqsum32s, (SumSqrFunc)GET_OPTIMIZED(sqsum32f), (SumSqrFunc)sqsum64f, 0
-};
+    };
+
+    return sumSqrTab[depth];
+}
 
 }
 
@@ -478,7 +492,7 @@ cv::Scalar cv::sum( InputArray _src )
 	}
 #endif 
 	
-    SumFunc func = sumTab[depth];
+    SumFunc func = getSumFunc(depth);
 
     CV_Assert( cn <= 4 && func != 0 );
 
@@ -530,7 +544,7 @@ cv::Scalar cv::sum( InputArray _src )
 int cv::countNonZero( InputArray _src )
 {
     Mat src = _src.getMat();
-    CountNonZeroFunc func = countNonZeroTab[src.depth()];
+    CountNonZeroFunc func = getCountNonZeroTab(src.depth());
 
     CV_Assert( src.channels() == 1 && func != 0 );
 
@@ -626,7 +640,7 @@ cv::Scalar cv::mean( InputArray _src, InputArray _mask )
 	}
 #endif
 	
-    SumFunc func = sumTab[depth];
+    SumFunc func = getSumFunc(depth);
 
     CV_Assert( cn <= 4 && func != 0 );
 
@@ -685,7 +699,7 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input
     CV_Assert( mask.empty() || mask.type() == CV_8U );
 
     int k, cn = src.channels(), depth = src.depth();
-    SumSqrFunc func = sumSqrTab[depth];
+    SumSqrFunc func = getSumSqrTab(depth);
 
     CV_Assert( func != 0 );
 
@@ -859,14 +873,19 @@ static void minMaxIdx_64f(const double* src, const uchar* mask, double* minval,
 
 typedef void (*MinMaxIdxFunc)(const uchar*, const uchar*, int*, int*, size_t*, size_t*, int, size_t);
 
-static MinMaxIdxFunc minmaxTab[] =
+static MinMaxIdxFunc getMinmaxTab(int depth)
 {
+    static MinMaxIdxFunc minmaxTab[] =
+    {
         (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_8u), (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_8s),
         (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_16u), (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_16s),
         (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_32s),
         (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_32f), (MinMaxIdxFunc)GET_OPTIMIZED(minMaxIdx_64f),
         0
-};
+    };
+
+    return minmaxTab[depth];
+}
 
 static void ofs2idx(const Mat& a, size_t ofs, int* idx)
 {
@@ -899,7 +918,7 @@ void cv::minMaxIdx(InputArray _src, double* minVal,
 
     CV_Assert( (cn == 1 && (mask.empty() || mask.type() == CV_8U)) ||
                (cn >= 1 && mask.empty() && !minIdx && !maxIdx) );
-    MinMaxIdxFunc func = minmaxTab[depth];
+    MinMaxIdxFunc func = getMinmaxTab(depth);
     CV_Assert( func != 0 );
 
     const Mat* arrays[] = {&src, &mask, 0};
@@ -1362,8 +1381,10 @@ CV_DEF_NORM_ALL(64f, double, double, double, double)
 typedef int (*NormFunc)(const uchar*, const uchar*, uchar*, int, int);
 typedef int (*NormDiffFunc)(const uchar*, const uchar*, const uchar*, uchar*, int, int);
 
-static NormFunc normTab[3][8] =
+static NormFunc getNormFunc(int normType, int depth)
 {
+    static NormFunc normTab[3][8] =
+    {
         {
             (NormFunc)GET_OPTIMIZED(normInf_8u), (NormFunc)GET_OPTIMIZED(normInf_8s), (NormFunc)GET_OPTIMIZED(normInf_16u), (NormFunc)GET_OPTIMIZED(normInf_16s),
             (NormFunc)GET_OPTIMIZED(normInf_32s), (NormFunc)GET_OPTIMIZED(normInf_32f), (NormFunc)normInf_64f, 0
@@ -1376,10 +1397,15 @@ static NormFunc normTab[3][8] =
             (NormFunc)GET_OPTIMIZED(normL2_8u), (NormFunc)GET_OPTIMIZED(normL2_8s), (NormFunc)GET_OPTIMIZED(normL2_16u), (NormFunc)GET_OPTIMIZED(normL2_16s),
             (NormFunc)GET_OPTIMIZED(normL2_32s), (NormFunc)GET_OPTIMIZED(normL2_32f), (NormFunc)normL2_64f, 0
         }
-};
+    };
 
-static NormDiffFunc normDiffTab[3][8] =
+    return normTab[normType][depth];
+}
+
+static NormDiffFunc getNormDiffFunc(int normType, int depth)
 {
+    static NormDiffFunc normDiffTab[3][8] =
+    {
         {
             (NormDiffFunc)GET_OPTIMIZED(normDiffInf_8u), (NormDiffFunc)normDiffInf_8s,
             (NormDiffFunc)normDiffInf_16u, (NormDiffFunc)normDiffInf_16s,
@@ -1398,7 +1424,10 @@ static NormDiffFunc normDiffTab[3][8] =
             (NormDiffFunc)normDiffL2_32s, (NormDiffFunc)GET_OPTIMIZED(normDiffL2_32f),
             (NormDiffFunc)normDiffL2_64f, 0
         }
-};
+    };
+
+    return normDiffTab[normType][depth];
+}
 
 }
 
@@ -1482,7 +1511,7 @@ double cv::norm( InputArray _src, int normType, InputArray _mask )
         return result;
     }
 
-    NormFunc func = normTab[normType >> 1][depth];
+    NormFunc func = getNormFunc(normType >> 1, depth);
     CV_Assert( func != 0 );
 
     const Mat* arrays[] = {&src, &mask, 0};
@@ -1623,7 +1652,7 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m
         return result;
     }
 
-    NormDiffFunc func = normDiffTab[normType >> 1][depth];
+    NormDiffFunc func = getNormDiffFunc(normType >> 1, depth);
     CV_Assert( func != 0 );
 
     const Mat* arrays[] = {&src1, &src2, &mask, 0};