fix warnings

quic-xuezha · quic-xuezha · commit 7554d15e72f9 · 2024-12-12T11:21:11.000+05:30
diff --git a/modules/fastcv/src/blur.cpp b/modules/fastcv/src/blur.cpp
@@ -38,22 +38,22 @@ class FcvGaussianBlurLoop_Invoker : public cv::ParallelLoopBody
         }
 
         const uchar* src = src_data + (range.start-topLines)*src_step;
-        uchar dst[dst_step*rangeHeight];
+        std::vector<uchar> dst(dst_step*rangeHeight);
 
         if (fcvFuncType == FCV_MAKETYPE(3,CV_8U))
-            fcvFilterGaussian3x3u8_v4(src, width, rangeHeight, src_step, dst, dst_step, fcvBorder, 0);
+            fcvFilterGaussian3x3u8_v4(src, width, rangeHeight, src_step, dst.data(), dst_step, fcvBorder, 0);
         else if (fcvFuncType == FCV_MAKETYPE(5,CV_8U))
-            fcvFilterGaussian5x5u8_v3(src, width, rangeHeight, src_step, dst, dst_step, fcvBorder, 0);
+            fcvFilterGaussian5x5u8_v3(src, width, rangeHeight, src_step, dst.data(), dst_step, fcvBorder, 0);
         else if (fcvFuncType == FCV_MAKETYPE(5,CV_16S))
-            fcvFilterGaussian5x5s16_v3((int16_t*)src, width, rangeHeight, src_step, (int16_t*)dst, dst_step, fcvBorder, 0);
+            fcvFilterGaussian5x5s16_v3((int16_t*)src, width, rangeHeight, src_step, (int16_t*)dst.data(), dst_step, fcvBorder, 0);
         else if (fcvFuncType == FCV_MAKETYPE(5,CV_32S))
-            fcvFilterGaussian5x5s32_v3((int32_t*)src, width, rangeHeight, src_step, (int32_t*)dst, dst_step, fcvBorder, 0);
+            fcvFilterGaussian5x5s32_v3((int32_t*)src, width, rangeHeight, src_step, (int32_t*)dst.data(), dst_step, fcvBorder, 0);
         else if (fcvFuncType == FCV_MAKETYPE(11,CV_8U))
-            fcvFilterGaussian11x11u8_v2(src, width, rangeHeight, src_step, dst, dst_step, fcvBorder);
+            fcvFilterGaussian11x11u8_v2(src, width, rangeHeight, src_step, dst.data(), dst_step, fcvBorder);
 
-        uchar* dptr = dst_data+range.start*dst_step;
-        uchar* sptr = dst+topLines*dst_step;
-        memcpy(dptr,sptr, (range.end-range.start)*dst_step);
+        uchar *dptr = dst_data + range.start * dst_step;
+        uchar *sptr = dst.data() + topLines * dst_step;
+        memcpy(dptr, sptr, (range.end - range.start) * dst_step);
     }
 
     private:
@@ -132,17 +132,17 @@ class FcvFilter2DLoop_Invoker : public cv::ParallelLoopBody
         }
 
         const uchar *src = src_data + (range.start - topLines) * src_step;
-        uchar dst[dst_step*rangeHeight];
+        std::vector<uchar> dst(dst_step*rangeHeight);
 
         if (ddepth == CV_8U)
-            fcvFilterCorrNxNu8((int8_t*)kernel, ksize, 0, src, width, rangeHeight, src_step, dst, dst_step);
+            fcvFilterCorrNxNu8((int8_t*)kernel, ksize, 0, src, width, rangeHeight, src_step, dst.data(), dst_step);
         else if (ddepth == CV_16S)
-            fcvFilterCorrNxNu8s16((int8_t*)kernel, ksize, 0, src, width, rangeHeight, src_step, (int16_t*)dst, dst_step);
+            fcvFilterCorrNxNu8s16((int8_t*)kernel, ksize, 0, src, width, rangeHeight, src_step, (int16_t*)dst.data(), dst_step);
         else if (ddepth == CV_32F)
-            fcvFilterCorrNxNu8f32((float32_t*)kernel, ksize, src, width, rangeHeight, src_step, (float32_t*)dst, dst_step);
+            fcvFilterCorrNxNu8f32((float32_t*)kernel, ksize, src, width, rangeHeight, src_step, (float32_t*)dst.data(), dst_step);
 
