Merge pull request #3931 from CodeLinaro:apreetam_5thPost

Add FastCV DSP Initialization, QcAllocator and FastCV DSP Extension APIs #3931

Merge with opencv/opencv#27290

**Detailed Description**

This PR introduces FastCV DSP Extension APIs within the '**cv::fastcv::dsp**' namespace.
The following APIs have been added:

1. **fcvdspinit**: Initializes the FastCV DSP environment.
2. **fcvdspdeinit**: Deinitializes the FastCV DSP environment.
3. **sumOfAbsoluteDiffs**: Computes the sum of absolute differences of an image against an 8x8 template.
4. **thresholdOtsu**: Binarizes a grayscale image using Otsu's method.
5. **FFT**: Computes the 1D or 2D Fast Fourier Transform of a real-valued matrix.
6. **IFFT**: Computes the 1D or 2D Inverse Fast Fourier Transform of a complex-valued matrix.
7. **canny**: Applies the Canny edge detector to an 8-bit grayscale image.
8. **filter2D**: Applies a generic 2D filter to an image.

The **QcAllocator** has been added to manage memory allocations on Qualcomm's Chipsets. This allocator ensures that matrices are allocated using the Qualcomm hardware memory allocator, providing efficient DSP operations.

Requires updated binary from: opencv/opencv_3rdparty#97
Requires binary from opencv/opencv_3rdparty#95

Lib Hash Update: opencv/opencv#27403

### 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
- [ ] The PR is proposed to the proper branch
- [ ] 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

Author: quic-apreetam

modules/fastcv/include/opencv2/fastcv.hpp

@@ -30,6 +30,13 @@
 #include "opencv2/fastcv/thresh.hpp"
 #include "opencv2/fastcv/tracking.hpp"
 #include "opencv2/fastcv/warp.hpp"
+#include "opencv2/fastcv/allocator.hpp"
+#include "opencv2/fastcv/dsp_init.hpp"
+#include "opencv2/fastcv/sad_dsp.hpp"
+#include "opencv2/fastcv/thresh_dsp.hpp"
+#include "opencv2/fastcv/fft_dsp.hpp"
+#include "opencv2/fastcv/edges_dsp.hpp"
+#include "opencv2/fastcv/blur_dsp.hpp"
 
 /**
  * @defgroup fastcv Module-wrapper for FastCV hardware accelerated functions

modules/fastcv/include/opencv2/fastcv/allocator.hpp

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2025 Qualcomm Innovation Center, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+*/
+
+#ifndef OPENCV_FASTCV_ALLOCATOR_HPP
+#define OPENCV_FASTCV_ALLOCATOR_HPP
+
+#include <opencv2/core.hpp>
+#include <set>
+#include <mutex>
+
+namespace cv {
+namespace fastcv {
+
+//! @addtogroup fastcv
+//! @{
+
+/**
+ * @brief Resource manager for FastCV allocations.
+ * This class manages active allocations.
+ */
+class QcResourceManager {
+public:
+    static QcResourceManager& getInstance();
+
+    void addAllocation(void* ptr);
+    void removeAllocation(void* ptr);
+
+private:
+    QcResourceManager() = default;
+    std::set<void*> activeAllocations;
+    std::mutex resourceMutex;
+};
+
+/**
+ * @brief Qualcomm's custom allocator.
+ * This allocator uses Qualcomm's memory management functions.
+ */
+class QcAllocator : public cv::MatAllocator {
+    public:
+        QcAllocator();
+        ~QcAllocator();
+    
+        cv::UMatData* allocate(int dims, const int* sizes, int type, void* data0, size_t* step, cv::AccessFlag flags, cv::UMatUsageFlags usageFlags) const CV_OVERRIDE;
+        bool allocate(cv::UMatData* u, cv::AccessFlag accessFlags, cv::UMatUsageFlags usageFlags) const CV_OVERRIDE;
+        void deallocate(cv::UMatData* u) const CV_OVERRIDE;
+};
+
+/**
+ * @brief Gets the default Qualcomm's allocator.
+ * This function returns a pointer to the default Qualcomm's allocator, which is optimized
+ * for use with DSP.
+ *
+ * @return Pointer to the default FastCV allocator.
+ */
+CV_EXPORTS cv::MatAllocator* getQcAllocator();
+
+//! @}
+
+} // namespace fastcv
+} // namespace cv
+
+#endif // OPENCV_FASTCV_ALLOCATOR_HPP

