Add dft and gemm to ocl module, using AMD's clAmdFft and clAmdBlas libraries

CMakeLists.txt

@@ -140,6 +140,9 @@ OCV_OPTION(WITH_XIMEA          "Include XIMEA cameras support"               OFF
 OCV_OPTION(WITH_XINE           "Include Xine support (GPL)"                  OFF  IF (UNIX AND NOT APPLE AND NOT ANDROID) )
 OCV_OPTION(WITH_CLP            "Include Clp support (EPL)"                   OFF)
 OCV_OPTION(WITH_OPENCL         "Include OpenCL Runtime support"              OFF  IF (NOT ANDROID AND NOT IOS) )
+OCV_OPTION(WITH_OPENCLAMDFFT   "Include AMD OpenCL FFT library support"      OFF  IF (NOT ANDROID AND NOT IOS) )
+OCV_OPTION(WITH_OPENCLAMDBLAS  "Include AMD OpenCL BLAS library support"     OFF  IF (NOT ANDROID AND NOT IOS) )
+
 
 # OpenCV build components
 # ===================================================
@@ -396,6 +399,12 @@ if(WITH_OPENCL)
   if(OPENCL_FOUND)
     set(HAVE_OPENCL 1)
   endif()
+  if(WITH_OPENCLAMDFFT)
+    set(HAVE_CLAMDFFT 1)
+  endif()
+  if(WITH_OPENCLAMDBLAS)
+    set(HAVE_CLAMDBLAS 1)
+  endif()
 endif()
 
 # ----------------------------------------------------------------------------

cmake/OpenCVDetectOpenCL.cmake

@@ -2,8 +2,19 @@ if(APPLE)
     set(OPENCL_FOUND YES)
     set(OPENCL_LIBRARIES "-framework OpenCL")
 else()
-    find_package(OpenCL QUIET)
-
+    #find_package(OpenCL QUIET)
+	if(WITH_OPENCLAMDFFT)
+            find_path(CLAMDFFT_INCLUDE_DIR
+                NAMES clAmdFft.h)
+            find_library(CLAMDFFT_LIBRARIES
+                NAMES clAmdFft.Runtime)
+	endif()
+	if(WITH_OPENCLAMDBLAS)
+            find_path(CLAMDBLAS_INCLUDE_DIR
+                NAMES clAmdBlas.h)
+            find_library(CLAMDBLAS_LIBRARIES
+                NAMES clAmdBlas)
+	endif()
     # Try AMD/ATI Stream SDK
     if (NOT OPENCL_FOUND)
         set(ENV_AMDSTREAMSDKROOT $ENV{AMDAPPSDKROOT})

cmake/templates/cvconfig.h.cmake

@@ -175,6 +175,12 @@
 /* OpenCL Support */
 #cmakedefine HAVE_OPENCL
 
+/* AMD's OpenCL Fast Fourier Transform Library*/ 
+#cmakedefine HAVE_CLAMDFFT
+
+/* AMD's Basic Linear Algebra Subprograms Library*/
+#cmakedefine HAVE_CLAMDBLAS
+
 /* NVidia Cuda Fast Fourier Transform (FFT) API*/
 #cmakedefine HAVE_CUFFT
 

modules/ocl/CMakeLists.txt

@@ -29,6 +29,14 @@ if (HAVE_OPENCL)
   if(OPENCL_INCLUDE_DIR)
       ocv_include_directories(${OPENCL_INCLUDE_DIR})
   endif()
+  if (HAVE_CLAMDFFT)
+	set(ocl_link_libs ${ocl_link_libs} ${CLAMDFFT_LIBRARIES})
+	ocv_include_directories(${CLAMDFFT_INCLUDE_DIR})
+  endif()
+  if (HAVE_CLAMDBLAS)
+	set(ocl_link_libs ${ocl_link_libs} ${CLAMDBLAS_LIBRARIES})
+	ocv_include_directories(${CLAMDBLAS_INCLUDE_DIR})
+  endif()
 endif()
 
 ocv_set_module_sources(

modules/ocl/include/opencv2/ocl/ocl.hpp

@@ -894,7 +894,35 @@ namespace cv
 		// Supports TM_SQDIFF, TM_CCORR for type 32FC1 and 32FC4
 		CV_EXPORTS void matchTemplate(const oclMat& image, const oclMat& templ, oclMat& result, int method, MatchTemplateBuf& buf);
 
-
+#ifdef HAVE_CLAMDFFT
+            ///////////////////////////////////////// clAmdFft related /////////////////////////////////////////
+            // the two functions must be called before/after run any fft library functions.
+            CV_EXPORTS void fft_setup();    // this will be implicitly invoked
+            CV_EXPORTS void fft_teardown(); // you need to teardown fft library manually
+
+		    /////////////////////////////////////// DFT /////////////////////////////////////////////////////
+		    //! Performs a forward or inverse discrete Fourier transform (1D or 2D) of floating point matrix.
+		    //! Param dft_size is the size of DFT transform.
+		    //!
+		    //! For complex-to-real transform it is assumed that the source matrix is packed in CLFFT's format.
+		    // support src type of CV32FC1, CV32FC2
+		    // support flags: DFT_INVERSE, DFT_REAL_OUTPUT, DFT_COMPLEX_OUTPUT, DFT_ROWS
+		    // dft_size is the size of original input, which is used for transformation from complex to real.
+		    // dft_size must be powers of 2, 3 and 5
+		    // real to complex dft requires at least v1.8 clAmdFft
+		    // real to complex dft output is not the same with cpu version
+		    // real to complex and complex to real does not support DFT_ROWS
+		    CV_EXPORTS void dft(const oclMat& src, oclMat& dst, Size dft_size = Size(0, 0), int flags = 0);
+#endif // HAVE_CLAMDFFT
+
+#ifdef HAVE_CLAMDBLAS
+		//! implements generalized matrix product algorithm GEMM from BLAS
+		// The functionality requires clAmdBlas library
+		// only support type CV_32FC1
+		// flag GEMM_3_T is not supported
+		CV_EXPORTS void gemm(const oclMat& src1, const oclMat& src2, double alpha,
+		const oclMat& src3, double beta, oclMat& dst, int flags = 0);
+#endif
 
     }
 }