-        uchar* dptr = dst_data+range.start*dst_step;
-        uchar* sptr = dst+topLines*dst_step;
+        uchar *dptr = dst_data + range.start * dst_step;
+        uchar *sptr = dst.data() + topLines * dst_step;
         memcpy(dptr, sptr, (range.end - range.start) * dst_step);
     }
 
@@ -237,56 +237,56 @@ class FcvSepFilter2DLoop_Invoker : public cv::ParallelLoopBody
         }
 
         const uchar *src = src_data + (range.start - topLines) * src_step;
-        uchar dst[dst_step*rangeHeight];
+        std::vector<uchar> dst(dst_step*rangeHeight);
 
         switch (ddepth)
         {
             case CV_8U:
             {
                 fcvFilterCorrSepMxNu8((int8_t*)kernelX, kernelXSize, (int8_t*)kernelY, kernelYSize, 0, src, width, rangeHeight,
-                    src_step, dst, dst_step);
+                    src_step, dst.data(), dst_step);
                 break;
             }
             case CV_16S:
             {
-                int16_t tmpImage[width*(rangeHeight+kernelXSize-1)];
+                std::vector<int16_t> tmpImage(width*(rangeHeight+kernelXSize-1));
                 switch (kernelXSize)
                 {
                     case 9:
                     {
                         fcvFilterCorrSep9x9s16_v2((int16_t*)kernelX, (int16_t*)src, width, rangeHeight, src_step,
-                            tmpImage, (int16_t*)dst, dst_step);
+                            tmpImage.data(), (int16_t*)dst.data(), dst_step);
                         break;
                     }
                     case 11:
                     {
                         fcvFilterCorrSep11x11s16_v2((int16_t*)kernelX, (int16_t*)src, width, rangeHeight, src_step,
-                            tmpImage, (int16_t*)dst, dst_step);
+                            tmpImage.data(), (int16_t*)dst.data(), dst_step);
                         break;
                     }
                     case 13:
                     {
                         fcvFilterCorrSep13x13s16_v2((int16_t*)kernelX, (int16_t*)src, width, rangeHeight, src_step,
-                            tmpImage, (int16_t*)dst, dst_step);
+                            tmpImage.data(), (int16_t*)dst.data(), dst_step);
                         break;
                     }
                     case 15:
                     {
                         fcvFilterCorrSep15x15s16_v2((int16_t*)kernelX, (int16_t*)src, width, rangeHeight, src_step,
-                            tmpImage, (int16_t*)dst, dst_step);
+                            tmpImage.data(), (int16_t*)dst.data(), dst_step);
                         break;
                     }
                     case 17:
                     {
                         fcvFilterCorrSep17x17s16_v2((int16_t*)kernelX, (int16_t*)src, width, rangeHeight, src_step,
-                            tmpImage, (int16_t*)dst, dst_step);
+                            tmpImage.data(), (int16_t*)dst.data(), dst_step);
                         break;
                     }
 
                     default:
                     {
                         fcvFilterCorrSepNxNs16((int16_t*)kernelX, kernelXSize, (int16_t*)src, width, rangeHeight, src_step,
-                            tmpImage, (int16_t*)dst, dst_step);
+                            tmpImage.data(), (int16_t*)dst.data(), dst_step);
                         break;
                     }
                 }
@@ -299,8 +299,8 @@ class FcvSepFilter2DLoop_Invoker : public cv::ParallelLoopBody
             }
         }
 
-        uchar* dptr = dst_data+range.start*dst_step;
-        uchar* sptr = dst+topLines*dst_step;
+        uchar *dptr = dst_data + range.start * dst_step;
+        uchar *sptr = dst.data() + topLines * dst_step;
         memcpy(dptr, sptr, (range.end - range.start) * dst_step);
     }
 

Original file line number	Diff line number	Diff line change
`@@ -38,22 +38,22 @@ class FcvGaussianBlurLoop_Invoker : public cv::ParallelLoopBody`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`const uchar* src = src_data + (range.start-topLines)*src_step;`
`41`		`- uchar dst[dst_step*rangeHeight];`
	`41`	`+ std::vector<uchar> dst(dst_step*rangeHeight);`
`42`	`42`
`43`	`43`	`if (fcvFuncType == FCV_MAKETYPE(3,CV_8U))`
`44`		`- fcvFilterGaussian3x3u8_v4(src, width, rangeHeight, src_step, dst, dst_step, fcvBorder, 0);`
	`44`	`+ fcvFilterGaussian3x3u8_v4(src, width, rangeHeight, src_step, dst.data(), dst_step, fcvBorder, 0);`