modules/fastcv/include/opencv2/fastcv/blur_dsp.hpp

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2025 Qualcomm Innovation Center, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+*/
+
+#ifndef OPENCV_FASTCV_BLUR_DSP_HPP
+#define OPENCV_FASTCV_BLUR_DSP_HPP
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+namespace fastcv {
+namespace dsp {
+
+//! @addtogroup fastcv
+//! @{
+
+/**
+ * @brief Filter an image with non-separable kernel
+ * @param _src Intput image with type CV_8UC1, src size should be greater than 176*144
+ * @param _dst Output image with type CV_8UC1, CV_16SC1 or CV_32FC1
+ * @param ddepth The depth of output image
+ * @param _kernel Filer kernel data
+ */
+CV_EXPORTS void filter2D(InputArray _src, OutputArray _dst, int ddepth, InputArray _kernel);
+
+//! @}
+
+} // dsp::
+} // fastcv::
+} // cv::
+
+#endif // OPENCV_FASTCV_BLUR_DSP_HPP

modules/fastcv/include/opencv2/fastcv/dsp_init.hpp

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2025 Qualcomm Innovation Center, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+*/
+
+#ifndef OPENCV_FASTCV_DSP_INIT_HPP
+#define OPENCV_FASTCV_DSP_INIT_HPP
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+namespace fastcv {
+namespace dsp {
+
+//! @addtogroup fastcv
+//! @{
+
+/**
+ * @brief Initializes the FastCV DSP environment.
+ * 
+ * This function sets up the necessary environment and resources for the DSP to operate.
+ * It must be called once at the very beginning of the use case or program to ensure that 
+ * the DSP is properly initialized before any DSP-related operations are performed.
+ *
+ * @note This function must be called at the start of the use case or program, before any 
+ *       DSP-related operations.
+ * 
+ * @return int Returns 0 on success, and a non-zero value on failure.
+ */
+CV_EXPORTS int fcvdspinit();
+
+/**
+ * @brief Deinitializes the FastCV DSP environment.
+ * 
+ * This function releases the resources and environment set up by the 'fcvdspinit' function.
+ * It should be called before the use case or program exits to ensure that all DSP resources 
+ * are properly cleaned up and no memory leaks occur.
+ *
+ * @note This function must be called at the end of the use case or program, after all DSP-related 
+ *       operations are complete.
+ */
+CV_EXPORTS void fcvdspdeinit();
+//! @}
+
+} // dsp::
+} // fastcv::
+} // cv::
+
+#endif // OPENCV_FASTCV_DSP_INIT_HPP

modules/fastcv/include/opencv2/fastcv/edges_dsp.hpp

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2025 Qualcomm Innovation Center, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+*/
+
+#ifndef OPENCV_FASTCV_EDGES_DSP_HPP
+#define OPENCV_FASTCV_EDGES_DSP_HPP
+
+#include "opencv2/core/mat.hpp"
+
+namespace cv {
+namespace fastcv {
+namespace dsp {
+
+/**
+* @defgroup fastcv Module-wrapper for FastCV hardware accelerated functions
+*/
+
+//! @addtogroup fastcv
+//! @{
+
+/**
+ * @brief Canny edge detector applied to a 8 bit grayscale image
+ * @param _src          Input image with type CV_8UC1
+ * @param _dst          Output 8-bit image containing the edge detection results
+ * @param lowThreshold  First threshold
+ * @param highThreshold Second threshold
+ * @param apertureSize  The Sobel kernel size for calculating gradient. Supported sizes are 3, 5 and 7.
+ * @param L2gradient    L2 Gradient or L1 Gradient
+*/
+CV_EXPORTS void Canny(InputArray _src, OutputArray _dst, int lowThreshold, int highThreshold, int apertureSize = 3, bool L2gradient = false);
+//! @}
+
+} // dsp::
+} // fastcv::
+} // cv::
+
+#endif //OPENCV_FASTCV_EDGES_DSP_HPP