modules/ocl/src/gemm.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Peng Xiao, pengxiao@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other oclMaterials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include <iomanip>
+#include "precomp.hpp"
+
+#ifdef HAVE_CLAMDBLAS
+
+#include "clAmdBlas.h"
+
+#if !defined (HAVE_OPENCL)
+void cv::ocl::dft(const oclMat& src, oclMat& dst, int flags) { throw_nogpu(); }
+#else
+
+using namespace cv;
+
+	void cv::ocl::gemm(const oclMat& src1, const oclMat& src2, double alpha,
+		const oclMat& src3, double beta, oclMat& dst, int flags)
+	{
+		CV_Assert(src1.cols == src2.rows && 
+			(src3.empty() || src1.rows == src3.rows && src2.cols == src3.cols));
+		CV_Assert(!(cv::GEMM_3_T & flags)); // cv::GEMM_3_T is not supported
+		if(!src3.empty())
+		{
+			src3.copyTo(dst);
+		}
+		else
+		{
+			dst.create(src1.rows, src2.cols, src1.type());
+			dst.setTo(Scalar::all(0));
+		}
+		openCLSafeCall( clAmdBlasSetup() );
+		
+		const clAmdBlasTranspose transA = (cv::GEMM_1_T & flags)?clAmdBlasTrans:clAmdBlasNoTrans;
+		const clAmdBlasTranspose transB = (cv::GEMM_2_T & flags)?clAmdBlasTrans:clAmdBlasNoTrans;
+		const clAmdBlasOrder     order  = clAmdBlasRowMajor;
+
+		const int M = src1.rows;
+		const int N = src2.cols;
+		const int K = src1.cols;
+		int lda     = src1.step;
+		int ldb     = src2.step;
+		int ldc     = dst.step;
+		int offa    = src1.offset;
+		int offb    = src2.offset;
+		int offc    = dst.offset;
+
+
+		switch(src1.type())
+		{
+		case CV_32FC1:
+			lda  /= sizeof(float);
+			ldb  /= sizeof(float);
+			ldc  /= sizeof(float);
+			offa /= sizeof(float);
+			offb /= sizeof(float);
+			offc /= sizeof(float);
+			openCLSafeCall
+			(
+				clAmdBlasSgemmEx(order, transA, transB, M, N, K,
+					alpha, (const cl_mem)src1.data, offa, lda, (const cl_mem)src2.data, offb, ldb, 
+					beta, (cl_mem)dst.data, offc, ldc, 1, &src1.clCxt->impl->clCmdQueue, 0, NULL, NULL)
+			);
+			break;
+		case CV_64FC1:
+			lda  /= sizeof(double);
+			ldb  /= sizeof(double);
+			ldc  /= sizeof(double);
+			offa /= sizeof(double);
+			offb /= sizeof(double);
+			offc /= sizeof(double);
+			openCLSafeCall
+			(
+				clAmdBlasDgemmEx(order, transA, transB, M, N, K,
+					alpha, (const cl_mem)src1.data, offa, lda, (const cl_mem)src2.data, offb, ldb, 
+					beta, (cl_mem)dst.data, offc, ldc, 1, &src1.clCxt->impl->clCmdQueue, 0, NULL, NULL)
+			);
+			break;
+		case CV_32FC2:
+			{
+				lda  /= sizeof(std::complex<float>);
+				ldb  /= sizeof(std::complex<float>);
+				ldc  /= sizeof(std::complex<float>);
+				offa /= sizeof(std::complex<float>);
+				offb /= sizeof(std::complex<float>);
+				offc /= sizeof(std::complex<float>);
+				cl_float2 alpha_2 = {{alpha, 0}};
+				cl_float2 beta_2  = {{beta, 0}};
+				openCLSafeCall
+				(
+					clAmdBlasCgemmEx(order, transA, transB, M, N, K,
+						alpha_2, (const cl_mem)src1.data, offa, lda, (const cl_mem)src2.data, offb, ldb, 
+						beta_2, (cl_mem)dst.data, offc, ldc, 1, &src1.clCxt->impl->clCmdQueue, 0, NULL, NULL)
+				);
+			}
+			break;
+		case CV_64FC2:
+			{
+				lda  /= sizeof(std::complex<double>);
+				ldb  /= sizeof(std::complex<double>);
+				ldc  /= sizeof(std::complex<double>);
+				offa /= sizeof(std::complex<double>);
+				offb /= sizeof(std::complex<double>);
+				offc /= sizeof(std::complex<double>);
+				cl_double2 alpha_2 = {{alpha, 0}};
+				cl_double2 beta_2  = {{beta, 0}};
+				openCLSafeCall
+				(
+					clAmdBlasZgemmEx(order, transA, transB, M, N, K,
+						alpha_2, (const cl_mem)src1.data, offa, lda, (const cl_mem)src2.data, offb, ldb, 
+						beta_2, (cl_mem)dst.data, offc, ldc, 1, &src1.clCxt->impl->clCmdQueue, 0, NULL, NULL)
+				);
+			}
+			break;
+		}
+		clAmdBlasTeardown();
+	}
+#endif
+#endif