`45`	`45`	`else if (fcvFuncType == FCV_MAKETYPE(5,CV_8U))`
`46`		`- fcvFilterGaussian5x5u8_v3(src, width, rangeHeight, src_step, dst, dst_step, fcvBorder, 0);`
	`46`	`+ fcvFilterGaussian5x5u8_v3(src, width, rangeHeight, src_step, dst.data(), dst_step, fcvBorder, 0);`
`47`	`47`	`else if (fcvFuncType == FCV_MAKETYPE(5,CV_16S))`
`48`		`- fcvFilterGaussian5x5s16_v3((int16_t)src, width, rangeHeight, src_step, (int16_t)dst, dst_step, fcvBorder, 0);`
	`48`	`+ fcvFilterGaussian5x5s16_v3((int16_t)src, width, rangeHeight, src_step, (int16_t)dst.data(), dst_step, fcvBorder, 0);`
`49`	`49`	`else if (fcvFuncType == FCV_MAKETYPE(5,CV_32S))`
`50`		`- fcvFilterGaussian5x5s32_v3((int32_t)src, width, rangeHeight, src_step, (int32_t)dst, dst_step, fcvBorder, 0);`
	`50`	`+ fcvFilterGaussian5x5s32_v3((int32_t)src, width, rangeHeight, src_step, (int32_t)dst.data(), dst_step, fcvBorder, 0);`
`51`	`51`	`else if (fcvFuncType == FCV_MAKETYPE(11,CV_8U))`
`52`		`- fcvFilterGaussian11x11u8_v2(src, width, rangeHeight, src_step, dst, dst_step, fcvBorder);`
	`52`	`+ fcvFilterGaussian11x11u8_v2(src, width, rangeHeight, src_step, dst.data(), dst_step, fcvBorder);`
`53`	`53`
`54`		`- uchar* dptr = dst_data+range.start*dst_step;`
`55`		`- uchar* sptr = dst+topLines*dst_step;`
`56`		`- memcpy(dptr,sptr, (range.end-range.start)*dst_step);`
	`54`	`+ uchar dptr = dst_data + range.start dst_step;`
	`55`	`+ uchar sptr = dst.data() + topLines dst_step;`
	`56`	`+ memcpy(dptr, sptr, (range.end - range.start) * dst_step);`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`private:`
`@@ -132,17 +132,17 @@ class FcvFilter2DLoop_Invoker : public cv::ParallelLoopBody`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`const uchar src = src_data + (range.start - topLines) src_step;`
`135`		`- uchar dst[dst_step*rangeHeight];`
	`135`	`+ std::vector<uchar> dst(dst_step*rangeHeight);`
`136`	`136`
`137`	`137`	`if (ddepth == CV_8U)`
`138`		`- fcvFilterCorrNxNu8((int8_t*)kernel, ksize, 0, src, width, rangeHeight, src_step, dst, dst_step);`
	`138`	`+ fcvFilterCorrNxNu8((int8_t*)kernel, ksize, 0, src, width, rangeHeight, src_step, dst.data(), dst_step);`
`139`	`139`	`else if (ddepth == CV_16S)`
`140`		`- fcvFilterCorrNxNu8s16((int8_t)kernel, ksize, 0, src, width, rangeHeight, src_step, (int16_t)dst, dst_step);`
	`140`	`+ fcvFilterCorrNxNu8s16((int8_t)kernel, ksize, 0, src, width, rangeHeight, src_step, (int16_t)dst.data(), dst_step);`
`141`	`141`	`else if (ddepth == CV_32F)`
`142`		`- fcvFilterCorrNxNu8f32((float32_t)kernel, ksize, src, width, rangeHeight, src_step, (float32_t)dst, dst_step);`
	`142`	`+ fcvFilterCorrNxNu8f32((float32_t)kernel, ksize, src, width, rangeHeight, src_step, (float32_t)dst.data(), dst_step);`
`143`	`143`
`144`		`- uchar* dptr = dst_data+range.start*dst_step;`
`145`		`- uchar* sptr = dst+topLines*dst_step;`
	`144`	`+ uchar dptr = dst_data + range.start dst_step;`
	`145`	`+ uchar sptr = dst.data() + topLines dst_step;`
`146`	`146`	`memcpy(dptr, sptr, (range.end - range.start) * dst_step);`
`147`	`147`	`}`
`148`	`148`
`@@ -237,56 +237,56 @@ class FcvSepFilter2DLoop_Invoker : public cv::ParallelLoopBody`
`237`	`237`	`}`
`238`	`238`
`239`	`239`	`const uchar src = src_data + (range.start - topLines) src_step;`
`240`		`- uchar dst[dst_step*rangeHeight];`
	`240`	`+ std::vector<uchar> dst(dst_step*rangeHeight);`