modules/fastcv/include/opencv2/fastcv/fft_dsp.hpp

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2025 Qualcomm Innovation Center, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+*/
+
+#ifndef OPENCV_FASTCV_FFT_DSP_HPP
+#define OPENCV_FASTCV_FFT_DSP_HPP
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+namespace fastcv {
+namespace dsp {
+
+//! @addtogroup fastcv
+//! @{
+
+/**
+* @brief Computes the 1D or 2D Fast Fourier Transform of a real valued matrix.
+        For the 2D case, the width and height of the input and output matrix must be powers of 2.
+        For the 1D case, the height of the matrices must be 1, while the width must be a power of 2.
+
+* @param src Input array of CV_8UC1. The dimensions of the matrix must be powers of 2 for the 2D case,
+            and in the 1D case, the height must be 1, while the width must be a power of 2.
+* @param dst The computed FFT matrix of type CV_32FC2. The FFT Re and Im coefficients are stored in different channels.
+            Hence the dimensions of the dst are (srcWidth, srcHeight)
+*/
+CV_EXPORTS void FFT(InputArray src, OutputArray dst);
+
+/**
+* @brief Computes the 1D or 2D Inverse Fast Fourier Transform of a complex valued matrix.
+        For the 2D case, The width and height of the input and output matrix must be powers of 2.
+        For the 1D case, the height of the matrices must be 1, while the width must be a power of 2.
+
+* @param src Input array of type CV_32FC2 containing FFT Re and Im coefficients stored in separate channels.
+            The dimensions of the matrix must be powers of 2 for the 2D case, and in the 1D case, the height must be 1,
+            while the width must be a power of 2.
+* @param dst The computed IFFT matrix of type CV_8U. The matrix is real valued and has no imaginary components.
+            Hence the dimensions of the dst are (srcWidth , srcHeight)
+*/
+CV_EXPORTS void IFFT(InputArray src, OutputArray dst);
+
+//! @}
+
+} // dsp::
+} // fastcv::
+} // cv::
+
+#endif // OPENCV_FASTCV_FFT_DSP_HPP

modules/fastcv/include/opencv2/fastcv/sad_dsp.hpp

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2025 Qualcomm Innovation Center, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+*/
+
+#ifndef OPENCV_FASTCV_SAD_HPP
+#define OPENCV_FASTCV_SAD_HPP
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+namespace fastcv {
+namespace dsp {
+
+/**
+ * @defgroup fastcv Module-wrapper for FastCV hardware accelerated functions
+ */
+
+//! @addtogroup fastcv
+//! @{
+/**
+ * @brief Sum of absolute differences of an image against an 8x8 template.
+ * @param _patch The first input image data, type CV_8UC1
+ * @param _src The input image data, type CV_8UC1
+ * @param _dst The output image data, type CV_16UC1
+*/
+CV_EXPORTS void sumOfAbsoluteDiffs(cv::InputArray _patch, cv::InputArray _src, cv::OutputArray _dst);
+//! @}
+
+} // dsp::
+} // fastcv::
+} // cv::
+
+#endif // OPENCV_FASTCV_SAD_HPP

modules/fastcv/include/opencv2/fastcv/thresh_dsp.hpp

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2025 Qualcomm Innovation Center, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+*/
+
+#ifndef OPENCV_FASTCV_THRESH_DSP_HPP
+#define OPENCV_FASTCV_THRESH_DSP_HPP
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+namespace fastcv {
+namespace dsp {
+
+//! @addtogroup fastcv
+//! @{
+
+/**
+ * @brief Binarizes a grayscale image using Otsu's method.
+ *        Sets the pixel to max(255) if it's value is greater than the threshold;
+ *        else, set the pixel to min(0). The threshold is searched that minimizes
+ *        the intra-class variance (the variance within the class).
+ * 
+ * @param _src Input 8-bit grayscale image. Size of buffer is srcStride*srcHeight bytes.
+ * @param _dst Output 8-bit binarized image. Size of buffer is dstStride*srcHeight bytes.
+ * @param type Threshold type that can be either 0 or 1.
+ *             NOTE: For threshold type=0, the pixel is set as
+ *             maxValue if it's value is greater than the threshold; else, it is set as zero.
+ *             For threshold type=1, the pixel is set as zero if it's
+ *             value is greater than the threshold; else, it is set as maxValue.
+ */
+CV_EXPORTS void thresholdOtsu(InputArray _src, OutputArray _dst, bool type);
+
+//! @}
+} // dsp::
+} // fastcv::
+} // cv::
+
+#endif // OPENCV_FASTCV_THRESH_DSP_HPP