modules/ocl/test/test_fft.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Peng Xiao, pengxiao@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other oclMaterials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+using namespace std;
+#ifdef HAVE_CLAMDFFT
+////////////////////////////////////////////////////////////////////////////
+// Dft
+PARAM_TEST_CASE(Dft, cv::Size, bool) 
+{
+	cv::Size dft_size;
+	bool	 dft_rows;
+	std::vector<cv::ocl::Info> oclinfo;
+    virtual void SetUp()
+    {
+	    int devnums = getDevice(oclinfo);
+        CV_Assert(devnums > 0);
+		dft_size = GET_PARAM(0);
+		dft_rows = GET_PARAM(1);
+    }
+};
+
+TEST_P(Dft, C2C)
+{
+	cv::Mat a = randomMat(dft_size, CV_32FC2, 0.0, 10.0);
+	cv::Mat b_gold;
+	int flags = 0;
+	flags |= dft_rows ? cv::DFT_ROWS : 0;
+
+	cv::ocl::oclMat d_b;
+	
+	cv::dft(a, b_gold, flags);
+	cv::ocl::dft(cv::ocl::oclMat(a), d_b, a.size(), flags);
+	EXPECT_MAT_NEAR(b_gold, cv::Mat(d_b), a.size().area() * 1e-4, "");
+}
+
+
+TEST_P(Dft, R2CthenC2R)
+{
+	cv::Mat a = randomMat(dft_size, CV_32FC1, 0.0, 10.0);
+	
+	int flags = 0;
+	//flags |= dft_rows ? cv::DFT_ROWS : 0; // not supported yet
+
+	cv::ocl::oclMat d_b, d_c;
+	cv::ocl::dft(cv::ocl::oclMat(a), d_b, a.size(), flags);
+	cv::ocl::dft(d_b, d_c, a.size(), flags + cv::DFT_INVERSE + cv::DFT_REAL_OUTPUT);
+	EXPECT_MAT_NEAR(a, d_c, a.size().area() * 1e-4, "");
+}
+
+INSTANTIATE_TEST_CASE_P(ocl_DFT, Dft, testing::Combine(
+    testing::Values(cv::Size(5, 4), cv::Size(20, 20)),
+    testing::Values(false, true)));
+
+#endif // HAVE_CLAMDFFT