`241`	`241`
`242`	`242`	`switch (ddepth)`
`243`	`243`	`{`
`244`	`244`	`case CV_8U:`
`245`	`245`	`{`
`246`	`246`	`fcvFilterCorrSepMxNu8((int8_t)kernelX, kernelXSize, (int8_t)kernelY, kernelYSize, 0, src, width, rangeHeight,`
`247`		`- src_step, dst, dst_step);`
	`247`	`+ src_step, dst.data(), dst_step);`
`248`	`248`	`break;`
`249`	`249`	`}`
`250`	`250`	`case CV_16S:`
`251`	`251`	`{`
`252`		`- int16_t tmpImage[width*(rangeHeight+kernelXSize-1)];`
	`252`	`+ std::vector<int16_t> tmpImage(width*(rangeHeight+kernelXSize-1));`
`253`	`253`	`switch (kernelXSize)`
`254`	`254`	`{`
`255`	`255`	`case 9:`
`256`	`256`	`{`
`257`	`257`	`fcvFilterCorrSep9x9s16_v2((int16_t)kernelX, (int16_t)src, width, rangeHeight, src_step,`
`258`		`- tmpImage, (int16_t*)dst, dst_step);`
	`258`	`+ tmpImage.data(), (int16_t*)dst.data(), dst_step);`
`259`	`259`	`break;`
`260`	`260`	`}`
`261`	`261`	`case 11:`
`262`	`262`	`{`
`263`	`263`	`fcvFilterCorrSep11x11s16_v2((int16_t)kernelX, (int16_t)src, width, rangeHeight, src_step,`
`264`		`- tmpImage, (int16_t*)dst, dst_step);`
	`264`	`+ tmpImage.data(), (int16_t*)dst.data(), dst_step);`
`265`	`265`	`break;`
`266`	`266`	`}`
`267`	`267`	`case 13:`
`268`	`268`	`{`
`269`	`269`	`fcvFilterCorrSep13x13s16_v2((int16_t)kernelX, (int16_t)src, width, rangeHeight, src_step,`
`270`		`- tmpImage, (int16_t*)dst, dst_step);`
	`270`	`+ tmpImage.data(), (int16_t*)dst.data(), dst_step);`
`271`	`271`	`break;`
`272`	`272`	`}`
`273`	`273`	`case 15:`
`274`	`274`	`{`
`275`	`275`	`fcvFilterCorrSep15x15s16_v2((int16_t)kernelX, (int16_t)src, width, rangeHeight, src_step,`
`276`		`- tmpImage, (int16_t*)dst, dst_step);`
	`276`	`+ tmpImage.data(), (int16_t*)dst.data(), dst_step);`
`277`	`277`	`break;`
`278`	`278`	`}`
`279`	`279`	`case 17:`
`280`	`280`	`{`
`281`	`281`	`fcvFilterCorrSep17x17s16_v2((int16_t)kernelX, (int16_t)src, width, rangeHeight, src_step,`
`282`		`- tmpImage, (int16_t*)dst, dst_step);`
	`282`	`+ tmpImage.data(), (int16_t*)dst.data(), dst_step);`
`283`	`283`	`break;`
`284`	`284`	`}`
`285`	`285`
`286`	`286`	`default:`
`287`	`287`	`{`
`288`	`288`	`fcvFilterCorrSepNxNs16((int16_t)kernelX, kernelXSize, (int16_t)src, width, rangeHeight, src_step,`
`289`		`- tmpImage, (int16_t*)dst, dst_step);`
	`289`	`+ tmpImage.data(), (int16_t*)dst.data(), dst_step);`
`290`	`290`	`break;`
`291`	`291`	`}`
`292`	`292`	`}`
`@@ -299,8 +299,8 @@ class FcvSepFilter2DLoop_Invoker : public cv::ParallelLoopBody`
`299`	`299`	`}`
`300`	`300`	`}`
`301`	`301`
`302`		`- uchar* dptr = dst_data+range.start*dst_step;`
`303`		`- uchar* sptr = dst+topLines*dst_step;`
	`302`	`+ uchar dptr = dst_data + range.start dst_step;`
	`303`	`+ uchar sptr = dst.data() + topLines dst_step;`
`304`	`304`	`memcpy(dptr, sptr, (range.end - range.start) * dst_step);`
`305`	`305`	`}`
`306`	`306`