modules/ocl/test/test_gemm.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Peng Xiao, pengxiao@multicorewareinc.com
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other oclMaterials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+
+#include "precomp.hpp"
+using namespace std;
+#ifdef HAVE_CLAMDBLAS
+////////////////////////////////////////////////////////////////////////////
+// GEMM
+PARAM_TEST_CASE(Gemm, int, cv::Size, int) 
+{
+	int      type;
+	cv::Size mat_size;
+	int		 flags;
+	vector<cv::ocl::Info> info;
+    virtual void SetUp()
+    {
+		type     = GET_PARAM(0);
+		mat_size = GET_PARAM(1);
+		flags    = GET_PARAM(2);
+		cv::ocl::getDevice(info);
+    }
+};
+
+TEST_P(Gemm, Accuracy)
+{
+	cv::Mat a = randomMat(mat_size, type, 0.0, 10.0);
+	cv::Mat b = randomMat(mat_size, type, 0.0, 10.0);
+	cv::Mat c = randomMat(mat_size, type, 0.0, 10.0);
+
+	cv::Mat dst;
+	cv::ocl::oclMat ocl_dst;
+
+	cv::gemm(a, b, 1.0, c, 1.0, dst, flags);
+	cv::ocl::gemm(cv::ocl::oclMat(a), cv::ocl::oclMat(b), 1.0, cv::ocl::oclMat(c), 1.0, ocl_dst, flags);
+
+	EXPECT_MAT_NEAR(dst, ocl_dst, mat_size.area() * 1e-4, "");
+}
+
+INSTANTIATE_TEST_CASE_P(ocl_gemm, Gemm, testing::Combine(
+	testing::Values(CV_32FC1, CV_32FC2/*, CV_64FC1, CV_64FC2*/),
+    testing::Values(cv::Size(20, 20), cv::Size(300, 300)),
+    testing::Values(0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_1_T + cv::GEMM_2_T)));
+#endif