diff --git a/3rdparty/ffmpeg/ffmpeg.cmake b/3rdparty/ffmpeg/ffmpeg.cmake index 3cd5e1be94..764e4b19d8 100644 --- a/3rdparty/ffmpeg/ffmpeg.cmake +++ b/3rdparty/ffmpeg/ffmpeg.cmake @@ -1,9 +1,9 @@ -# Binaries branch name: ffmpeg/master_20210303 -# Binaries were created for OpenCV: 7ac6abe02a33bef445a5b77214ad31964e2c5cc1 -ocv_update(FFMPEG_BINARIES_COMMIT "629590c3ba09fb0c8eaa9ab858ff13d3a84ca1aa") -ocv_update(FFMPEG_FILE_HASH_BIN32 "638065d5a0dab8a828879942375dcac4") -ocv_update(FFMPEG_FILE_HASH_BIN64 "7f10ae2e6a080ba3714f7a38ee03ae15") -ocv_update(FFMPEG_FILE_HASH_CMAKE "f8e65dbe4a3b4eedc0d2997e07c3f3fd") +# Binaries branch name: ffmpeg/master_20210608 +# Binaries were created for OpenCV: eaa9228a4fdfb9c2465aea65a50ce2d16b55dce0 +ocv_update(FFMPEG_BINARIES_COMMIT "213fcd5d4897319a83207406036c4a5957fba010") +ocv_update(FFMPEG_FILE_HASH_BIN32 "bab661341c30862fa88627130219c0a5") +ocv_update(FFMPEG_FILE_HASH_BIN64 "ac99f9767a83103c31709628af685924") +ocv_update(FFMPEG_FILE_HASH_CMAKE "8862c87496e2e8c375965e1277dee1c7") function(download_win_ffmpeg script_var) set(${script_var} "" PARENT_SCOPE) diff --git a/CMakeLists.txt b/CMakeLists.txt index eef357e8ba..be47c27f4a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -468,6 +468,7 @@ OCV_OPTION(BUILD_ANDROID_SERVICE "Build OpenCV Manager for Google Play" OFF I OCV_OPTION(BUILD_CUDA_STUBS "Build CUDA modules stubs when no CUDA SDK" OFF IF (NOT APPLE_FRAMEWORK) ) OCV_OPTION(BUILD_JAVA "Enable Java support" (ANDROID OR NOT CMAKE_CROSSCOMPILING) IF (ANDROID OR (NOT APPLE_FRAMEWORK AND NOT WINRT)) ) OCV_OPTION(BUILD_OBJC "Enable Objective-C support" ON IF APPLE_FRAMEWORK ) +OCV_OPTION(BUILD_KOTLIN_EXTENSIONS "Build Kotlin extensions (Android)" ON IF ANDROID ) # OpenCV installation options # =================================================== diff --git a/cmake/android/android_gradle_projects.cmake b/cmake/android/android_gradle_projects.cmake index 2e34a20d97..e07d26b5bb 100644 --- a/cmake/android/android_gradle_projects.cmake +++ b/cmake/android/android_gradle_projects.cmake @@ -2,6 +2,17 @@ set(ANDROID_GRADLE_PLUGIN_VERSION "3.2.1" CACHE STRING "Android Gradle Plugin version") message(STATUS "Android Gradle Plugin version: ${ANDROID_GRADLE_PLUGIN_VERSION}") +set(KOTLIN_PLUGIN_VERSION "1.4.10" CACHE STRING "Kotlin Plugin version") +message(STATUS "kotlin Plugin version: ${KOTLIN_GRADLE_PLUGIN_VERSION}") + +if(BUILD_KOTLIN_EXTENSIONS) + set(KOTLIN_PLUGIN_DECLARATION "apply plugin: 'kotlin-android'" CACHE STRING "Kotlin Plugin version") + set(KOTLIN_STD_LIB "implementation 'org.jetbrains.kotlin:kotlin-stdlib:${KOTLIN_PLUGIN_VERSION}'" CACHE STRING "Kotlin Standard Library dependency") +else() + set(KOTLIN_PLUGIN_DECLARATION "" CACHE STRING "Kotlin Plugin version") + set(KOTLIN_STD_LIB "" CACHE STRING "Kotlin Standard Library dependency") +endif() + set(GRADLE_VERSION "5.6.4" CACHE STRING "Gradle version") message(STATUS "Gradle version: ${GRADLE_VERSION}") diff --git a/modules/3d/include/opencv2/3d.hpp b/modules/3d/include/opencv2/3d.hpp index 2d5f1c6c2c..a2a28cddae 100644 --- a/modules/3d/include/opencv2/3d.hpp +++ b/modules/3d/include/opencv2/3d.hpp @@ -620,7 +620,7 @@ CV_EXPORTS_W Mat findHomography(InputArray srcPoints, InputArray dstPoints, Outp @param Qz Optional output 3x3 rotation matrix around z-axis. The function computes a RQ decomposition using the given rotations. This function is used in -decomposeProjectionMatrix to decompose the left 3x3 submatrix of a projection matrix into a camera +#decomposeProjectionMatrix to decompose the left 3x3 submatrix of a projection matrix into a camera and a rotation matrix. It optionally returns three rotation matrices, one for each axis, and the three Euler angles in @@ -674,7 +674,7 @@ CV_EXPORTS_W void decomposeProjectionMatrix( InputArray projMatrix, OutputArray The function computes partial derivatives of the elements of the matrix product \f$A*B\f$ with regard to the elements of each of the two input matrices. The function is used to compute the Jacobian -matrices in stereoCalibrate but can also be used in any other similar optimization function. +matrices in #stereoCalibrate but can also be used in any other similar optimization function. */ CV_EXPORTS_W void matMulDeriv( InputArray A, InputArray B, OutputArray dABdA, OutputArray dABdB ); @@ -703,7 +703,7 @@ where \f$\mathrm{rodrigues}\f$ denotes a rotation vector to a rotation matrix tr \f$\mathrm{rodrigues}^{-1}\f$ denotes the inverse transformation. See Rodrigues for details. Also, the functions can compute the derivatives of the output vectors with regards to the input -vectors (see matMulDeriv ). The functions are used inside stereoCalibrate but can also be used in +vectors (see matMulDeriv ). The functions are used inside #stereoCalibrate but can also be used in your own code where Levenberg-Marquardt or another gradient-based solver is used to optimize a function that contains a matrix multiplication. */ @@ -934,7 +934,7 @@ a 3D point expressed in the world frame into the camera frame: arrays (enforced by the assertion using cv::Mat::checkVector() around line 55 of modules/3d/src/solvepnp.cpp version 2.4.9) - The P3P algorithm requires image points to be in an array of shape (N,1,2) due - to its calling of cv::undistortPoints (around line 75 of modules/3d/src/solvepnp.cpp version 2.4.9) + to its calling of #undistortPoints (around line 75 of modules/3d/src/solvepnp.cpp version 2.4.9) which requires 2-channel information. - Thus, given some data D = np.array(...) where D.shape = (N,M), in order to use a subset of it as, e.g., imagePoints, one must effectively copy it into a new array: imagePoints = @@ -1140,7 +1140,7 @@ vectors, respectively, and further optimizes them. - @ref SOLVEPNP_ITERATIVE Iterative method is based on a Levenberg-Marquardt optimization. In this case the function finds such a pose that minimizes reprojection error, that is the sum of squared distances between the observed projections imagePoints and the projected (using -projectPoints ) objectPoints . + #projectPoints ) objectPoints . - @ref SOLVEPNP_P3P Method is based on the paper of X.S. Gao, X.-R. Hou, J. Tang, H.-F. Chang "Complete Solution Classification for the Perspective-Three-Point Problem" (@cite gao2003complete). In this case the function requires exactly four object and image points. @@ -1276,7 +1276,7 @@ a 3D point expressed in the world frame into the camera frame: arrays (enforced by the assertion using cv::Mat::checkVector() around line 55 of modules/3d/src/solvepnp.cpp version 2.4.9) - The P3P algorithm requires image points to be in an array of shape (N,1,2) due - to its calling of undistortPoints (around line 75 of modules/3d/src/solvepnp.cpp version 2.4.9) + to its calling of #undistortPoints (around line 75 of modules/3d/src/solvepnp.cpp version 2.4.9) which requires 2-channel information. - Thus, given some data D = np.array(...) where D.shape = (N,M), in order to use a subset of it as, e.g., imagePoints, one must effectively copy it into a new array: imagePoints = @@ -1357,7 +1357,7 @@ CV_EXPORTS_W void convertPointsFromHomogeneous( InputArray src, OutputArray dst, @param dst Output vector of 2D, 3D, or 4D points. The function converts 2D or 3D points from/to homogeneous coordinates by calling either -convertPointsToHomogeneous or convertPointsFromHomogeneous. +#convertPointsToHomogeneous or #convertPointsFromHomogeneous. @note The function is obsolete. Use one of the previous two functions instead. */ @@ -1396,7 +1396,7 @@ matrices sequentially). The calculated fundamental matrix may be passed further to computeCorrespondEpilines that finds the epipolar lines corresponding to the specified points. It can also be passed to -stereoRectifyUncalibrated to compute the rectification transformation. : +#stereoRectifyUncalibrated to compute the rectification transformation. : @code // Example. Estimation of fundamental matrix using the RANSAC algorithm int point_count = 100; @@ -1441,7 +1441,7 @@ be floating-point (single or double precision). @param cameraMatrix Camera intrinsic matrix \f$\cameramatrix{A}\f$ . Note that this function assumes that points1 and points2 are feature points from cameras with the same camera intrinsic matrix. If this assumption does not hold for your use case, use -`undistortPoints()` with `P = cv::NoArray()` for both cameras to transform image points +#undistortPoints with `P = cv::NoArray()` for both cameras to transform image points to normalized image coordinates, which are valid for the identity camera intrinsic matrix. When passing these coordinates, pass the identity matrix for this parameter. @param method Method for computing an essential matrix. @@ -1464,7 +1464,7 @@ This function estimates essential matrix based on the five-point algorithm solve where \f$E\f$ is an essential matrix, \f$p_1\f$ and \f$p_2\f$ are corresponding points in the first and the second images, respectively. The result of this function may be passed further to -decomposeEssentialMat or recoverPose to recover the relative pose between cameras. +#decomposeEssentialMat or #recoverPose to recover the relative pose between cameras. */ CV_EXPORTS_W Mat findEssentialMat( @@ -1539,13 +1539,13 @@ be floating-point (single or double precision). @param cameraMatrix1 Camera matrix \f$K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$ . Note that this function assumes that points1 and points2 are feature points from cameras with the same camera matrix. If this assumption does not hold for your use case, use -`undistortPoints()` with `P = cv::NoArray()` for both cameras to transform image points +#undistortPoints with `P = cv::NoArray()` for both cameras to transform image points to normalized image coordinates, which are valid for the identity camera matrix. When passing these coordinates, pass the identity matrix for this parameter. @param cameraMatrix2 Camera matrix \f$K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$ . Note that this function assumes that points1 and points2 are feature points from cameras with the same camera matrix. If this assumption does not hold for your use case, use -`undistortPoints()` with `P = cv::NoArray()` for both cameras to transform image points +#undistortPoints with `P = cv::NoArray()` for both cameras to transform image points to normalized image coordinates, which are valid for the identity camera matrix. When passing these coordinates, pass the identity matrix for this parameter. @param distCoeffs1 Input vector of distortion coefficients @@ -1573,7 +1573,7 @@ This function estimates essential matrix based on the five-point algorithm solve where \f$E\f$ is an essential matrix, \f$p_1\f$ and \f$p_2\f$ are corresponding points in the first and the second images, respectively. The result of this function may be passed further to -decomposeEssentialMat or recoverPose to recover the relative pose between cameras. +#decomposeEssentialMat or #recoverPose to recover the relative pose between cameras. */ CV_EXPORTS_W Mat findEssentialMat( InputArray points1, InputArray points2, InputArray cameraMatrix1, InputArray distCoeffs1, @@ -1635,7 +1635,7 @@ possible pose hypotheses by doing cheirality check. The cheirality check means t triangulated 3D points should have positive depth. Some details can be found in @cite Nister03. This function can be used to process the output E and mask from @ref findEssentialMat. In this -scenario, points1 and points2 are the same input for findEssentialMat.: +scenario, points1 and points2 are the same input for #findEssentialMat : @code // Example. Estimation of fundamental matrix using the RANSAC algorithm int point_count = 100; @@ -1731,14 +1731,14 @@ CV_EXPORTS_W int recoverPose( InputArray E, InputArray points1, InputArray point @param points Input points. \f$N \times 1\f$ or \f$1 \times N\f$ matrix of type CV_32FC2 or vector\ . @param whichImage Index of the image (1 or 2) that contains the points . -@param F Fundamental matrix that can be estimated using findFundamentalMat or stereoRectify . +@param F Fundamental matrix that can be estimated using #findFundamentalMat or #stereoRectify . @param lines Output vector of the epipolar lines corresponding to the points in the other image. Each line \f$ax + by + c=0\f$ is encoded by 3 numbers \f$(a, b, c)\f$ . For every point in one of the two images of a stereo pair, the function finds the equation of the corresponding epipolar line in the other image. -From the fundamental matrix definition (see findFundamentalMat ), line \f$l^{(2)}_i\f$ in the second +From the fundamental matrix definition (see #findFundamentalMat ), line \f$l^{(2)}_i\f$ in the second image for the point \f$p^{(1)}_i\f$ in the first image (when whichImage=1 ) is computed as: \f[l^{(2)}_i = F p^{(1)}_i\f] @@ -1798,7 +1798,6 @@ geometric distance between points \f$a\f$ and \f$b\f$ ) subject to the epipolar CV_EXPORTS_W void correctMatches( InputArray F, InputArray points1, InputArray points2, OutputArray newPoints1, OutputArray newPoints2 ); - /** @brief Calculates the Sampson Distance between two points. The function cv::sampsonDistance calculates and returns the first order approximation of the geometric error as: @@ -1810,7 +1809,7 @@ sd( \texttt{pt1} , \texttt{pt2} )= ((\texttt{F}^t \cdot \texttt{pt2})(0))^2 + ((\texttt{F}^t \cdot \texttt{pt2})(1))^2} \f] -The fundamental matrix may be calculated using the cv::findFundamentalMat function. See @cite HartleyZ00 11.4.3 for details. +The fundamental matrix may be calculated using the #findFundamentalMat function. See @cite HartleyZ00 11.4.3 for details. @param pt1 first homogeneous 2d point @param pt2 second homogeneous 2d point @param F fundamental matrix @@ -2104,10 +2103,10 @@ CV_EXPORTS_W int decomposeHomographyMat(InputArray H, @param beforePoints Vector of (rectified) visible reference points before the homography is applied @param afterPoints Vector of (rectified) visible reference points after the homography is applied @param possibleSolutions Vector of int indices representing the viable solution set after filtering -@param pointsMask optional Mat/Vector of 8u type representing the mask for the inliers as given by the findHomography function +@param pointsMask optional Mat/Vector of 8u type representing the mask for the inliers as given by the #findHomography function -This function is intended to filter the output of the decomposeHomographyMat based on additional -information as described in @cite Malis . The summary of the method: the decomposeHomographyMat function +This function is intended to filter the output of the #decomposeHomographyMat based on additional +information as described in @cite Malis . The summary of the method: the #decomposeHomographyMat function returns 2 unique solutions and their "opposites" for a total of 4 solutions. If we have access to the sets of points visible in the camera frame before and after the homography transformation is applied, we can determine which are the true potential solutions and which are the opposites by verifying which @@ -2166,7 +2165,7 @@ CV_EXPORTS_W void undistort( InputArray src, OutputArray dst, /** @brief Computes the undistortion and rectification transformation map. The function computes the joint undistortion and rectification transformation and represents the -result in the form of maps for remap. The undistorted image looks like original, as if it is +result in the form of maps for #remap. The undistorted image looks like original, as if it is captured with a camera using the camera matrix =newCameraMatrix and zero distortion. In case of a monocular camera, newCameraMatrix is usually equal to cameraMatrix, or it can be computed by #getOptimalNewCameraMatrix for a better control over scaling. In case of a stereo camera, @@ -2176,7 +2175,7 @@ Also, this new camera is oriented differently in the coordinate space, according example, helps to align two heads of a stereo camera so that the epipolar lines on both images become horizontal and have the same y- coordinate (in case of a horizontally aligned stereo camera). -The function actually builds the maps for the inverse mapping algorithm that is used by remap. That +The function actually builds the maps for the inverse mapping algorithm that is used by #remap. That is, for each pixel \f$(u, v)\f$ in the destination (corrected and rectified) image, the function computes the corresponding coordinates in the source image (that is, in the original image from camera). The following process is applied: @@ -2204,7 +2203,7 @@ where \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x are the distortion coefficients. In case of a stereo camera, this function is called twice: once for each camera head, after -stereoRectify, which in its turn is called after #stereoCalibrate. But if the stereo camera +#stereoRectify, which in its turn is called after #stereoCalibrate. But if the stereo camera was not calibrated, it is still possible to compute the rectification transformations directly from the fundamental matrix using #stereoRectifyUncalibrated. For each camera, the function computes homography H as the rectification transformation in a pixel domain, not a rotation matrix R in 3D @@ -2230,6 +2229,77 @@ void initUndistortRectifyMap(InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, Size size, int m1type, OutputArray map1, OutputArray map2); +/** @brief Computes the projection and inverse-rectification transformation map. In essense, this is the inverse of +#initUndistortRectifyMap to accomodate stereo-rectification of projectors ('inverse-cameras') in projector-camera pairs. + +The function computes the joint projection and inverse rectification transformation and represents the +result in the form of maps for #remap. The projected image looks like a distorted version of the original which, +once projected by a projector, should visually match the original. In case of a monocular camera, newCameraMatrix +is usually equal to cameraMatrix, or it can be computed by +#getOptimalNewCameraMatrix for a better control over scaling. In case of a projector-camera pair, +newCameraMatrix is normally set to P1 or P2 computed by #stereoRectify . + +The projector is oriented differently in the coordinate space, according to R. In case of projector-camera pairs, +this helps align the projector (in the same manner as #initUndistortRectifyMap for the camera) to create a stereo-rectified pair. This +allows epipolar lines on both images to become horizontal and have the same y-coordinate (in case of a horizontally aligned projector-camera pair). + +The function builds the maps for the inverse mapping algorithm that is used by #remap. That +is, for each pixel \f$(u, v)\f$ in the destination (projected and inverse-rectified) image, the function +computes the corresponding coordinates in the source image (that is, in the original digital image). The following process is applied: + +\f[ +\begin{array}{l} +\text{newCameraMatrix}\\ +x \leftarrow (u - {c'}_x)/{f'}_x \\ +y \leftarrow (v - {c'}_y)/{f'}_y \\ + +\\\text{Undistortion} +\\\scriptsize{\textit{though equation shown is for radial undistortion, function implements cv::undistortPoints()}}\\ +r^2 \leftarrow x^2 + y^2 \\ +\theta \leftarrow \frac{1 + k_1 r^2 + k_2 r^4 + k_3 r^6}{1 + k_4 r^2 + k_5 r^4 + k_6 r^6}\\ +x' \leftarrow \frac{x}{\theta} \\ +y' \leftarrow \frac{y}{\theta} \\ + +\\\text{Rectification}\\ +{[X\,Y\,W]} ^T \leftarrow R*[x' \, y' \, 1]^T \\ +x'' \leftarrow X/W \\ +y'' \leftarrow Y/W \\ + +\\\text{cameraMatrix}\\ +map_x(u,v) \leftarrow x'' f_x + c_x \\ +map_y(u,v) \leftarrow y'' f_y + c_y +\end{array} +\f] +where \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\f$ +are the distortion coefficients vector distCoeffs. + +In case of a stereo-rectified projector-camera pair, this function is called for the projector while #initUndistortRectifyMap is called for the camera head. +This is done after #stereoRectify, which in turn is called after #stereoCalibrate. If the projector-camera pair +is not calibrated, it is still possible to compute the rectification transformations directly from +the fundamental matrix using #stereoRectifyUncalibrated. For the projector and camera, the function computes +homography H as the rectification transformation in a pixel domain, not a rotation matrix R in 3D +space. R can be computed from H as +\f[\texttt{R} = \texttt{cameraMatrix} ^{-1} \cdot \texttt{H} \cdot \texttt{cameraMatrix}\f] +where cameraMatrix can be chosen arbitrarily. + +@param cameraMatrix Input camera matrix \f$A=\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$ . +@param distCoeffs Input vector of distortion coefficients +\f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\f$ +of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed. +@param R Optional rectification transformation in the object space (3x3 matrix). R1 or R2, +computed by #stereoRectify can be passed here. If the matrix is empty, the identity transformation +is assumed. +@param newCameraMatrix New camera matrix \f$A'=\vecthreethree{f_x'}{0}{c_x'}{0}{f_y'}{c_y'}{0}{0}{1}\f$. +@param size Distorted image size. +@param m1type Type of the first output map. Can be CV_32FC1, CV_32FC2 or CV_16SC2, see #convertMaps +@param map1 The first output map for #remap. +@param map2 The second output map for #remap. + */ +CV_EXPORTS_W +void initInverseRectificationMap( InputArray cameraMatrix, InputArray distCoeffs, + InputArray R, InputArray newCameraMatrix, + const Size& size, int m1type, OutputArray map1, OutputArray map2 ); + //! initializes maps for #remap for wide-angle CV_EXPORTS float initWideAngleProjMap(InputArray cameraMatrix, InputArray distCoeffs, @@ -2305,10 +2375,10 @@ assumed. @param imageSize Original image size. @param alpha Free scaling parameter between 0 (when all the pixels in the undistorted image are valid) and 1 (when all the source image pixels are retained in the undistorted image). See -stereoRectify for details. +#stereoRectify for details. @param newImgSize Image size after rectification. By default, it is set to imageSize . @param validPixROI Optional output rectangle that outlines all-good-pixels region in the -undistorted image. See roi1, roi2 description in stereoRectify . +undistorted image. See roi1, roi2 description in #stereoRectify . @param centerPrincipalPoint Optional flag that indicates whether in the new camera intrinsic matrix the principal point should be at the image center or not. By default, the principal point is chosen to best fit a subset of the source image (determined by alpha) to the corrected image. @@ -2320,7 +2390,7 @@ image pixels if there is valuable information in the corners alpha=1 , or get so When alpha\>0 , the undistorted result is likely to have some black pixels corresponding to "virtual" pixels outside of the captured distorted image. The original camera intrinsic matrix, distortion coefficients, the computed new camera intrinsic matrix, and newImageSize should be passed to -initUndistortRectifyMap to produce the maps for remap . +#initUndistortRectifyMap to produce the maps for #remap . */ CV_EXPORTS_W Mat getOptimalNewCameraMatrix( InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, double alpha, Size newImgSize = Size(), @@ -2331,7 +2401,7 @@ CV_EXPORTS_W Mat getOptimalNewCameraMatrix( InputArray cameraMatrix, InputArray The function is similar to #undistort and #initUndistortRectifyMap but it operates on a sparse set of points instead of a raster image. Also the function performs a reverse transformation -to projectPoints. In case of a 3D object, it does not reconstruct its 3D coordinates, but for a +to #projectPoints. In case of a 3D object, it does not reconstruct its 3D coordinates, but for a planar object, it does, up to a translation vector, if the proper R is specified. For each observed point coordinate \f$(u, v)\f$ the function computes: @@ -2516,7 +2586,6 @@ public: protected: struct Impl; Ptr p; - }; //! @} _3d diff --git a/modules/3d/perf/perf_undistort.cpp b/modules/3d/perf/perf_undistort.cpp index 5372aaea92..e15d2aefe3 100644 --- a/modules/3d/perf/perf_undistort.cpp +++ b/modules/3d/perf/perf_undistort.cpp @@ -16,4 +16,15 @@ PERF_TEST(Undistort, InitUndistortMap) SANITY_CHECK_NOTHING(); } +PERF_TEST(Undistort, DISABLED_InitInverseRectificationMap) +{ + Size size_w_h(512 + 3, 512); + Mat k(3, 3, CV_32FC1); + Mat d(1, 14, CV_64FC1); + Mat dst(size_w_h, CV_32FC2); + declare.in(k, d, WARMUP_RNG).out(dst); + TEST_CYCLE() initInverseRectificationMap(k, d, noArray(), k, size_w_h, CV_32FC2, dst, noArray()); + SANITY_CHECK_NOTHING(); +} + } // namespace diff --git a/modules/3d/src/undistort.dispatch.cpp b/modules/3d/src/undistort.dispatch.cpp index 72681483ca..289ec45efe 100644 --- a/modules/3d/src/undistort.dispatch.cpp +++ b/modules/3d/src/undistort.dispatch.cpp @@ -159,6 +159,125 @@ void initUndistortRectifyMap( InputArray _cameraMatrix, InputArray _distCoeffs, fx, fy, k1, k2, p1, p2, k3, k4, k5, k6, s1, s2, s3, s4)); } +void initInverseRectificationMap( InputArray _cameraMatrix, InputArray _distCoeffs, + InputArray _matR, InputArray _newCameraMatrix, + const Size& size, int m1type, OutputArray _map1, OutputArray _map2 ) +{ + // Parameters + Mat cameraMatrix = _cameraMatrix.getMat(), distCoeffs = _distCoeffs.getMat(); + Mat matR = _matR.getMat(), newCameraMatrix = _newCameraMatrix.getMat(); + + // Check m1type validity + if( m1type <= 0 ) + m1type = CV_16SC2; + CV_Assert( m1type == CV_16SC2 || m1type == CV_32FC1 || m1type == CV_32FC2 ); + + // Init Maps + _map1.create( size, m1type ); + Mat map1 = _map1.getMat(), map2; + if( m1type != CV_32FC2 ) + { + _map2.create( size, m1type == CV_16SC2 ? CV_16UC1 : CV_32FC1 ); + map2 = _map2.getMat(); + } + else { + _map2.release(); + } + + // Init camera intrinsics + Mat_ A = Mat_(cameraMatrix), Ar; + if( !newCameraMatrix.empty() ) + Ar = Mat_(newCameraMatrix); + else + Ar = getDefaultNewCameraMatrix( A, size, true ); + CV_Assert( A.size() == Size(3,3) ); + CV_Assert( Ar.size() == Size(3,3) || Ar.size() == Size(4, 3)); + + // Init rotation matrix + Mat_ R = Mat_::eye(3, 3); + if( !matR.empty() ) + { + R = Mat_(matR); + //Note, do not inverse + } + CV_Assert( Size(3,3) == R.size() ); + + // Init distortion vector + if( !distCoeffs.empty() ){ + distCoeffs = Mat_(distCoeffs); + + // Fix distortion vector orientation + if( distCoeffs.rows != 1 && !distCoeffs.isContinuous() ) { + distCoeffs = distCoeffs.t(); + } + } + + // Validate distortion vector size + CV_Assert( distCoeffs.empty() || // Empty allows cv::undistortPoints to skip distortion + distCoeffs.size() == Size(1, 4) || distCoeffs.size() == Size(4, 1) || + distCoeffs.size() == Size(1, 5) || distCoeffs.size() == Size(5, 1) || + distCoeffs.size() == Size(1, 8) || distCoeffs.size() == Size(8, 1) || + distCoeffs.size() == Size(1, 12) || distCoeffs.size() == Size(12, 1) || + distCoeffs.size() == Size(1, 14) || distCoeffs.size() == Size(14, 1)); + + // Create objectPoints + std::vector p2i_objPoints; + std::vector p2f_objPoints; + for (int r = 0; r < size.height; r++) + { + for (int c = 0; c < size.width; c++) + { + p2i_objPoints.push_back(cv::Point2i(c, r)); + p2f_objPoints.push_back(cv::Point2f(static_cast(c), static_cast(r))); + } + } + + // Undistort + std::vector p2f_objPoints_undistorted; + undistortPoints( + p2f_objPoints, + p2f_objPoints_undistorted, + A, + distCoeffs, + cv::Mat::eye(cv::Size(3, 3), CV_64FC1), // R + cv::Mat::eye(cv::Size(3, 3), CV_64FC1) // P = New K + ); + + // Rectify + std::vector p2f_sourcePoints_pinHole; + perspectiveTransform( + p2f_objPoints_undistorted, + p2f_sourcePoints_pinHole, + R + ); + + // Project points back to camera coordinates. + std::vector p2f_sourcePoints; + undistortPoints( + p2f_sourcePoints_pinHole, + p2f_sourcePoints, + cv::Mat::eye(cv::Size(3, 3), CV_32FC1), // K + cv::Mat::zeros(cv::Size(1, 4), CV_32FC1), // Distortion + cv::Mat::eye(cv::Size(3, 3), CV_32FC1), // R + Ar // New K + ); + + // Copy to map + if (m1type == CV_16SC2) { + for (size_t i=0; i < p2i_objPoints.size(); i++) { + map1.at(p2i_objPoints[i].y, p2i_objPoints[i].x) = Vec2s(saturate_cast(p2f_sourcePoints[i].x), saturate_cast(p2f_sourcePoints[i].y)); + } + } else if (m1type == CV_32FC2) { + for (size_t i=0; i < p2i_objPoints.size(); i++) { + map1.at(p2i_objPoints[i].y, p2i_objPoints[i].x) = Vec2f(p2f_sourcePoints[i]); + } + } else { // m1type == CV_32FC1 + for (size_t i=0; i < p2i_objPoints.size(); i++) { + map1.at(p2i_objPoints[i].y, p2i_objPoints[i].x) = p2f_sourcePoints[i].x; + map2.at(p2i_objPoints[i].y, p2i_objPoints[i].x) = p2f_sourcePoints[i].y; + } + } +} void undistort( InputArray _src, OutputArray _dst, InputArray _cameraMatrix, InputArray _distCoeffs, InputArray _newCameraMatrix ) diff --git a/modules/3d/test/test_undistort.cpp b/modules/3d/test/test_undistort.cpp index c6b6fb95f9..92d1050c9b 100644 --- a/modules/3d/test/test_undistort.cpp +++ b/modules/3d/test/test_undistort.cpp @@ -719,11 +719,281 @@ double CV_InitUndistortRectifyMapTest::get_success_error_level( int /*test_case_ return 8; } +//------------------------------------------------------ + +class CV_InitInverseRectificationMapTest : public cvtest::ArrayTest +{ +public: + CV_InitInverseRectificationMapTest(); +protected: + int prepare_test_case (int test_case_idx); + void prepare_to_validation( int test_case_idx ); + void get_test_array_types_and_sizes( int test_case_idx, vector >& sizes, vector >& types ); + double get_success_error_level( int test_case_idx, int i, int j ); + void run_func(); + +private: + static const int MAX_X = 1024; + static const int MAX_Y = 1024; + bool zero_new_cam; + bool zero_distortion; + bool zero_R; + + cv::Size img_size; + int map_type; +}; + +CV_InitInverseRectificationMapTest::CV_InitInverseRectificationMapTest() +{ + test_array[INPUT].push_back(NULL); // camera matrix + test_array[INPUT].push_back(NULL); // distortion coeffs + test_array[INPUT].push_back(NULL); // R matrix + test_array[INPUT].push_back(NULL); // new camera matrix + test_array[OUTPUT].push_back(NULL); // inverse rectified mapx + test_array[OUTPUT].push_back(NULL); // inverse rectified mapy + test_array[REF_OUTPUT].push_back(NULL); + test_array[REF_OUTPUT].push_back(NULL); + + zero_distortion = zero_new_cam = zero_R = false; + map_type = 0; +} + +void CV_InitInverseRectificationMapTest::get_test_array_types_and_sizes( int test_case_idx, vector >& sizes, vector >& types ) +{ + cvtest::ArrayTest::get_test_array_types_and_sizes(test_case_idx,sizes,types); + RNG& rng = ts->get_rng(); + //rng.next(); + + map_type = CV_32F; + types[OUTPUT][0] = types[OUTPUT][1] = types[REF_OUTPUT][0] = types[REF_OUTPUT][1] = map_type; + + img_size.width = cvtest::randInt(rng) % MAX_X + 1; + img_size.height = cvtest::randInt(rng) % MAX_Y + 1; + + types[INPUT][0] = cvtest::randInt(rng)%2 ? CV_64F : CV_32F; + types[INPUT][1] = cvtest::randInt(rng)%2 ? CV_64F : CV_32F; + types[INPUT][2] = cvtest::randInt(rng)%2 ? CV_64F : CV_32F; + types[INPUT][3] = cvtest::randInt(rng)%2 ? CV_64F : CV_32F; + + sizes[OUTPUT][0] = sizes[OUTPUT][1] = sizes[REF_OUTPUT][0] = sizes[REF_OUTPUT][1] = img_size; + sizes[INPUT][0] = sizes[INPUT][2] = sizes[INPUT][3] = cvSize(3,3); + + Size dsize; + + if (cvtest::randInt(rng)%2) + { + if (cvtest::randInt(rng)%2) + { + dsize = Size(1,4); + } + else + { + dsize = Size(1,5); + } + } + else + { + if (cvtest::randInt(rng)%2) + { + dsize = Size(4,1); + } + else + { + dsize = Size(5,1); + } + } + sizes[INPUT][1] = dsize; +} + + +int CV_InitInverseRectificationMapTest::prepare_test_case(int test_case_idx) +{ + RNG& rng = ts->get_rng(); + int code = cvtest::ArrayTest::prepare_test_case( test_case_idx ); + + if (code <= 0) + return code; + + int dist_size = test_mat[INPUT][1].cols > test_mat[INPUT][1].rows ? test_mat[INPUT][1].cols : test_mat[INPUT][1].rows; + double cam[9] = {0,0,0,0,0,0,0,0,1}; + vector dist(dist_size); + vector new_cam(test_mat[INPUT][3].cols * test_mat[INPUT][3].rows); + + Mat _camera(3,3,CV_64F,cam); + Mat _distort(test_mat[INPUT][1].size(),CV_64F,&dist[0]); + Mat _new_cam(test_mat[INPUT][3].size(),CV_64F,&new_cam[0]); + + //Generating camera matrix + double sz = MAX(img_size.width,img_size.height); + double aspect_ratio = cvtest::randReal(rng)*0.6 + 0.7; + cam[2] = (img_size.width - 1)*0.5 + cvtest::randReal(rng)*10 - 5; + cam[5] = (img_size.height - 1)*0.5 + cvtest::randReal(rng)*10 - 5; + cam[0] = sz/(0.9 - cvtest::randReal(rng)*0.6); + cam[4] = aspect_ratio*cam[0]; + + //Generating distortion coeffs + dist[0] = cvtest::randReal(rng)*0.06 - 0.03; + dist[1] = cvtest::randReal(rng)*0.06 - 0.03; + if( dist[0]*dist[1] > 0 ) + dist[1] = -dist[1]; + if( cvtest::randInt(rng)%4 != 0 ) + { + dist[2] = cvtest::randReal(rng)*0.004 - 0.002; + dist[3] = cvtest::randReal(rng)*0.004 - 0.002; + if (dist_size > 4) + dist[4] = cvtest::randReal(rng)*0.004 - 0.002; + } + else + { + dist[2] = dist[3] = 0; + if (dist_size > 4) + dist[4] = 0; + } + + //Generating new camera matrix + _new_cam = Scalar::all(0); + new_cam[8] = 1; + + // If P == K + //new_cam[0] = cam[0]; + //new_cam[4] = cam[4]; + //new_cam[2] = cam[2]; + //new_cam[5] = cam[5]; + + // If P != K + new_cam[0] = cam[0] + (cvtest::randReal(rng) - (double)0.5)*0.2*cam[0]; //10% + new_cam[4] = cam[4] + (cvtest::randReal(rng) - (double)0.5)*0.2*cam[4]; //10% + new_cam[2] = cam[2] + (cvtest::randReal(rng) - (double)0.5)*0.3*img_size.width; //15% + new_cam[5] = cam[5] + (cvtest::randReal(rng) - (double)0.5)*0.3*img_size.height; //15% + + //Generating R matrix + Mat _rot(3,3,CV_64F); + Mat rotation(1,3,CV_64F); + rotation.at(0) = CV_PI/8*(cvtest::randReal(rng) - (double)0.5); // phi + rotation.at(1) = CV_PI/8*(cvtest::randReal(rng) - (double)0.5); // ksi + rotation.at(2) = CV_PI/3*(cvtest::randReal(rng) - (double)0.5); //khi + cvtest::Rodrigues(rotation, _rot); + + //cvSetIdentity(_rot); + //copying data + cvtest::convert( _camera, test_mat[INPUT][0], test_mat[INPUT][0].type()); + cvtest::convert( _distort, test_mat[INPUT][1], test_mat[INPUT][1].type()); + cvtest::convert( _rot, test_mat[INPUT][2], test_mat[INPUT][2].type()); + cvtest::convert( _new_cam, test_mat[INPUT][3], test_mat[INPUT][3].type()); + + zero_distortion = (cvtest::randInt(rng)%2) == 0 ? false : true; + zero_new_cam = (cvtest::randInt(rng)%2) == 0 ? false : true; + zero_R = (cvtest::randInt(rng)%2) == 0 ? false : true; + + return code; +} + +void CV_InitInverseRectificationMapTest::prepare_to_validation(int/* test_case_idx*/) +{ + // Configure Parameters + Mat _a0 = test_mat[INPUT][0]; + Mat _d0 = zero_distortion ? cv::Mat() : test_mat[INPUT][1]; + Mat _R0 = zero_R ? cv::Mat() : test_mat[INPUT][2]; + Mat _new_cam0 = zero_new_cam ? test_mat[INPUT][0] : test_mat[INPUT][3]; + Mat _mapx(img_size, CV_32F), _mapy(img_size, CV_32F); + + double a[9], d[5]={0,0,0,0,0}, R[9]={1, 0, 0, 0, 1, 0, 0, 0, 1}, a1[9]; + Mat _a(3, 3, CV_64F, a), _a1(3, 3, CV_64F, a1); + Mat _d(_d0.rows,_d0.cols, CV_MAKETYPE(CV_64F,_d0.channels()),d); + Mat _R(3, 3, CV_64F, R); + double fx, fy, cx, cy, ifx, ify, cxn, cyn; + + // Camera matrix + CV_Assert(_a0.size() == Size(3, 3)); + _a0.convertTo(_a, CV_64F); + if( !_new_cam0.empty() ) + { + CV_Assert(_new_cam0.size() == Size(3, 3)); + _new_cam0.convertTo(_a1, CV_64F); + } + else + { + _a.copyTo(_a1); + } + + // Distortion + CV_Assert(_d0.empty() || + _d0.size() == Size(5, 1) || + _d0.size() == Size(1, 5) || + _d0.size() == Size(4, 1) || + _d0.size() == Size(1, 4)); + if( !_d0.empty() ) + _d0.convertTo(_d, CV_64F); + + // Rotation + if( !_R0.empty() ) + { + CV_Assert(_R0.size() == Size(3, 3)); + Mat tmp; + _R0.convertTo(_R, CV_64F); + } + + // Copy camera matrix + fx = a[0]; fy = a[4]; cx = a[2]; cy = a[5]; + + // Copy new camera matrix + ifx = a1[0]; ify = a1[4]; cxn = a1[2]; cyn = a1[5]; + + // Undistort + for( int v = 0; v < img_size.height; v++ ) + { + for( int u = 0; u < img_size.width; u++ ) + { + // Convert from image to pin-hole coordinates + double x = (u - cx)/fx; + double y = (v - cy)/fy; + + // Undistort + double x2 = x*x, y2 = y*y; + double r2 = x2 + y2; + double cdist = 1./(1 + (d[0] + (d[1] + d[4]*r2)*r2)*r2); // (1 + (d[5] + (d[6] + d[7]*r2)*r2)*r2) == 1 as d[5-7]=0; + double x_ = x*cdist - d[2]*2*x*y + d[3]*(r2 + 2*x2); + double y_ = y*cdist - d[3]*2*x*y + d[2]*(r2 + 2*y2); + + // Rectify + double X = R[0]*x_ + R[1]*y_ + R[2]; + double Y = R[3]*x_ + R[4]*y_ + R[5]; + double Z = R[6]*x_ + R[7]*y_ + R[8]; + double x__ = X/Z; + double y__ = Y/Z; + + // Convert from pin-hole to image coordinates + _mapy.at(v, u) = (float)(y__*ify + cyn); + _mapx.at(v, u) = (float)(x__*ifx + cxn); + } + } + + // Convert + _mapx.convertTo(test_mat[REF_OUTPUT][0], test_mat[REF_OUTPUT][0].type()); + _mapy.convertTo(test_mat[REF_OUTPUT][1], test_mat[REF_OUTPUT][0].type()); +} + +void CV_InitInverseRectificationMapTest::run_func() +{ + cv::Mat camera_mat = test_mat[INPUT][0]; + cv::Mat dist = zero_distortion ? cv::Mat() : test_mat[INPUT][1]; + cv::Mat R = zero_R ? cv::Mat() : test_mat[INPUT][2]; + cv::Mat new_cam = zero_new_cam ? cv::Mat() : test_mat[INPUT][3]; + cv::Mat& mapx = test_mat[OUTPUT][0], &mapy = test_mat[OUTPUT][1]; + cv::initInverseRectificationMap(camera_mat,dist,R,new_cam,img_size,map_type,mapx,mapy); +} + +double CV_InitInverseRectificationMapTest::get_success_error_level( int /*test_case_idx*/, int /*i*/, int /*j*/ ) +{ + return 8; +} + ////////////////////////////////////////////////////////////////////////////////////////////////////// TEST(Calib3d_DefaultNewCameraMatrix, accuracy) { CV_DefaultNewCameraMatrixTest test; test.safe_run(); } TEST(Calib3d_UndistortPoints, accuracy) { CV_UndistortPointsTest test; test.safe_run(); } TEST(Calib3d_InitUndistortRectifyMap, accuracy) { CV_InitUndistortRectifyMapTest test; test.safe_run(); } +TEST(DISABLED_Calib3d_InitInverseRectificationMap, accuracy) { CV_InitInverseRectificationMapTest test; test.safe_run(); } ////////////////////////////// undistort ///////////////////////////////// diff --git a/modules/calib/include/opencv2/calib.hpp b/modules/calib/include/opencv2/calib.hpp index 98f850b092..460ac2657f 100644 --- a/modules/calib/include/opencv2/calib.hpp +++ b/modules/calib/include/opencv2/calib.hpp @@ -462,7 +462,7 @@ enum RobotWorldHandEyeCalibrationMethod @param objectPoints Vector of vectors of the calibration pattern points in the calibration pattern coordinate space. In the old interface all the per-view vectors are concatenated. See -calibrateCamera for details. +#calibrateCamera for details. @param imagePoints Vector of vectors of the projections of the calibration pattern points. In the old interface all the per-view vectors are concatenated. @param imageSize Image size in pixels used to initialize the principal point. @@ -556,7 +556,7 @@ Each entry stands for one corner of the pattern and can have one of the followin - 3 = left-top corner of a black cell with a white marker dot - 4 = left-top corner of a white cell with a black marker dot (pattern origin in case of markers otherwise first corner) -The function is analog to findchessboardCorners but uses a localized radon +The function is analog to #findChessboardCorners but uses a localized radon transformation approximated by box filters being more robust to all sort of noise, faster on larger images and is able to directly return the sub-pixel position of the internal chessboard corners. The Method is based on the paper @@ -606,7 +606,7 @@ and should be below ~3.0 pixels. @param image Gray image used to find chessboard corners @param patternSize Size of a found chessboard pattern -@param corners Corners found by findChessboardCorners(SB) +@param corners Corners found by #findChessboardCornersSB @param rise_distance Rise distance 0.8 means 10% ... 90% of the final signal strength @param vertical By default edge responses for horizontal lines are calculated @param sharpness Optional output array with a sharpness value for calculated edge responses (see description) @@ -634,9 +634,9 @@ CV_EXPORTS_W bool find4QuadCornerSubpix( InputArray img, InputOutputArray corner @param image Destination image. It must be an 8-bit color image. @param patternSize Number of inner corners per a chessboard row and column (patternSize = cv::Size(points_per_row,points_per_column)). -@param corners Array of detected corners, the output of findChessboardCorners. +@param corners Array of detected corners, the output of #findChessboardCorners. @param patternWasFound Parameter indicating whether the complete board was found or not. The -return value of findChessboardCorners should be passed here. +return value of #findChessboardCorners should be passed here. The function draws individual chessboard corners detected either as red circles if the board was not found, or as colored corners connected with lines if the board was found. @@ -854,21 +854,21 @@ CV_EXPORTS_W double calibrateCamera( InputArrayOfArrays objectPoints, /** @brief Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern. -This function is an extension of calibrateCamera() with the method of releasing object which was +This function is an extension of #calibrateCamera with the method of releasing object which was proposed in @cite strobl2011iccv. In many common cases with inaccurate, unmeasured, roughly planar targets (calibration plates), this method can dramatically improve the precision of the estimated camera parameters. Both the object-releasing method and standard method are supported by this function. Use the parameter **iFixedPoint** for method selection. In the internal implementation, -calibrateCamera() is a wrapper for this function. +#calibrateCamera is a wrapper for this function. @param objectPoints Vector of vectors of calibration pattern points in the calibration pattern -coordinate space. See calibrateCamera() for details. If the method of releasing object to be used, +coordinate space. See #calibrateCamera for details. If the method of releasing object to be used, the identical calibration board must be used in each view and it must be fully visible, and all objectPoints[i] must be the same and all points should be roughly close to a plane. **The calibration target has to be rigid, or at least static if the camera (rather than the calibration target) is shifted for grabbing images.** @param imagePoints Vector of vectors of the projections of calibration pattern points. See -calibrateCamera() for details. +#calibrateCamera for details. @param imageSize Size of the image used only to initialize the intrinsic camera matrix. @param iFixedPoint The index of the 3D object point in objectPoints[0] to be fixed. It also acts as a switch for calibration method selection. If object-releasing method to be used, pass in the @@ -878,9 +878,9 @@ board grid is recommended to be fixed when object-releasing method being utilize \cite strobl2011iccv, two other points are also fixed. In this implementation, objectPoints[0].front and objectPoints[0].back.z are used. With object-releasing method, accurate rvecs, tvecs and newObjPoints are only possible if coordinates of these three fixed points are accurate enough. -@param cameraMatrix Output 3x3 floating-point camera matrix. See calibrateCamera() for details. -@param distCoeffs Output vector of distortion coefficients. See calibrateCamera() for details. -@param rvecs Output vector of rotation vectors estimated for each pattern view. See calibrateCamera() +@param cameraMatrix Output 3x3 floating-point camera matrix. See #calibrateCamera for details. +@param distCoeffs Output vector of distortion coefficients. See #calibrateCamera for details. +@param rvecs Output vector of rotation vectors estimated for each pattern view. See #calibrateCamera for details. @param tvecs Output vector of translation vectors estimated for each pattern view. @param newObjPoints The updated output vector of calibration pattern points. The coordinates might @@ -888,15 +888,15 @@ be scaled based on three fixed points. The returned coordinates are accurate onl mentioned three fixed points are accurate. If not needed, noArray() can be passed in. This parameter is ignored with standard calibration method. @param stdDeviationsIntrinsics Output vector of standard deviations estimated for intrinsic parameters. -See calibrateCamera() for details. +See #calibrateCamera for details. @param stdDeviationsExtrinsics Output vector of standard deviations estimated for extrinsic parameters. -See calibrateCamera() for details. +See #calibrateCamera for details. @param stdDeviationsObjPoints Output vector of standard deviations estimated for refined coordinates of calibration pattern points. It has the same size and order as objectPoints[0] vector. This parameter is ignored with standard calibration method. @param perViewErrors Output vector of the RMS re-projection error estimated for each pattern view. @param flags Different flags that may be zero or a combination of some predefined values. See -calibrateCamera() for details. If the method of releasing object is used, the calibration time may +#calibrateCamera for details. If the method of releasing object is used, the calibration time may be much longer. CALIB_USE_QR or CALIB_USE_LU could be used for faster calibration with potentially less precise and less stable in some rare cases. @param criteria Termination criteria for the iterative optimization algorithm. @@ -905,7 +905,7 @@ less precise and less stable in some rare cases. The function estimates the intrinsic camera parameters and extrinsic parameters for each of the views. The algorithm is based on @cite Zhang2000, @cite BouguetMCT and @cite strobl2011iccv. See -calibrateCamera() for other detailed explanations. +#calibrateCamera for other detailed explanations. @sa calibrateCamera, findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate, undistort */ @@ -932,8 +932,8 @@ CV_EXPORTS_W double calibrateCameraRO( InputArrayOfArrays objectPoints, /** @brief Computes useful camera characteristics from the camera intrinsic matrix. -@param cameraMatrix Input camera intrinsic matrix that can be estimated by calibrateCamera or -stereoCalibrate . +@param cameraMatrix Input camera intrinsic matrix that can be estimated by #calibrateCamera or +#stereoCalibrate . @param imageSize Input image size in pixels. @param apertureWidth Physical width in mm of the sensor. @param apertureHeight Physical height in mm of the sensor. @@ -1068,13 +1068,13 @@ Besides the stereo-related information, the function can also perform a full cal the two cameras. However, due to the high dimensionality of the parameter space and noise in the input data, the function can diverge from the correct solution. If the intrinsic parameters can be estimated with high accuracy for each of the cameras individually (for example, using -calibrateCamera ), you are recommended to do so and then pass @ref CALIB_FIX_INTRINSIC flag to the +#calibrateCamera ), you are recommended to do so and then pass @ref CALIB_FIX_INTRINSIC flag to the function along with the computed intrinsic parameters. Otherwise, if all the parameters are estimated at once, it makes sense to restrict some parameters, for example, pass @ref CALIB_SAME_FOCAL_LENGTH and @ref CALIB_ZERO_TANGENT_DIST flags, which is usually a reasonable assumption. -Similarly to calibrateCamera, the function minimizes the total re-projection error for all the +Similarly to #calibrateCamera, the function minimizes the total re-projection error for all the points in all the available views from both cameras. The function returns the final value of the re-projection error. */ diff --git a/modules/core/include/opencv2/core/mat.hpp b/modules/core/include/opencv2/core/mat.hpp index 20234ddf8c..de2370f46b 100644 --- a/modules/core/include/opencv2/core/mat.hpp +++ b/modules/core/include/opencv2/core/mat.hpp @@ -2577,27 +2577,38 @@ public: - number of channels */ int flags; + //! the matrix dimensionality, >= 2 int dims; - //! the number of rows and columns or (-1, -1) when the matrix has more than 2 dimensions - int rows, cols; + + //! number of rows in the matrix; -1 when the matrix has more than 2 dimensions + int rows; + + //! number of columns in the matrix; -1 when the matrix has more than 2 dimensions + int cols; //! custom allocator MatAllocator* allocator; - UMatUsageFlags usageFlags; // usage flags for allocator + + //! usage flags for allocator; recommend do not set directly, instead set during construct/create/getUMat + UMatUsageFlags usageFlags; + //! and the standard allocator static MatAllocator* getStdAllocator(); //! internal use method: updates the continuity flag void updateContinuityFlag(); - // black-box container of UMat data + //! black-box container of UMat data UMatData* u; - // offset of the submatrix (or 0) + //! offset of the submatrix (or 0) size_t offset; + //! dimensional size of the matrix; accessible in various formats MatSize size; + + //! number of bytes each matrix element/row/plane/dimension occupies MatStep step; protected: diff --git a/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clamdblas.hpp b/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clamdblas.hpp deleted file mode 100644 index 65c8493524..0000000000 --- a/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clamdblas.hpp +++ /dev/null @@ -1,714 +0,0 @@ -// -// AUTOGENERATED, DO NOT EDIT -// -#ifndef OPENCV_CORE_OCL_RUNTIME_CLAMDBLAS_HPP -#error "Invalid usage" -#endif - -// generated by parser_clamdblas.py -#define clAmdBlasAddScratchImage clAmdBlasAddScratchImage_ -#define clAmdBlasCaxpy clAmdBlasCaxpy_ -#define clAmdBlasCcopy clAmdBlasCcopy_ -#define clAmdBlasCdotc clAmdBlasCdotc_ -#define clAmdBlasCdotu clAmdBlasCdotu_ -#define clAmdBlasCgbmv clAmdBlasCgbmv_ -#define clAmdBlasCgemm clAmdBlasCgemm_ -#define clAmdBlasCgemmEx clAmdBlasCgemmEx_ -#define clAmdBlasCgemv clAmdBlasCgemv_ -#define clAmdBlasCgemvEx clAmdBlasCgemvEx_ -#define clAmdBlasCgerc clAmdBlasCgerc_ -#define clAmdBlasCgeru clAmdBlasCgeru_ -#define clAmdBlasChbmv clAmdBlasChbmv_ -#define clAmdBlasChemm clAmdBlasChemm_ -#define clAmdBlasChemv clAmdBlasChemv_ -#define clAmdBlasCher clAmdBlasCher_ -#define clAmdBlasCher2 clAmdBlasCher2_ -#define clAmdBlasCher2k clAmdBlasCher2k_ -#define clAmdBlasCherk clAmdBlasCherk_ -#define clAmdBlasChpmv clAmdBlasChpmv_ -#define clAmdBlasChpr clAmdBlasChpr_ -#define clAmdBlasChpr2 clAmdBlasChpr2_ -#define clAmdBlasCrotg clAmdBlasCrotg_ -#define clAmdBlasCscal clAmdBlasCscal_ -#define clAmdBlasCsrot clAmdBlasCsrot_ -#define clAmdBlasCsscal clAmdBlasCsscal_ -#define clAmdBlasCswap clAmdBlasCswap_ -#define clAmdBlasCsymm clAmdBlasCsymm_ -#define clAmdBlasCsyr2k clAmdBlasCsyr2k_ -#define clAmdBlasCsyr2kEx clAmdBlasCsyr2kEx_ -#define clAmdBlasCsyrk clAmdBlasCsyrk_ -#define clAmdBlasCsyrkEx clAmdBlasCsyrkEx_ -#define clAmdBlasCtbmv clAmdBlasCtbmv_ -#define clAmdBlasCtbsv clAmdBlasCtbsv_ -#define clAmdBlasCtpmv clAmdBlasCtpmv_ -#define clAmdBlasCtpsv clAmdBlasCtpsv_ -#define clAmdBlasCtrmm clAmdBlasCtrmm_ -#define clAmdBlasCtrmmEx clAmdBlasCtrmmEx_ -#define clAmdBlasCtrmv clAmdBlasCtrmv_ -#define clAmdBlasCtrsm clAmdBlasCtrsm_ -#define clAmdBlasCtrsmEx clAmdBlasCtrsmEx_ -#define clAmdBlasCtrsv clAmdBlasCtrsv_ -#define clAmdBlasDasum clAmdBlasDasum_ -#define clAmdBlasDaxpy clAmdBlasDaxpy_ -#define clAmdBlasDcopy clAmdBlasDcopy_ -#define clAmdBlasDdot clAmdBlasDdot_ -#define clAmdBlasDgbmv clAmdBlasDgbmv_ -#define clAmdBlasDgemm clAmdBlasDgemm_ -#define clAmdBlasDgemmEx clAmdBlasDgemmEx_ -#define clAmdBlasDgemv clAmdBlasDgemv_ -#define clAmdBlasDgemvEx clAmdBlasDgemvEx_ -#define clAmdBlasDger clAmdBlasDger_ -#define clAmdBlasDnrm2 clAmdBlasDnrm2_ -#define clAmdBlasDrot clAmdBlasDrot_ -#define clAmdBlasDrotg clAmdBlasDrotg_ -#define clAmdBlasDrotm clAmdBlasDrotm_ -#define clAmdBlasDrotmg clAmdBlasDrotmg_ -#define clAmdBlasDsbmv clAmdBlasDsbmv_ -#define clAmdBlasDscal clAmdBlasDscal_ -#define clAmdBlasDspmv clAmdBlasDspmv_ -#define clAmdBlasDspr clAmdBlasDspr_ -#define clAmdBlasDspr2 clAmdBlasDspr2_ -#define clAmdBlasDswap clAmdBlasDswap_ -#define clAmdBlasDsymm clAmdBlasDsymm_ -#define clAmdBlasDsymv clAmdBlasDsymv_ -#define clAmdBlasDsymvEx clAmdBlasDsymvEx_ -#define clAmdBlasDsyr clAmdBlasDsyr_ -#define clAmdBlasDsyr2 clAmdBlasDsyr2_ -#define clAmdBlasDsyr2k clAmdBlasDsyr2k_ -#define clAmdBlasDsyr2kEx clAmdBlasDsyr2kEx_ -#define clAmdBlasDsyrk clAmdBlasDsyrk_ -#define clAmdBlasDsyrkEx clAmdBlasDsyrkEx_ -#define clAmdBlasDtbmv clAmdBlasDtbmv_ -#define clAmdBlasDtbsv clAmdBlasDtbsv_ -#define clAmdBlasDtpmv clAmdBlasDtpmv_ -#define clAmdBlasDtpsv clAmdBlasDtpsv_ -#define clAmdBlasDtrmm clAmdBlasDtrmm_ -#define clAmdBlasDtrmmEx clAmdBlasDtrmmEx_ -#define clAmdBlasDtrmv clAmdBlasDtrmv_ -#define clAmdBlasDtrsm clAmdBlasDtrsm_ -#define clAmdBlasDtrsmEx clAmdBlasDtrsmEx_ -#define clAmdBlasDtrsv clAmdBlasDtrsv_ -#define clAmdBlasDzasum clAmdBlasDzasum_ -#define clAmdBlasDznrm2 clAmdBlasDznrm2_ -#define clAmdBlasGetVersion clAmdBlasGetVersion_ -#define clAmdBlasRemoveScratchImage clAmdBlasRemoveScratchImage_ -#define clAmdBlasSasum clAmdBlasSasum_ -#define clAmdBlasSaxpy clAmdBlasSaxpy_ -#define clAmdBlasScasum clAmdBlasScasum_ -#define clAmdBlasScnrm2 clAmdBlasScnrm2_ -#define clAmdBlasScopy clAmdBlasScopy_ -#define clAmdBlasSdot clAmdBlasSdot_ -#define clAmdBlasSetup clAmdBlasSetup_ -#define clAmdBlasSgbmv clAmdBlasSgbmv_ -#define clAmdBlasSgemm clAmdBlasSgemm_ -#define clAmdBlasSgemmEx clAmdBlasSgemmEx_ -#define clAmdBlasSgemv clAmdBlasSgemv_ -#define clAmdBlasSgemvEx clAmdBlasSgemvEx_ -#define clAmdBlasSger clAmdBlasSger_ -#define clAmdBlasSnrm2 clAmdBlasSnrm2_ -#define clAmdBlasSrot clAmdBlasSrot_ -#define clAmdBlasSrotg clAmdBlasSrotg_ -#define clAmdBlasSrotm clAmdBlasSrotm_ -#define clAmdBlasSrotmg clAmdBlasSrotmg_ -#define clAmdBlasSsbmv clAmdBlasSsbmv_ -#define clAmdBlasSscal clAmdBlasSscal_ -#define clAmdBlasSspmv clAmdBlasSspmv_ -#define clAmdBlasSspr clAmdBlasSspr_ -#define clAmdBlasSspr2 clAmdBlasSspr2_ -#define clAmdBlasSswap clAmdBlasSswap_ -#define clAmdBlasSsymm clAmdBlasSsymm_ -#define clAmdBlasSsymv clAmdBlasSsymv_ -#define clAmdBlasSsymvEx clAmdBlasSsymvEx_ -#define clAmdBlasSsyr clAmdBlasSsyr_ -#define clAmdBlasSsyr2 clAmdBlasSsyr2_ -#define clAmdBlasSsyr2k clAmdBlasSsyr2k_ -#define clAmdBlasSsyr2kEx clAmdBlasSsyr2kEx_ -#define clAmdBlasSsyrk clAmdBlasSsyrk_ -#define clAmdBlasSsyrkEx clAmdBlasSsyrkEx_ -#define clAmdBlasStbmv clAmdBlasStbmv_ -#define clAmdBlasStbsv clAmdBlasStbsv_ -#define clAmdBlasStpmv clAmdBlasStpmv_ -#define clAmdBlasStpsv clAmdBlasStpsv_ -#define clAmdBlasStrmm clAmdBlasStrmm_ -#define clAmdBlasStrmmEx clAmdBlasStrmmEx_ -#define clAmdBlasStrmv clAmdBlasStrmv_ -#define clAmdBlasStrsm clAmdBlasStrsm_ -#define clAmdBlasStrsmEx clAmdBlasStrsmEx_ -#define clAmdBlasStrsv clAmdBlasStrsv_ -#define clAmdBlasTeardown clAmdBlasTeardown_ -#define clAmdBlasZaxpy clAmdBlasZaxpy_ -#define clAmdBlasZcopy clAmdBlasZcopy_ -#define clAmdBlasZdotc clAmdBlasZdotc_ -#define clAmdBlasZdotu clAmdBlasZdotu_ -#define clAmdBlasZdrot clAmdBlasZdrot_ -#define clAmdBlasZdscal clAmdBlasZdscal_ -#define clAmdBlasZgbmv clAmdBlasZgbmv_ -#define clAmdBlasZgemm clAmdBlasZgemm_ -#define clAmdBlasZgemmEx clAmdBlasZgemmEx_ -#define clAmdBlasZgemv clAmdBlasZgemv_ -#define clAmdBlasZgemvEx clAmdBlasZgemvEx_ -#define clAmdBlasZgerc clAmdBlasZgerc_ -#define clAmdBlasZgeru clAmdBlasZgeru_ -#define clAmdBlasZhbmv clAmdBlasZhbmv_ -#define clAmdBlasZhemm clAmdBlasZhemm_ -#define clAmdBlasZhemv clAmdBlasZhemv_ -#define clAmdBlasZher clAmdBlasZher_ -#define clAmdBlasZher2 clAmdBlasZher2_ -#define clAmdBlasZher2k clAmdBlasZher2k_ -#define clAmdBlasZherk clAmdBlasZherk_ -#define clAmdBlasZhpmv clAmdBlasZhpmv_ -#define clAmdBlasZhpr clAmdBlasZhpr_ -#define clAmdBlasZhpr2 clAmdBlasZhpr2_ -#define clAmdBlasZrotg clAmdBlasZrotg_ -#define clAmdBlasZscal clAmdBlasZscal_ -#define clAmdBlasZswap clAmdBlasZswap_ -#define clAmdBlasZsymm clAmdBlasZsymm_ -#define clAmdBlasZsyr2k clAmdBlasZsyr2k_ -#define clAmdBlasZsyr2kEx clAmdBlasZsyr2kEx_ -#define clAmdBlasZsyrk clAmdBlasZsyrk_ -#define clAmdBlasZsyrkEx clAmdBlasZsyrkEx_ -#define clAmdBlasZtbmv clAmdBlasZtbmv_ -#define clAmdBlasZtbsv clAmdBlasZtbsv_ -#define clAmdBlasZtpmv clAmdBlasZtpmv_ -#define clAmdBlasZtpsv clAmdBlasZtpsv_ -#define clAmdBlasZtrmm clAmdBlasZtrmm_ -#define clAmdBlasZtrmmEx clAmdBlasZtrmmEx_ -#define clAmdBlasZtrmv clAmdBlasZtrmv_ -#define clAmdBlasZtrsm clAmdBlasZtrsm_ -#define clAmdBlasZtrsmEx clAmdBlasZtrsmEx_ -#define clAmdBlasZtrsv clAmdBlasZtrsv_ -#define clAmdBlasiCamax clAmdBlasiCamax_ -#define clAmdBlasiDamax clAmdBlasiDamax_ -#define clAmdBlasiSamax clAmdBlasiSamax_ -#define clAmdBlasiZamax clAmdBlasiZamax_ - -#include - -// generated by parser_clamdblas.py -#undef clAmdBlasAddScratchImage -//#define clAmdBlasAddScratchImage clAmdBlasAddScratchImage_pfn -#undef clAmdBlasCaxpy -//#define clAmdBlasCaxpy clAmdBlasCaxpy_pfn -#undef clAmdBlasCcopy -//#define clAmdBlasCcopy clAmdBlasCcopy_pfn -#undef clAmdBlasCdotc -//#define clAmdBlasCdotc clAmdBlasCdotc_pfn -#undef clAmdBlasCdotu -//#define clAmdBlasCdotu clAmdBlasCdotu_pfn -#undef clAmdBlasCgbmv -//#define clAmdBlasCgbmv clAmdBlasCgbmv_pfn -#undef clAmdBlasCgemm -//#define clAmdBlasCgemm clAmdBlasCgemm_pfn -#undef clAmdBlasCgemmEx -#define clAmdBlasCgemmEx clAmdBlasCgemmEx_pfn -#undef clAmdBlasCgemv -//#define clAmdBlasCgemv clAmdBlasCgemv_pfn -#undef clAmdBlasCgemvEx -//#define clAmdBlasCgemvEx clAmdBlasCgemvEx_pfn -#undef clAmdBlasCgerc -//#define clAmdBlasCgerc clAmdBlasCgerc_pfn -#undef clAmdBlasCgeru -//#define clAmdBlasCgeru clAmdBlasCgeru_pfn -#undef clAmdBlasChbmv -//#define clAmdBlasChbmv clAmdBlasChbmv_pfn -#undef clAmdBlasChemm -//#define clAmdBlasChemm clAmdBlasChemm_pfn -#undef clAmdBlasChemv -//#define clAmdBlasChemv clAmdBlasChemv_pfn -#undef clAmdBlasCher -//#define clAmdBlasCher clAmdBlasCher_pfn -#undef clAmdBlasCher2 -//#define clAmdBlasCher2 clAmdBlasCher2_pfn -#undef clAmdBlasCher2k -//#define clAmdBlasCher2k clAmdBlasCher2k_pfn -#undef clAmdBlasCherk -//#define clAmdBlasCherk clAmdBlasCherk_pfn -#undef clAmdBlasChpmv -//#define clAmdBlasChpmv clAmdBlasChpmv_pfn -#undef clAmdBlasChpr -//#define clAmdBlasChpr clAmdBlasChpr_pfn -#undef clAmdBlasChpr2 -//#define clAmdBlasChpr2 clAmdBlasChpr2_pfn -#undef clAmdBlasCrotg -//#define clAmdBlasCrotg clAmdBlasCrotg_pfn -#undef clAmdBlasCscal -//#define clAmdBlasCscal clAmdBlasCscal_pfn -#undef clAmdBlasCsrot -//#define clAmdBlasCsrot clAmdBlasCsrot_pfn -#undef clAmdBlasCsscal -//#define clAmdBlasCsscal clAmdBlasCsscal_pfn -#undef clAmdBlasCswap -//#define clAmdBlasCswap clAmdBlasCswap_pfn -#undef clAmdBlasCsymm -//#define clAmdBlasCsymm clAmdBlasCsymm_pfn -#undef clAmdBlasCsyr2k -//#define clAmdBlasCsyr2k clAmdBlasCsyr2k_pfn -#undef clAmdBlasCsyr2kEx -//#define clAmdBlasCsyr2kEx clAmdBlasCsyr2kEx_pfn -#undef clAmdBlasCsyrk -//#define clAmdBlasCsyrk clAmdBlasCsyrk_pfn -#undef clAmdBlasCsyrkEx -//#define clAmdBlasCsyrkEx clAmdBlasCsyrkEx_pfn -#undef clAmdBlasCtbmv -//#define clAmdBlasCtbmv clAmdBlasCtbmv_pfn -#undef clAmdBlasCtbsv -//#define clAmdBlasCtbsv clAmdBlasCtbsv_pfn -#undef clAmdBlasCtpmv -//#define clAmdBlasCtpmv clAmdBlasCtpmv_pfn -#undef clAmdBlasCtpsv -//#define clAmdBlasCtpsv clAmdBlasCtpsv_pfn -#undef clAmdBlasCtrmm -//#define clAmdBlasCtrmm clAmdBlasCtrmm_pfn -#undef clAmdBlasCtrmmEx -//#define clAmdBlasCtrmmEx clAmdBlasCtrmmEx_pfn -#undef clAmdBlasCtrmv -//#define clAmdBlasCtrmv clAmdBlasCtrmv_pfn -#undef clAmdBlasCtrsm -//#define clAmdBlasCtrsm clAmdBlasCtrsm_pfn -#undef clAmdBlasCtrsmEx -//#define clAmdBlasCtrsmEx clAmdBlasCtrsmEx_pfn -#undef clAmdBlasCtrsv -//#define clAmdBlasCtrsv clAmdBlasCtrsv_pfn -#undef clAmdBlasDasum -//#define clAmdBlasDasum clAmdBlasDasum_pfn -#undef clAmdBlasDaxpy -//#define clAmdBlasDaxpy clAmdBlasDaxpy_pfn -#undef clAmdBlasDcopy -//#define clAmdBlasDcopy clAmdBlasDcopy_pfn -#undef clAmdBlasDdot -//#define clAmdBlasDdot clAmdBlasDdot_pfn -#undef clAmdBlasDgbmv -//#define clAmdBlasDgbmv clAmdBlasDgbmv_pfn -#undef clAmdBlasDgemm -//#define clAmdBlasDgemm clAmdBlasDgemm_pfn -#undef clAmdBlasDgemmEx -#define clAmdBlasDgemmEx clAmdBlasDgemmEx_pfn -#undef clAmdBlasDgemv -//#define clAmdBlasDgemv clAmdBlasDgemv_pfn -#undef clAmdBlasDgemvEx -//#define clAmdBlasDgemvEx clAmdBlasDgemvEx_pfn -#undef clAmdBlasDger -//#define clAmdBlasDger clAmdBlasDger_pfn -#undef clAmdBlasDnrm2 -//#define clAmdBlasDnrm2 clAmdBlasDnrm2_pfn -#undef clAmdBlasDrot -//#define clAmdBlasDrot clAmdBlasDrot_pfn -#undef clAmdBlasDrotg -//#define clAmdBlasDrotg clAmdBlasDrotg_pfn -#undef clAmdBlasDrotm -//#define clAmdBlasDrotm clAmdBlasDrotm_pfn -#undef clAmdBlasDrotmg -//#define clAmdBlasDrotmg clAmdBlasDrotmg_pfn -#undef clAmdBlasDsbmv -//#define clAmdBlasDsbmv clAmdBlasDsbmv_pfn -#undef clAmdBlasDscal -//#define clAmdBlasDscal clAmdBlasDscal_pfn -#undef clAmdBlasDspmv -//#define clAmdBlasDspmv clAmdBlasDspmv_pfn -#undef clAmdBlasDspr -//#define clAmdBlasDspr clAmdBlasDspr_pfn -#undef clAmdBlasDspr2 -//#define clAmdBlasDspr2 clAmdBlasDspr2_pfn -#undef clAmdBlasDswap -//#define clAmdBlasDswap clAmdBlasDswap_pfn -#undef clAmdBlasDsymm -//#define clAmdBlasDsymm clAmdBlasDsymm_pfn -#undef clAmdBlasDsymv -//#define clAmdBlasDsymv clAmdBlasDsymv_pfn -#undef clAmdBlasDsymvEx -//#define clAmdBlasDsymvEx clAmdBlasDsymvEx_pfn -#undef clAmdBlasDsyr -//#define clAmdBlasDsyr clAmdBlasDsyr_pfn -#undef clAmdBlasDsyr2 -//#define clAmdBlasDsyr2 clAmdBlasDsyr2_pfn -#undef clAmdBlasDsyr2k -//#define clAmdBlasDsyr2k clAmdBlasDsyr2k_pfn -#undef clAmdBlasDsyr2kEx -//#define clAmdBlasDsyr2kEx clAmdBlasDsyr2kEx_pfn -#undef clAmdBlasDsyrk -//#define clAmdBlasDsyrk clAmdBlasDsyrk_pfn -#undef clAmdBlasDsyrkEx -//#define clAmdBlasDsyrkEx clAmdBlasDsyrkEx_pfn -#undef clAmdBlasDtbmv -//#define clAmdBlasDtbmv clAmdBlasDtbmv_pfn -#undef clAmdBlasDtbsv -//#define clAmdBlasDtbsv clAmdBlasDtbsv_pfn -#undef clAmdBlasDtpmv -//#define clAmdBlasDtpmv clAmdBlasDtpmv_pfn -#undef clAmdBlasDtpsv -//#define clAmdBlasDtpsv clAmdBlasDtpsv_pfn -#undef clAmdBlasDtrmm -//#define clAmdBlasDtrmm clAmdBlasDtrmm_pfn -#undef clAmdBlasDtrmmEx -//#define clAmdBlasDtrmmEx clAmdBlasDtrmmEx_pfn -#undef clAmdBlasDtrmv -//#define clAmdBlasDtrmv clAmdBlasDtrmv_pfn -#undef clAmdBlasDtrsm -//#define clAmdBlasDtrsm clAmdBlasDtrsm_pfn -#undef clAmdBlasDtrsmEx -//#define clAmdBlasDtrsmEx clAmdBlasDtrsmEx_pfn -#undef clAmdBlasDtrsv -//#define clAmdBlasDtrsv clAmdBlasDtrsv_pfn -#undef clAmdBlasDzasum -//#define clAmdBlasDzasum clAmdBlasDzasum_pfn -#undef clAmdBlasDznrm2 -//#define clAmdBlasDznrm2 clAmdBlasDznrm2_pfn -#undef clAmdBlasGetVersion -//#define clAmdBlasGetVersion clAmdBlasGetVersion_pfn -#undef clAmdBlasRemoveScratchImage -//#define clAmdBlasRemoveScratchImage clAmdBlasRemoveScratchImage_pfn -#undef clAmdBlasSasum -//#define clAmdBlasSasum clAmdBlasSasum_pfn -#undef clAmdBlasSaxpy -//#define clAmdBlasSaxpy clAmdBlasSaxpy_pfn -#undef clAmdBlasScasum -//#define clAmdBlasScasum clAmdBlasScasum_pfn -#undef clAmdBlasScnrm2 -//#define clAmdBlasScnrm2 clAmdBlasScnrm2_pfn -#undef clAmdBlasScopy -//#define clAmdBlasScopy clAmdBlasScopy_pfn -#undef clAmdBlasSdot -//#define clAmdBlasSdot clAmdBlasSdot_pfn -#undef clAmdBlasSetup -#define clAmdBlasSetup clAmdBlasSetup_pfn -#undef clAmdBlasSgbmv -//#define clAmdBlasSgbmv clAmdBlasSgbmv_pfn -#undef clAmdBlasSgemm -//#define clAmdBlasSgemm clAmdBlasSgemm_pfn -#undef clAmdBlasSgemmEx -#define clAmdBlasSgemmEx clAmdBlasSgemmEx_pfn -#undef clAmdBlasSgemv -//#define clAmdBlasSgemv clAmdBlasSgemv_pfn -#undef clAmdBlasSgemvEx -//#define clAmdBlasSgemvEx clAmdBlasSgemvEx_pfn -#undef clAmdBlasSger -//#define clAmdBlasSger clAmdBlasSger_pfn -#undef clAmdBlasSnrm2 -//#define clAmdBlasSnrm2 clAmdBlasSnrm2_pfn -#undef clAmdBlasSrot -//#define clAmdBlasSrot clAmdBlasSrot_pfn -#undef clAmdBlasSrotg -//#define clAmdBlasSrotg clAmdBlasSrotg_pfn -#undef clAmdBlasSrotm -//#define clAmdBlasSrotm clAmdBlasSrotm_pfn -#undef clAmdBlasSrotmg -//#define clAmdBlasSrotmg clAmdBlasSrotmg_pfn -#undef clAmdBlasSsbmv -//#define clAmdBlasSsbmv clAmdBlasSsbmv_pfn -#undef clAmdBlasSscal -//#define clAmdBlasSscal clAmdBlasSscal_pfn -#undef clAmdBlasSspmv -//#define clAmdBlasSspmv clAmdBlasSspmv_pfn -#undef clAmdBlasSspr -//#define clAmdBlasSspr clAmdBlasSspr_pfn -#undef clAmdBlasSspr2 -//#define clAmdBlasSspr2 clAmdBlasSspr2_pfn -#undef clAmdBlasSswap -//#define clAmdBlasSswap clAmdBlasSswap_pfn -#undef clAmdBlasSsymm -//#define clAmdBlasSsymm clAmdBlasSsymm_pfn -#undef clAmdBlasSsymv -//#define clAmdBlasSsymv clAmdBlasSsymv_pfn -#undef clAmdBlasSsymvEx -//#define clAmdBlasSsymvEx clAmdBlasSsymvEx_pfn -#undef clAmdBlasSsyr -//#define clAmdBlasSsyr clAmdBlasSsyr_pfn -#undef clAmdBlasSsyr2 -//#define clAmdBlasSsyr2 clAmdBlasSsyr2_pfn -#undef clAmdBlasSsyr2k -//#define clAmdBlasSsyr2k clAmdBlasSsyr2k_pfn -#undef clAmdBlasSsyr2kEx -//#define clAmdBlasSsyr2kEx clAmdBlasSsyr2kEx_pfn -#undef clAmdBlasSsyrk -//#define clAmdBlasSsyrk clAmdBlasSsyrk_pfn -#undef clAmdBlasSsyrkEx -//#define clAmdBlasSsyrkEx clAmdBlasSsyrkEx_pfn -#undef clAmdBlasStbmv -//#define clAmdBlasStbmv clAmdBlasStbmv_pfn -#undef clAmdBlasStbsv -//#define clAmdBlasStbsv clAmdBlasStbsv_pfn -#undef clAmdBlasStpmv -//#define clAmdBlasStpmv clAmdBlasStpmv_pfn -#undef clAmdBlasStpsv -//#define clAmdBlasStpsv clAmdBlasStpsv_pfn -#undef clAmdBlasStrmm -//#define clAmdBlasStrmm clAmdBlasStrmm_pfn -#undef clAmdBlasStrmmEx -//#define clAmdBlasStrmmEx clAmdBlasStrmmEx_pfn -#undef clAmdBlasStrmv -//#define clAmdBlasStrmv clAmdBlasStrmv_pfn -#undef clAmdBlasStrsm -//#define clAmdBlasStrsm clAmdBlasStrsm_pfn -#undef clAmdBlasStrsmEx -//#define clAmdBlasStrsmEx clAmdBlasStrsmEx_pfn -#undef clAmdBlasStrsv -//#define clAmdBlasStrsv clAmdBlasStrsv_pfn -#undef clAmdBlasTeardown -#define clAmdBlasTeardown clAmdBlasTeardown_pfn -#undef clAmdBlasZaxpy -//#define clAmdBlasZaxpy clAmdBlasZaxpy_pfn -#undef clAmdBlasZcopy -//#define clAmdBlasZcopy clAmdBlasZcopy_pfn -#undef clAmdBlasZdotc -//#define clAmdBlasZdotc clAmdBlasZdotc_pfn -#undef clAmdBlasZdotu -//#define clAmdBlasZdotu clAmdBlasZdotu_pfn -#undef clAmdBlasZdrot -//#define clAmdBlasZdrot clAmdBlasZdrot_pfn -#undef clAmdBlasZdscal -//#define clAmdBlasZdscal clAmdBlasZdscal_pfn -#undef clAmdBlasZgbmv -//#define clAmdBlasZgbmv clAmdBlasZgbmv_pfn -#undef clAmdBlasZgemm -//#define clAmdBlasZgemm clAmdBlasZgemm_pfn -#undef clAmdBlasZgemmEx -#define clAmdBlasZgemmEx clAmdBlasZgemmEx_pfn -#undef clAmdBlasZgemv -//#define clAmdBlasZgemv clAmdBlasZgemv_pfn -#undef clAmdBlasZgemvEx -//#define clAmdBlasZgemvEx clAmdBlasZgemvEx_pfn -#undef clAmdBlasZgerc -//#define clAmdBlasZgerc clAmdBlasZgerc_pfn -#undef clAmdBlasZgeru -//#define clAmdBlasZgeru clAmdBlasZgeru_pfn -#undef clAmdBlasZhbmv -//#define clAmdBlasZhbmv clAmdBlasZhbmv_pfn -#undef clAmdBlasZhemm -//#define clAmdBlasZhemm clAmdBlasZhemm_pfn -#undef clAmdBlasZhemv -//#define clAmdBlasZhemv clAmdBlasZhemv_pfn -#undef clAmdBlasZher -//#define clAmdBlasZher clAmdBlasZher_pfn -#undef clAmdBlasZher2 -//#define clAmdBlasZher2 clAmdBlasZher2_pfn -#undef clAmdBlasZher2k -//#define clAmdBlasZher2k clAmdBlasZher2k_pfn -#undef clAmdBlasZherk -//#define clAmdBlasZherk clAmdBlasZherk_pfn -#undef clAmdBlasZhpmv -//#define clAmdBlasZhpmv clAmdBlasZhpmv_pfn -#undef clAmdBlasZhpr -//#define clAmdBlasZhpr clAmdBlasZhpr_pfn -#undef clAmdBlasZhpr2 -//#define clAmdBlasZhpr2 clAmdBlasZhpr2_pfn -#undef clAmdBlasZrotg -//#define clAmdBlasZrotg clAmdBlasZrotg_pfn -#undef clAmdBlasZscal -//#define clAmdBlasZscal clAmdBlasZscal_pfn -#undef clAmdBlasZswap -//#define clAmdBlasZswap clAmdBlasZswap_pfn -#undef clAmdBlasZsymm -//#define clAmdBlasZsymm clAmdBlasZsymm_pfn -#undef clAmdBlasZsyr2k -//#define clAmdBlasZsyr2k clAmdBlasZsyr2k_pfn -#undef clAmdBlasZsyr2kEx -//#define clAmdBlasZsyr2kEx clAmdBlasZsyr2kEx_pfn -#undef clAmdBlasZsyrk -//#define clAmdBlasZsyrk clAmdBlasZsyrk_pfn -#undef clAmdBlasZsyrkEx -//#define clAmdBlasZsyrkEx clAmdBlasZsyrkEx_pfn -#undef clAmdBlasZtbmv -//#define clAmdBlasZtbmv clAmdBlasZtbmv_pfn -#undef clAmdBlasZtbsv -//#define clAmdBlasZtbsv clAmdBlasZtbsv_pfn -#undef clAmdBlasZtpmv -//#define clAmdBlasZtpmv clAmdBlasZtpmv_pfn -#undef clAmdBlasZtpsv -//#define clAmdBlasZtpsv clAmdBlasZtpsv_pfn -#undef clAmdBlasZtrmm -//#define clAmdBlasZtrmm clAmdBlasZtrmm_pfn -#undef clAmdBlasZtrmmEx -//#define clAmdBlasZtrmmEx clAmdBlasZtrmmEx_pfn -#undef clAmdBlasZtrmv -//#define clAmdBlasZtrmv clAmdBlasZtrmv_pfn -#undef clAmdBlasZtrsm -//#define clAmdBlasZtrsm clAmdBlasZtrsm_pfn -#undef clAmdBlasZtrsmEx -//#define clAmdBlasZtrsmEx clAmdBlasZtrsmEx_pfn -#undef clAmdBlasZtrsv -//#define clAmdBlasZtrsv clAmdBlasZtrsv_pfn -#undef clAmdBlasiCamax -//#define clAmdBlasiCamax clAmdBlasiCamax_pfn -#undef clAmdBlasiDamax -//#define clAmdBlasiDamax clAmdBlasiDamax_pfn -#undef clAmdBlasiSamax -//#define clAmdBlasiSamax clAmdBlasiSamax_pfn -#undef clAmdBlasiZamax -//#define clAmdBlasiZamax clAmdBlasiZamax_pfn - -// generated by parser_clamdblas.py -//extern CL_RUNTIME_EXPORT cl_ulong (*clAmdBlasAddScratchImage)(cl_context context, size_t width, size_t height, clAmdBlasStatus* status); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCaxpy)(size_t N, cl_float2 alpha, const cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCcopy)(size_t N, const cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCdotc)(size_t N, cl_mem dotProduct, size_t offDP, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCdotu)(size_t N, cl_mem dotProduct, size_t offDP, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCgbmv)(clAmdBlasOrder order, clAmdBlasTranspose trans, size_t M, size_t N, size_t KL, size_t KU, cl_float2 alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem X, size_t offx, int incx, cl_float2 beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCgemm)(clAmdBlasOrder order, clAmdBlasTranspose transA, clAmdBlasTranspose transB, size_t M, size_t N, size_t K, FloatComplex alpha, const cl_mem A, size_t lda, const cl_mem B, size_t ldb, FloatComplex beta, cl_mem C, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCgemmEx)(clAmdBlasOrder order, clAmdBlasTranspose transA, clAmdBlasTranspose transB, size_t M, size_t N, size_t K, FloatComplex alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem B, size_t offB, size_t ldb, FloatComplex beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCgemv)(clAmdBlasOrder order, clAmdBlasTranspose transA, size_t M, size_t N, FloatComplex alpha, const cl_mem A, size_t lda, const cl_mem x, size_t offx, int incx, FloatComplex beta, cl_mem y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCgemvEx)(clAmdBlasOrder order, clAmdBlasTranspose transA, size_t M, size_t N, FloatComplex alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem x, size_t offx, int incx, FloatComplex beta, cl_mem y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCgerc)(clAmdBlasOrder order, size_t M, size_t N, cl_float2 alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCgeru)(clAmdBlasOrder order, size_t M, size_t N, cl_float2 alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasChbmv)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, size_t K, cl_float2 alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem X, size_t offx, int incx, cl_float2 beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasChemm)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, size_t M, size_t N, cl_float2 alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem B, size_t offb, size_t ldb, cl_float2 beta, cl_mem C, size_t offc, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasChemv)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, FloatComplex alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem X, size_t offx, int incx, FloatComplex beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCher)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_float alpha, const cl_mem X, size_t offx, int incx, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCher2)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_float2 alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCher2k)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, size_t N, size_t K, FloatComplex alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem B, size_t offb, size_t ldb, cl_float beta, cl_mem C, size_t offc, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCherk)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose transA, size_t N, size_t K, float alpha, const cl_mem A, size_t offa, size_t lda, float beta, cl_mem C, size_t offc, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasChpmv)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_float2 alpha, const cl_mem AP, size_t offa, const cl_mem X, size_t offx, int incx, cl_float2 beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasChpr)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_float alpha, const cl_mem X, size_t offx, int incx, cl_mem AP, size_t offa, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasChpr2)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_float2 alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem AP, size_t offa, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCrotg)(cl_mem CA, size_t offCA, cl_mem CB, size_t offCB, cl_mem C, size_t offC, cl_mem S, size_t offS, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCscal)(size_t N, cl_float2 alpha, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCsrot)(size_t N, cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_float C, cl_float S, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCsscal)(size_t N, cl_float alpha, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCswap)(size_t N, cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCsymm)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, size_t M, size_t N, cl_float2 alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem B, size_t offb, size_t ldb, cl_float2 beta, cl_mem C, size_t offc, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCsyr2k)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose transAB, size_t N, size_t K, FloatComplex alpha, const cl_mem A, size_t lda, const cl_mem B, size_t ldb, FloatComplex beta, cl_mem C, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCsyr2kEx)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose transAB, size_t N, size_t K, FloatComplex alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem B, size_t offB, size_t ldb, FloatComplex beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCsyrk)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose transA, size_t N, size_t K, FloatComplex alpha, const cl_mem A, size_t lda, FloatComplex beta, cl_mem C, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCsyrkEx)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose transA, size_t N, size_t K, FloatComplex alpha, const cl_mem A, size_t offA, size_t lda, FloatComplex beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCtbmv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, size_t K, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCtbsv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, size_t K, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCtpmv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, const cl_mem AP, size_t offa, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCtpsv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, const cl_mem A, size_t offa, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCtrmm)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, clAmdBlasTranspose transA, clAmdBlasDiag diag, size_t M, size_t N, FloatComplex alpha, const cl_mem A, size_t lda, cl_mem B, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCtrmmEx)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, clAmdBlasTranspose transA, clAmdBlasDiag diag, size_t M, size_t N, FloatComplex alpha, const cl_mem A, size_t offA, size_t lda, cl_mem B, size_t offB, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCtrmv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCtrsm)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, clAmdBlasTranspose transA, clAmdBlasDiag diag, size_t M, size_t N, FloatComplex alpha, const cl_mem A, size_t lda, cl_mem B, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCtrsmEx)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, clAmdBlasTranspose transA, clAmdBlasDiag diag, size_t M, size_t N, FloatComplex alpha, const cl_mem A, size_t offA, size_t lda, cl_mem B, size_t offB, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasCtrsv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDasum)(size_t N, cl_mem asum, size_t offAsum, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDaxpy)(size_t N, cl_double alpha, const cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDcopy)(size_t N, const cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDdot)(size_t N, cl_mem dotProduct, size_t offDP, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDgbmv)(clAmdBlasOrder order, clAmdBlasTranspose trans, size_t M, size_t N, size_t KL, size_t KU, cl_double alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem X, size_t offx, int incx, cl_double beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDgemm)(clAmdBlasOrder order, clAmdBlasTranspose transA, clAmdBlasTranspose transB, size_t M, size_t N, size_t K, cl_double alpha, const cl_mem A, size_t lda, const cl_mem B, size_t ldb, cl_double beta, cl_mem C, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDgemmEx)(clAmdBlasOrder order, clAmdBlasTranspose transA, clAmdBlasTranspose transB, size_t M, size_t N, size_t K, cl_double alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem B, size_t offB, size_t ldb, cl_double beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDgemv)(clAmdBlasOrder order, clAmdBlasTranspose transA, size_t M, size_t N, cl_double alpha, const cl_mem A, size_t lda, const cl_mem x, size_t offx, int incx, cl_double beta, cl_mem y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDgemvEx)(clAmdBlasOrder order, clAmdBlasTranspose transA, size_t M, size_t N, cl_double alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem x, size_t offx, int incx, cl_double beta, cl_mem y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDger)(clAmdBlasOrder order, size_t M, size_t N, cl_double alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDnrm2)(size_t N, cl_mem NRM2, size_t offNRM2, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDrot)(size_t N, cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_double C, cl_double S, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDrotg)(cl_mem DA, size_t offDA, cl_mem DB, size_t offDB, cl_mem C, size_t offC, cl_mem S, size_t offS, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDrotm)(size_t N, cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, const cl_mem DPARAM, size_t offDparam, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDrotmg)(cl_mem DD1, size_t offDD1, cl_mem DD2, size_t offDD2, cl_mem DX1, size_t offDX1, const cl_mem DY1, size_t offDY1, cl_mem DPARAM, size_t offDparam, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDsbmv)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, size_t K, cl_double alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem X, size_t offx, int incx, cl_double beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDscal)(size_t N, cl_double alpha, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDspmv)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_double alpha, const cl_mem AP, size_t offa, const cl_mem X, size_t offx, int incx, cl_double beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDspr)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_double alpha, const cl_mem X, size_t offx, int incx, cl_mem AP, size_t offa, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDspr2)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_double alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem AP, size_t offa, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDswap)(size_t N, cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDsymm)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, size_t M, size_t N, cl_double alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem B, size_t offb, size_t ldb, cl_double beta, cl_mem C, size_t offc, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDsymv)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_double alpha, const cl_mem A, size_t lda, const cl_mem x, size_t offx, int incx, cl_double beta, cl_mem y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDsymvEx)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_double alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem x, size_t offx, int incx, cl_double beta, cl_mem y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDsyr)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_double alpha, const cl_mem X, size_t offx, int incx, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDsyr2)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_double alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDsyr2k)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose transAB, size_t N, size_t K, cl_double alpha, const cl_mem A, size_t lda, const cl_mem B, size_t ldb, cl_double beta, cl_mem C, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDsyr2kEx)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose transAB, size_t N, size_t K, cl_double alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem B, size_t offB, size_t ldb, cl_double beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDsyrk)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose transA, size_t N, size_t K, cl_double alpha, const cl_mem A, size_t lda, cl_double beta, cl_mem C, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDsyrkEx)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose transA, size_t N, size_t K, cl_double alpha, const cl_mem A, size_t offA, size_t lda, cl_double beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDtbmv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, size_t K, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDtbsv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, size_t K, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDtpmv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, const cl_mem AP, size_t offa, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDtpsv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, const cl_mem A, size_t offa, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDtrmm)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, clAmdBlasTranspose transA, clAmdBlasDiag diag, size_t M, size_t N, cl_double alpha, const cl_mem A, size_t lda, cl_mem B, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDtrmmEx)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, clAmdBlasTranspose transA, clAmdBlasDiag diag, size_t M, size_t N, cl_double alpha, const cl_mem A, size_t offA, size_t lda, cl_mem B, size_t offB, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDtrmv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDtrsm)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, clAmdBlasTranspose transA, clAmdBlasDiag diag, size_t M, size_t N, cl_double alpha, const cl_mem A, size_t lda, cl_mem B, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDtrsmEx)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, clAmdBlasTranspose transA, clAmdBlasDiag diag, size_t M, size_t N, cl_double alpha, const cl_mem A, size_t offA, size_t lda, cl_mem B, size_t offB, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDtrsv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDzasum)(size_t N, cl_mem asum, size_t offAsum, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasDznrm2)(size_t N, cl_mem NRM2, size_t offNRM2, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasGetVersion)(cl_uint* major, cl_uint* minor, cl_uint* patch); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasRemoveScratchImage)(cl_ulong imageID); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSasum)(size_t N, cl_mem asum, size_t offAsum, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSaxpy)(size_t N, cl_float alpha, const cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasScasum)(size_t N, cl_mem asum, size_t offAsum, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasScnrm2)(size_t N, cl_mem NRM2, size_t offNRM2, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasScopy)(size_t N, const cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSdot)(size_t N, cl_mem dotProduct, size_t offDP, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSetup)(); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSgbmv)(clAmdBlasOrder order, clAmdBlasTranspose trans, size_t M, size_t N, size_t KL, size_t KU, cl_float alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem X, size_t offx, int incx, cl_float beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSgemm)(clAmdBlasOrder order, clAmdBlasTranspose transA, clAmdBlasTranspose transB, size_t M, size_t N, size_t K, cl_float alpha, const cl_mem A, size_t lda, const cl_mem B, size_t ldb, cl_float beta, cl_mem C, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSgemmEx)(clAmdBlasOrder order, clAmdBlasTranspose transA, clAmdBlasTranspose transB, size_t M, size_t N, size_t K, cl_float alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem B, size_t offB, size_t ldb, cl_float beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSgemv)(clAmdBlasOrder order, clAmdBlasTranspose transA, size_t M, size_t N, cl_float alpha, const cl_mem A, size_t lda, const cl_mem x, size_t offx, int incx, cl_float beta, cl_mem y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSgemvEx)(clAmdBlasOrder order, clAmdBlasTranspose transA, size_t M, size_t N, cl_float alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem x, size_t offx, int incx, cl_float beta, cl_mem y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSger)(clAmdBlasOrder order, size_t M, size_t N, cl_float alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSnrm2)(size_t N, cl_mem NRM2, size_t offNRM2, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSrot)(size_t N, cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_float C, cl_float S, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSrotg)(cl_mem SA, size_t offSA, cl_mem SB, size_t offSB, cl_mem C, size_t offC, cl_mem S, size_t offS, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSrotm)(size_t N, cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, const cl_mem SPARAM, size_t offSparam, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSrotmg)(cl_mem SD1, size_t offSD1, cl_mem SD2, size_t offSD2, cl_mem SX1, size_t offSX1, const cl_mem SY1, size_t offSY1, cl_mem SPARAM, size_t offSparam, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSsbmv)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, size_t K, cl_float alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem X, size_t offx, int incx, cl_float beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSscal)(size_t N, cl_float alpha, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSspmv)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_float alpha, const cl_mem AP, size_t offa, const cl_mem X, size_t offx, int incx, cl_float beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSspr)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_float alpha, const cl_mem X, size_t offx, int incx, cl_mem AP, size_t offa, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSspr2)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_float alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem AP, size_t offa, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSswap)(size_t N, cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSsymm)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, size_t M, size_t N, cl_float alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem B, size_t offb, size_t ldb, cl_float beta, cl_mem C, size_t offc, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSsymv)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_float alpha, const cl_mem A, size_t lda, const cl_mem x, size_t offx, int incx, cl_float beta, cl_mem y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSsymvEx)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_float alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem x, size_t offx, int incx, cl_float beta, cl_mem y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSsyr)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_float alpha, const cl_mem X, size_t offx, int incx, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSsyr2)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_float alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSsyr2k)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose transAB, size_t N, size_t K, cl_float alpha, const cl_mem A, size_t lda, const cl_mem B, size_t ldb, cl_float beta, cl_mem C, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSsyr2kEx)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose transAB, size_t N, size_t K, cl_float alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem B, size_t offB, size_t ldb, cl_float beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSsyrk)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose transA, size_t N, size_t K, cl_float alpha, const cl_mem A, size_t lda, cl_float beta, cl_mem C, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasSsyrkEx)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose transA, size_t N, size_t K, cl_float alpha, const cl_mem A, size_t offA, size_t lda, cl_float beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasStbmv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, size_t K, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasStbsv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, size_t K, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasStpmv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, const cl_mem AP, size_t offa, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasStpsv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, const cl_mem A, size_t offa, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasStrmm)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, clAmdBlasTranspose transA, clAmdBlasDiag diag, size_t M, size_t N, cl_float alpha, const cl_mem A, size_t lda, cl_mem B, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasStrmmEx)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, clAmdBlasTranspose transA, clAmdBlasDiag diag, size_t M, size_t N, cl_float alpha, const cl_mem A, size_t offA, size_t lda, cl_mem B, size_t offB, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasStrmv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasStrsm)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, clAmdBlasTranspose transA, clAmdBlasDiag diag, size_t M, size_t N, cl_float alpha, const cl_mem A, size_t lda, cl_mem B, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasStrsmEx)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, clAmdBlasTranspose transA, clAmdBlasDiag diag, size_t M, size_t N, cl_float alpha, const cl_mem A, size_t offA, size_t lda, cl_mem B, size_t offB, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasStrsv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -extern CL_RUNTIME_EXPORT void (*clAmdBlasTeardown)(); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZaxpy)(size_t N, cl_double2 alpha, const cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZcopy)(size_t N, const cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZdotc)(size_t N, cl_mem dotProduct, size_t offDP, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZdotu)(size_t N, cl_mem dotProduct, size_t offDP, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZdrot)(size_t N, cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_double C, cl_double S, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZdscal)(size_t N, cl_double alpha, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZgbmv)(clAmdBlasOrder order, clAmdBlasTranspose trans, size_t M, size_t N, size_t KL, size_t KU, cl_double2 alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem X, size_t offx, int incx, cl_double2 beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZgemm)(clAmdBlasOrder order, clAmdBlasTranspose transA, clAmdBlasTranspose transB, size_t M, size_t N, size_t K, DoubleComplex alpha, const cl_mem A, size_t lda, const cl_mem B, size_t ldb, DoubleComplex beta, cl_mem C, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZgemmEx)(clAmdBlasOrder order, clAmdBlasTranspose transA, clAmdBlasTranspose transB, size_t M, size_t N, size_t K, DoubleComplex alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem B, size_t offB, size_t ldb, DoubleComplex beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZgemv)(clAmdBlasOrder order, clAmdBlasTranspose transA, size_t M, size_t N, DoubleComplex alpha, const cl_mem A, size_t lda, const cl_mem x, size_t offx, int incx, DoubleComplex beta, cl_mem y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZgemvEx)(clAmdBlasOrder order, clAmdBlasTranspose transA, size_t M, size_t N, DoubleComplex alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem x, size_t offx, int incx, DoubleComplex beta, cl_mem y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZgerc)(clAmdBlasOrder order, size_t M, size_t N, cl_double2 alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZgeru)(clAmdBlasOrder order, size_t M, size_t N, cl_double2 alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZhbmv)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, size_t K, cl_double2 alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem X, size_t offx, int incx, cl_double2 beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZhemm)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, size_t M, size_t N, cl_double2 alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem B, size_t offb, size_t ldb, cl_double2 beta, cl_mem C, size_t offc, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZhemv)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, DoubleComplex alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem X, size_t offx, int incx, DoubleComplex beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZher)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_double alpha, const cl_mem X, size_t offx, int incx, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZher2)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_double2 alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZher2k)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, size_t N, size_t K, DoubleComplex alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem B, size_t offb, size_t ldb, cl_double beta, cl_mem C, size_t offc, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZherk)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose transA, size_t N, size_t K, double alpha, const cl_mem A, size_t offa, size_t lda, double beta, cl_mem C, size_t offc, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZhpmv)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_double2 alpha, const cl_mem AP, size_t offa, const cl_mem X, size_t offx, int incx, cl_double2 beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZhpr)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_double alpha, const cl_mem X, size_t offx, int incx, cl_mem AP, size_t offa, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZhpr2)(clAmdBlasOrder order, clAmdBlasUplo uplo, size_t N, cl_double2 alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem AP, size_t offa, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZrotg)(cl_mem CA, size_t offCA, cl_mem CB, size_t offCB, cl_mem C, size_t offC, cl_mem S, size_t offS, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZscal)(size_t N, cl_double2 alpha, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZswap)(size_t N, cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZsymm)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, size_t M, size_t N, cl_double2 alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem B, size_t offb, size_t ldb, cl_double2 beta, cl_mem C, size_t offc, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZsyr2k)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose transAB, size_t N, size_t K, DoubleComplex alpha, const cl_mem A, size_t lda, const cl_mem B, size_t ldb, DoubleComplex beta, cl_mem C, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZsyr2kEx)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose transAB, size_t N, size_t K, DoubleComplex alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem B, size_t offB, size_t ldb, DoubleComplex beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZsyrk)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose transA, size_t N, size_t K, DoubleComplex alpha, const cl_mem A, size_t lda, DoubleComplex beta, cl_mem C, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZsyrkEx)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose transA, size_t N, size_t K, DoubleComplex alpha, const cl_mem A, size_t offA, size_t lda, DoubleComplex beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZtbmv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, size_t K, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZtbsv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, size_t K, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZtpmv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, const cl_mem AP, size_t offa, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZtpsv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, const cl_mem A, size_t offa, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZtrmm)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, clAmdBlasTranspose transA, clAmdBlasDiag diag, size_t M, size_t N, DoubleComplex alpha, const cl_mem A, size_t lda, cl_mem B, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZtrmmEx)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, clAmdBlasTranspose transA, clAmdBlasDiag diag, size_t M, size_t N, DoubleComplex alpha, const cl_mem A, size_t offA, size_t lda, cl_mem B, size_t offB, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZtrmv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZtrsm)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, clAmdBlasTranspose transA, clAmdBlasDiag diag, size_t M, size_t N, DoubleComplex alpha, const cl_mem A, size_t lda, cl_mem B, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZtrsmEx)(clAmdBlasOrder order, clAmdBlasSide side, clAmdBlasUplo uplo, clAmdBlasTranspose transA, clAmdBlasDiag diag, size_t M, size_t N, DoubleComplex alpha, const cl_mem A, size_t offA, size_t lda, cl_mem B, size_t offB, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasZtrsv)(clAmdBlasOrder order, clAmdBlasUplo uplo, clAmdBlasTranspose trans, clAmdBlasDiag diag, size_t N, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasiCamax)(size_t N, cl_mem iMax, size_t offiMax, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasiDamax)(size_t N, cl_mem iMax, size_t offiMax, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasiSamax)(size_t N, cl_mem iMax, size_t offiMax, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); -//extern CL_RUNTIME_EXPORT clAmdBlasStatus (*clAmdBlasiZamax)(size_t N, cl_mem iMax, size_t offiMax, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); diff --git a/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clamdfft.hpp b/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clamdfft.hpp deleted file mode 100644 index 1457d7eb8d..0000000000 --- a/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clamdfft.hpp +++ /dev/null @@ -1,142 +0,0 @@ -// -// AUTOGENERATED, DO NOT EDIT -// -#ifndef OPENCV_CORE_OCL_RUNTIME_CLAMDFFT_HPP -#error "Invalid usage" -#endif - -// generated by parser_clamdfft.py -#define clAmdFftBakePlan clAmdFftBakePlan_ -#define clAmdFftCopyPlan clAmdFftCopyPlan_ -#define clAmdFftCreateDefaultPlan clAmdFftCreateDefaultPlan_ -#define clAmdFftDestroyPlan clAmdFftDestroyPlan_ -#define clAmdFftEnqueueTransform clAmdFftEnqueueTransform_ -#define clAmdFftGetLayout clAmdFftGetLayout_ -#define clAmdFftGetPlanBatchSize clAmdFftGetPlanBatchSize_ -#define clAmdFftGetPlanContext clAmdFftGetPlanContext_ -#define clAmdFftGetPlanDim clAmdFftGetPlanDim_ -#define clAmdFftGetPlanDistance clAmdFftGetPlanDistance_ -#define clAmdFftGetPlanInStride clAmdFftGetPlanInStride_ -#define clAmdFftGetPlanLength clAmdFftGetPlanLength_ -#define clAmdFftGetPlanOutStride clAmdFftGetPlanOutStride_ -#define clAmdFftGetPlanPrecision clAmdFftGetPlanPrecision_ -#define clAmdFftGetPlanScale clAmdFftGetPlanScale_ -#define clAmdFftGetPlanTransposeResult clAmdFftGetPlanTransposeResult_ -#define clAmdFftGetResultLocation clAmdFftGetResultLocation_ -#define clAmdFftGetTmpBufSize clAmdFftGetTmpBufSize_ -#define clAmdFftGetVersion clAmdFftGetVersion_ -#define clAmdFftSetLayout clAmdFftSetLayout_ -#define clAmdFftSetPlanBatchSize clAmdFftSetPlanBatchSize_ -#define clAmdFftSetPlanDim clAmdFftSetPlanDim_ -#define clAmdFftSetPlanDistance clAmdFftSetPlanDistance_ -#define clAmdFftSetPlanInStride clAmdFftSetPlanInStride_ -#define clAmdFftSetPlanLength clAmdFftSetPlanLength_ -#define clAmdFftSetPlanOutStride clAmdFftSetPlanOutStride_ -#define clAmdFftSetPlanPrecision clAmdFftSetPlanPrecision_ -#define clAmdFftSetPlanScale clAmdFftSetPlanScale_ -#define clAmdFftSetPlanTransposeResult clAmdFftSetPlanTransposeResult_ -#define clAmdFftSetResultLocation clAmdFftSetResultLocation_ -#define clAmdFftSetup clAmdFftSetup_ -#define clAmdFftTeardown clAmdFftTeardown_ - -#include - -// generated by parser_clamdfft.py -#undef clAmdFftBakePlan -#define clAmdFftBakePlan clAmdFftBakePlan_pfn -#undef clAmdFftCopyPlan -//#define clAmdFftCopyPlan clAmdFftCopyPlan_pfn -#undef clAmdFftCreateDefaultPlan -#define clAmdFftCreateDefaultPlan clAmdFftCreateDefaultPlan_pfn -#undef clAmdFftDestroyPlan -#define clAmdFftDestroyPlan clAmdFftDestroyPlan_pfn -#undef clAmdFftEnqueueTransform -#define clAmdFftEnqueueTransform clAmdFftEnqueueTransform_pfn -#undef clAmdFftGetLayout -//#define clAmdFftGetLayout clAmdFftGetLayout_pfn -#undef clAmdFftGetPlanBatchSize -//#define clAmdFftGetPlanBatchSize clAmdFftGetPlanBatchSize_pfn -#undef clAmdFftGetPlanContext -//#define clAmdFftGetPlanContext clAmdFftGetPlanContext_pfn -#undef clAmdFftGetPlanDim -//#define clAmdFftGetPlanDim clAmdFftGetPlanDim_pfn -#undef clAmdFftGetPlanDistance -//#define clAmdFftGetPlanDistance clAmdFftGetPlanDistance_pfn -#undef clAmdFftGetPlanInStride -//#define clAmdFftGetPlanInStride clAmdFftGetPlanInStride_pfn -#undef clAmdFftGetPlanLength -//#define clAmdFftGetPlanLength clAmdFftGetPlanLength_pfn -#undef clAmdFftGetPlanOutStride -//#define clAmdFftGetPlanOutStride clAmdFftGetPlanOutStride_pfn -#undef clAmdFftGetPlanPrecision -//#define clAmdFftGetPlanPrecision clAmdFftGetPlanPrecision_pfn -#undef clAmdFftGetPlanScale -//#define clAmdFftGetPlanScale clAmdFftGetPlanScale_pfn -#undef clAmdFftGetPlanTransposeResult -//#define clAmdFftGetPlanTransposeResult clAmdFftGetPlanTransposeResult_pfn -#undef clAmdFftGetResultLocation -//#define clAmdFftGetResultLocation clAmdFftGetResultLocation_pfn -#undef clAmdFftGetTmpBufSize -#define clAmdFftGetTmpBufSize clAmdFftGetTmpBufSize_pfn -#undef clAmdFftGetVersion -#define clAmdFftGetVersion clAmdFftGetVersion_pfn -#undef clAmdFftSetLayout -#define clAmdFftSetLayout clAmdFftSetLayout_pfn -#undef clAmdFftSetPlanBatchSize -#define clAmdFftSetPlanBatchSize clAmdFftSetPlanBatchSize_pfn -#undef clAmdFftSetPlanDim -//#define clAmdFftSetPlanDim clAmdFftSetPlanDim_pfn -#undef clAmdFftSetPlanDistance -#define clAmdFftSetPlanDistance clAmdFftSetPlanDistance_pfn -#undef clAmdFftSetPlanInStride -#define clAmdFftSetPlanInStride clAmdFftSetPlanInStride_pfn -#undef clAmdFftSetPlanLength -//#define clAmdFftSetPlanLength clAmdFftSetPlanLength_pfn -#undef clAmdFftSetPlanOutStride -#define clAmdFftSetPlanOutStride clAmdFftSetPlanOutStride_pfn -#undef clAmdFftSetPlanPrecision -#define clAmdFftSetPlanPrecision clAmdFftSetPlanPrecision_pfn -#undef clAmdFftSetPlanScale -#define clAmdFftSetPlanScale clAmdFftSetPlanScale_pfn -#undef clAmdFftSetPlanTransposeResult -//#define clAmdFftSetPlanTransposeResult clAmdFftSetPlanTransposeResult_pfn -#undef clAmdFftSetResultLocation -#define clAmdFftSetResultLocation clAmdFftSetResultLocation_pfn -#undef clAmdFftSetup -#define clAmdFftSetup clAmdFftSetup_pfn -#undef clAmdFftTeardown -#define clAmdFftTeardown clAmdFftTeardown_pfn - -// generated by parser_clamdfft.py -extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftBakePlan)(clAmdFftPlanHandle plHandle, cl_uint numQueues, cl_command_queue* commQueueFFT, void (CL_CALLBACK* pfn_notify) (clAmdFftPlanHandle plHandle, void* user_data), void* user_data); -//extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftCopyPlan)(clAmdFftPlanHandle* out_plHandle, cl_context new_context, clAmdFftPlanHandle in_plHandle); -extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftCreateDefaultPlan)(clAmdFftPlanHandle* plHandle, cl_context context, const clAmdFftDim dim, const size_t* clLengths); -extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftDestroyPlan)(clAmdFftPlanHandle* plHandle); -extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftEnqueueTransform)(clAmdFftPlanHandle plHandle, clAmdFftDirection dir, cl_uint numQueuesAndEvents, cl_command_queue* commQueues, cl_uint numWaitEvents, const cl_event* waitEvents, cl_event* outEvents, cl_mem* inputBuffers, cl_mem* outputBuffers, cl_mem tmpBuffer); -//extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftGetLayout)(const clAmdFftPlanHandle plHandle, clAmdFftLayout* iLayout, clAmdFftLayout* oLayout); -//extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftGetPlanBatchSize)(const clAmdFftPlanHandle plHandle, size_t* batchSize); -//extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftGetPlanContext)(const clAmdFftPlanHandle plHandle, cl_context* context); -//extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftGetPlanDim)(const clAmdFftPlanHandle plHandle, clAmdFftDim* dim, cl_uint* size); -//extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftGetPlanDistance)(const clAmdFftPlanHandle plHandle, size_t* iDist, size_t* oDist); -//extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftGetPlanInStride)(const clAmdFftPlanHandle plHandle, const clAmdFftDim dim, size_t* clStrides); -//extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftGetPlanLength)(const clAmdFftPlanHandle plHandle, const clAmdFftDim dim, size_t* clLengths); -//extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftGetPlanOutStride)(const clAmdFftPlanHandle plHandle, const clAmdFftDim dim, size_t* clStrides); -//extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftGetPlanPrecision)(const clAmdFftPlanHandle plHandle, clAmdFftPrecision* precision); -//extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftGetPlanScale)(const clAmdFftPlanHandle plHandle, clAmdFftDirection dir, cl_float* scale); -//extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftGetPlanTransposeResult)(const clAmdFftPlanHandle plHandle, clAmdFftResultTransposed* transposed); -//extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftGetResultLocation)(const clAmdFftPlanHandle plHandle, clAmdFftResultLocation* placeness); -extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftGetTmpBufSize)(const clAmdFftPlanHandle plHandle, size_t* buffersize); -extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftGetVersion)(cl_uint* major, cl_uint* minor, cl_uint* patch); -extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftSetLayout)(clAmdFftPlanHandle plHandle, clAmdFftLayout iLayout, clAmdFftLayout oLayout); -extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftSetPlanBatchSize)(clAmdFftPlanHandle plHandle, size_t batchSize); -//extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftSetPlanDim)(clAmdFftPlanHandle plHandle, const clAmdFftDim dim); -extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftSetPlanDistance)(clAmdFftPlanHandle plHandle, size_t iDist, size_t oDist); -extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftSetPlanInStride)(clAmdFftPlanHandle plHandle, const clAmdFftDim dim, size_t* clStrides); -//extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftSetPlanLength)(clAmdFftPlanHandle plHandle, const clAmdFftDim dim, const size_t* clLengths); -extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftSetPlanOutStride)(clAmdFftPlanHandle plHandle, const clAmdFftDim dim, size_t* clStrides); -extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftSetPlanPrecision)(clAmdFftPlanHandle plHandle, clAmdFftPrecision precision); -extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftSetPlanScale)(clAmdFftPlanHandle plHandle, clAmdFftDirection dir, cl_float scale); -//extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftSetPlanTransposeResult)(clAmdFftPlanHandle plHandle, clAmdFftResultTransposed transposed); -extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftSetResultLocation)(clAmdFftPlanHandle plHandle, clAmdFftResultLocation placeness); -extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftSetup)(const clAmdFftSetupData* setupData); -extern CL_RUNTIME_EXPORT clAmdFftStatus (*clAmdFftTeardown)(); diff --git a/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clblas.hpp b/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clblas.hpp new file mode 100644 index 0000000000..2749927bea --- /dev/null +++ b/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clblas.hpp @@ -0,0 +1,602 @@ +// +// AUTOGENERATED, DO NOT EDIT +// +#ifndef OPENCV_CORE_OCL_RUNTIME_CLAMDBLAS_HPP +#error "Invalid usage" +#endif + +// generated by parser_clblas.py +#define clblasCaxpy clblasCaxpy_ +#define clblasCcopy clblasCcopy_ +#define clblasCdotc clblasCdotc_ +#define clblasCdotu clblasCdotu_ +#define clblasCgbmv clblasCgbmv_ +#define clblasCgemm clblasCgemm_ +#define clblasCgemv clblasCgemv_ +#define clblasCgerc clblasCgerc_ +#define clblasCgeru clblasCgeru_ +#define clblasChbmv clblasChbmv_ +#define clblasChemm clblasChemm_ +#define clblasChemv clblasChemv_ +#define clblasCher clblasCher_ +#define clblasCher2 clblasCher2_ +#define clblasCher2k clblasCher2k_ +#define clblasCherk clblasCherk_ +#define clblasChpmv clblasChpmv_ +#define clblasChpr clblasChpr_ +#define clblasChpr2 clblasChpr2_ +#define clblasCrotg clblasCrotg_ +#define clblasCscal clblasCscal_ +#define clblasCsrot clblasCsrot_ +#define clblasCsscal clblasCsscal_ +#define clblasCswap clblasCswap_ +#define clblasCsymm clblasCsymm_ +#define clblasCsyr2k clblasCsyr2k_ +#define clblasCsyrk clblasCsyrk_ +#define clblasCtbmv clblasCtbmv_ +#define clblasCtbsv clblasCtbsv_ +#define clblasCtpmv clblasCtpmv_ +#define clblasCtpsv clblasCtpsv_ +#define clblasCtrmm clblasCtrmm_ +#define clblasCtrmv clblasCtrmv_ +#define clblasCtrsm clblasCtrsm_ +#define clblasCtrsv clblasCtrsv_ +#define clblasDasum clblasDasum_ +#define clblasDaxpy clblasDaxpy_ +#define clblasDcopy clblasDcopy_ +#define clblasDdot clblasDdot_ +#define clblasDgbmv clblasDgbmv_ +#define clblasDgemm clblasDgemm_ +#define clblasDgemv clblasDgemv_ +#define clblasDger clblasDger_ +#define clblasDnrm2 clblasDnrm2_ +#define clblasDrot clblasDrot_ +#define clblasDrotg clblasDrotg_ +#define clblasDrotm clblasDrotm_ +#define clblasDrotmg clblasDrotmg_ +#define clblasDsbmv clblasDsbmv_ +#define clblasDscal clblasDscal_ +#define clblasDspmv clblasDspmv_ +#define clblasDspr clblasDspr_ +#define clblasDspr2 clblasDspr2_ +#define clblasDswap clblasDswap_ +#define clblasDsymm clblasDsymm_ +#define clblasDsymv clblasDsymv_ +#define clblasDsyr clblasDsyr_ +#define clblasDsyr2 clblasDsyr2_ +#define clblasDsyr2k clblasDsyr2k_ +#define clblasDsyrk clblasDsyrk_ +#define clblasDtbmv clblasDtbmv_ +#define clblasDtbsv clblasDtbsv_ +#define clblasDtpmv clblasDtpmv_ +#define clblasDtpsv clblasDtpsv_ +#define clblasDtrmm clblasDtrmm_ +#define clblasDtrmv clblasDtrmv_ +#define clblasDtrsm clblasDtrsm_ +#define clblasDtrsv clblasDtrsv_ +#define clblasDzasum clblasDzasum_ +#define clblasDznrm2 clblasDznrm2_ +#define clblasGetVersion clblasGetVersion_ +#define clblasSasum clblasSasum_ +#define clblasSaxpy clblasSaxpy_ +#define clblasScasum clblasScasum_ +#define clblasScnrm2 clblasScnrm2_ +#define clblasScopy clblasScopy_ +#define clblasSdot clblasSdot_ +#define clblasSetup clblasSetup_ +#define clblasSgbmv clblasSgbmv_ +#define clblasSgemm clblasSgemm_ +#define clblasSgemv clblasSgemv_ +#define clblasSger clblasSger_ +#define clblasSnrm2 clblasSnrm2_ +#define clblasSrot clblasSrot_ +#define clblasSrotg clblasSrotg_ +#define clblasSrotm clblasSrotm_ +#define clblasSrotmg clblasSrotmg_ +#define clblasSsbmv clblasSsbmv_ +#define clblasSscal clblasSscal_ +#define clblasSspmv clblasSspmv_ +#define clblasSspr clblasSspr_ +#define clblasSspr2 clblasSspr2_ +#define clblasSswap clblasSswap_ +#define clblasSsymm clblasSsymm_ +#define clblasSsymv clblasSsymv_ +#define clblasSsyr clblasSsyr_ +#define clblasSsyr2 clblasSsyr2_ +#define clblasSsyr2k clblasSsyr2k_ +#define clblasSsyrk clblasSsyrk_ +#define clblasStbmv clblasStbmv_ +#define clblasStbsv clblasStbsv_ +#define clblasStpmv clblasStpmv_ +#define clblasStpsv clblasStpsv_ +#define clblasStrmm clblasStrmm_ +#define clblasStrmv clblasStrmv_ +#define clblasStrsm clblasStrsm_ +#define clblasStrsv clblasStrsv_ +#define clblasTeardown clblasTeardown_ +#define clblasZaxpy clblasZaxpy_ +#define clblasZcopy clblasZcopy_ +#define clblasZdotc clblasZdotc_ +#define clblasZdotu clblasZdotu_ +#define clblasZdrot clblasZdrot_ +#define clblasZdscal clblasZdscal_ +#define clblasZgbmv clblasZgbmv_ +#define clblasZgemm clblasZgemm_ +#define clblasZgemv clblasZgemv_ +#define clblasZgerc clblasZgerc_ +#define clblasZgeru clblasZgeru_ +#define clblasZhbmv clblasZhbmv_ +#define clblasZhemm clblasZhemm_ +#define clblasZhemv clblasZhemv_ +#define clblasZher clblasZher_ +#define clblasZher2 clblasZher2_ +#define clblasZher2k clblasZher2k_ +#define clblasZherk clblasZherk_ +#define clblasZhpmv clblasZhpmv_ +#define clblasZhpr clblasZhpr_ +#define clblasZhpr2 clblasZhpr2_ +#define clblasZrotg clblasZrotg_ +#define clblasZscal clblasZscal_ +#define clblasZswap clblasZswap_ +#define clblasZsymm clblasZsymm_ +#define clblasZsyr2k clblasZsyr2k_ +#define clblasZsyrk clblasZsyrk_ +#define clblasZtbmv clblasZtbmv_ +#define clblasZtbsv clblasZtbsv_ +#define clblasZtpmv clblasZtpmv_ +#define clblasZtpsv clblasZtpsv_ +#define clblasZtrmm clblasZtrmm_ +#define clblasZtrmv clblasZtrmv_ +#define clblasZtrsm clblasZtrsm_ +#define clblasZtrsv clblasZtrsv_ +#define clblasiCamax clblasiCamax_ +#define clblasiDamax clblasiDamax_ +#define clblasiSamax clblasiSamax_ +#define clblasiZamax clblasiZamax_ + +#include + +// generated by parser_clblas.py +#undef clblasCaxpy +//#define clblasCaxpy clblasCaxpy_pfn +#undef clblasCcopy +//#define clblasCcopy clblasCcopy_pfn +#undef clblasCdotc +//#define clblasCdotc clblasCdotc_pfn +#undef clblasCdotu +//#define clblasCdotu clblasCdotu_pfn +#undef clblasCgbmv +//#define clblasCgbmv clblasCgbmv_pfn +#undef clblasCgemm +#define clblasCgemm clblasCgemm_pfn +#undef clblasCgemv +//#define clblasCgemv clblasCgemv_pfn +#undef clblasCgerc +//#define clblasCgerc clblasCgerc_pfn +#undef clblasCgeru +//#define clblasCgeru clblasCgeru_pfn +#undef clblasChbmv +//#define clblasChbmv clblasChbmv_pfn +#undef clblasChemm +//#define clblasChemm clblasChemm_pfn +#undef clblasChemv +//#define clblasChemv clblasChemv_pfn +#undef clblasCher +//#define clblasCher clblasCher_pfn +#undef clblasCher2 +//#define clblasCher2 clblasCher2_pfn +#undef clblasCher2k +//#define clblasCher2k clblasCher2k_pfn +#undef clblasCherk +//#define clblasCherk clblasCherk_pfn +#undef clblasChpmv +//#define clblasChpmv clblasChpmv_pfn +#undef clblasChpr +//#define clblasChpr clblasChpr_pfn +#undef clblasChpr2 +//#define clblasChpr2 clblasChpr2_pfn +#undef clblasCrotg +//#define clblasCrotg clblasCrotg_pfn +#undef clblasCscal +//#define clblasCscal clblasCscal_pfn +#undef clblasCsrot +//#define clblasCsrot clblasCsrot_pfn +#undef clblasCsscal +//#define clblasCsscal clblasCsscal_pfn +#undef clblasCswap +//#define clblasCswap clblasCswap_pfn +#undef clblasCsymm +//#define clblasCsymm clblasCsymm_pfn +#undef clblasCsyr2k +//#define clblasCsyr2k clblasCsyr2k_pfn +#undef clblasCsyrk +//#define clblasCsyrk clblasCsyrk_pfn +#undef clblasCtbmv +//#define clblasCtbmv clblasCtbmv_pfn +#undef clblasCtbsv +//#define clblasCtbsv clblasCtbsv_pfn +#undef clblasCtpmv +//#define clblasCtpmv clblasCtpmv_pfn +#undef clblasCtpsv +//#define clblasCtpsv clblasCtpsv_pfn +#undef clblasCtrmm +//#define clblasCtrmm clblasCtrmm_pfn +#undef clblasCtrmv +//#define clblasCtrmv clblasCtrmv_pfn +#undef clblasCtrsm +//#define clblasCtrsm clblasCtrsm_pfn +#undef clblasCtrsv +//#define clblasCtrsv clblasCtrsv_pfn +#undef clblasDasum +//#define clblasDasum clblasDasum_pfn +#undef clblasDaxpy +//#define clblasDaxpy clblasDaxpy_pfn +#undef clblasDcopy +//#define clblasDcopy clblasDcopy_pfn +#undef clblasDdot +//#define clblasDdot clblasDdot_pfn +#undef clblasDgbmv +//#define clblasDgbmv clblasDgbmv_pfn +#undef clblasDgemm +#define clblasDgemm clblasDgemm_pfn +#undef clblasDgemv +//#define clblasDgemv clblasDgemv_pfn +#undef clblasDger +//#define clblasDger clblasDger_pfn +#undef clblasDnrm2 +//#define clblasDnrm2 clblasDnrm2_pfn +#undef clblasDrot +//#define clblasDrot clblasDrot_pfn +#undef clblasDrotg +//#define clblasDrotg clblasDrotg_pfn +#undef clblasDrotm +//#define clblasDrotm clblasDrotm_pfn +#undef clblasDrotmg +//#define clblasDrotmg clblasDrotmg_pfn +#undef clblasDsbmv +//#define clblasDsbmv clblasDsbmv_pfn +#undef clblasDscal +//#define clblasDscal clblasDscal_pfn +#undef clblasDspmv +//#define clblasDspmv clblasDspmv_pfn +#undef clblasDspr +//#define clblasDspr clblasDspr_pfn +#undef clblasDspr2 +//#define clblasDspr2 clblasDspr2_pfn +#undef clblasDswap +//#define clblasDswap clblasDswap_pfn +#undef clblasDsymm +//#define clblasDsymm clblasDsymm_pfn +#undef clblasDsymv +//#define clblasDsymv clblasDsymv_pfn +#undef clblasDsyr +//#define clblasDsyr clblasDsyr_pfn +#undef clblasDsyr2 +//#define clblasDsyr2 clblasDsyr2_pfn +#undef clblasDsyr2k +//#define clblasDsyr2k clblasDsyr2k_pfn +#undef clblasDsyrk +//#define clblasDsyrk clblasDsyrk_pfn +#undef clblasDtbmv +//#define clblasDtbmv clblasDtbmv_pfn +#undef clblasDtbsv +//#define clblasDtbsv clblasDtbsv_pfn +#undef clblasDtpmv +//#define clblasDtpmv clblasDtpmv_pfn +#undef clblasDtpsv +//#define clblasDtpsv clblasDtpsv_pfn +#undef clblasDtrmm +//#define clblasDtrmm clblasDtrmm_pfn +#undef clblasDtrmv +//#define clblasDtrmv clblasDtrmv_pfn +#undef clblasDtrsm +//#define clblasDtrsm clblasDtrsm_pfn +#undef clblasDtrsv +//#define clblasDtrsv clblasDtrsv_pfn +#undef clblasDzasum +//#define clblasDzasum clblasDzasum_pfn +#undef clblasDznrm2 +//#define clblasDznrm2 clblasDznrm2_pfn +#undef clblasGetVersion +//#define clblasGetVersion clblasGetVersion_pfn +#undef clblasSasum +//#define clblasSasum clblasSasum_pfn +#undef clblasSaxpy +//#define clblasSaxpy clblasSaxpy_pfn +#undef clblasScasum +//#define clblasScasum clblasScasum_pfn +#undef clblasScnrm2 +//#define clblasScnrm2 clblasScnrm2_pfn +#undef clblasScopy +//#define clblasScopy clblasScopy_pfn +#undef clblasSdot +//#define clblasSdot clblasSdot_pfn +#undef clblasSetup +#define clblasSetup clblasSetup_pfn +#undef clblasSgbmv +//#define clblasSgbmv clblasSgbmv_pfn +#undef clblasSgemm +#define clblasSgemm clblasSgemm_pfn +#undef clblasSgemv +//#define clblasSgemv clblasSgemv_pfn +#undef clblasSger +//#define clblasSger clblasSger_pfn +#undef clblasSnrm2 +//#define clblasSnrm2 clblasSnrm2_pfn +#undef clblasSrot +//#define clblasSrot clblasSrot_pfn +#undef clblasSrotg +//#define clblasSrotg clblasSrotg_pfn +#undef clblasSrotm +//#define clblasSrotm clblasSrotm_pfn +#undef clblasSrotmg +//#define clblasSrotmg clblasSrotmg_pfn +#undef clblasSsbmv +//#define clblasSsbmv clblasSsbmv_pfn +#undef clblasSscal +//#define clblasSscal clblasSscal_pfn +#undef clblasSspmv +//#define clblasSspmv clblasSspmv_pfn +#undef clblasSspr +//#define clblasSspr clblasSspr_pfn +#undef clblasSspr2 +//#define clblasSspr2 clblasSspr2_pfn +#undef clblasSswap +//#define clblasSswap clblasSswap_pfn +#undef clblasSsymm +//#define clblasSsymm clblasSsymm_pfn +#undef clblasSsymv +//#define clblasSsymv clblasSsymv_pfn +#undef clblasSsyr +//#define clblasSsyr clblasSsyr_pfn +#undef clblasSsyr2 +//#define clblasSsyr2 clblasSsyr2_pfn +#undef clblasSsyr2k +//#define clblasSsyr2k clblasSsyr2k_pfn +#undef clblasSsyrk +//#define clblasSsyrk clblasSsyrk_pfn +#undef clblasStbmv +//#define clblasStbmv clblasStbmv_pfn +#undef clblasStbsv +//#define clblasStbsv clblasStbsv_pfn +#undef clblasStpmv +//#define clblasStpmv clblasStpmv_pfn +#undef clblasStpsv +//#define clblasStpsv clblasStpsv_pfn +#undef clblasStrmm +//#define clblasStrmm clblasStrmm_pfn +#undef clblasStrmv +//#define clblasStrmv clblasStrmv_pfn +#undef clblasStrsm +//#define clblasStrsm clblasStrsm_pfn +#undef clblasStrsv +//#define clblasStrsv clblasStrsv_pfn +#undef clblasTeardown +#define clblasTeardown clblasTeardown_pfn +#undef clblasZaxpy +//#define clblasZaxpy clblasZaxpy_pfn +#undef clblasZcopy +//#define clblasZcopy clblasZcopy_pfn +#undef clblasZdotc +//#define clblasZdotc clblasZdotc_pfn +#undef clblasZdotu +//#define clblasZdotu clblasZdotu_pfn +#undef clblasZdrot +//#define clblasZdrot clblasZdrot_pfn +#undef clblasZdscal +//#define clblasZdscal clblasZdscal_pfn +#undef clblasZgbmv +//#define clblasZgbmv clblasZgbmv_pfn +#undef clblasZgemm +#define clblasZgemm clblasZgemm_pfn +#undef clblasZgemv +//#define clblasZgemv clblasZgemv_pfn +#undef clblasZgerc +//#define clblasZgerc clblasZgerc_pfn +#undef clblasZgeru +//#define clblasZgeru clblasZgeru_pfn +#undef clblasZhbmv +//#define clblasZhbmv clblasZhbmv_pfn +#undef clblasZhemm +//#define clblasZhemm clblasZhemm_pfn +#undef clblasZhemv +//#define clblasZhemv clblasZhemv_pfn +#undef clblasZher +//#define clblasZher clblasZher_pfn +#undef clblasZher2 +//#define clblasZher2 clblasZher2_pfn +#undef clblasZher2k +//#define clblasZher2k clblasZher2k_pfn +#undef clblasZherk +//#define clblasZherk clblasZherk_pfn +#undef clblasZhpmv +//#define clblasZhpmv clblasZhpmv_pfn +#undef clblasZhpr +//#define clblasZhpr clblasZhpr_pfn +#undef clblasZhpr2 +//#define clblasZhpr2 clblasZhpr2_pfn +#undef clblasZrotg +//#define clblasZrotg clblasZrotg_pfn +#undef clblasZscal +//#define clblasZscal clblasZscal_pfn +#undef clblasZswap +//#define clblasZswap clblasZswap_pfn +#undef clblasZsymm +//#define clblasZsymm clblasZsymm_pfn +#undef clblasZsyr2k +//#define clblasZsyr2k clblasZsyr2k_pfn +#undef clblasZsyrk +//#define clblasZsyrk clblasZsyrk_pfn +#undef clblasZtbmv +//#define clblasZtbmv clblasZtbmv_pfn +#undef clblasZtbsv +//#define clblasZtbsv clblasZtbsv_pfn +#undef clblasZtpmv +//#define clblasZtpmv clblasZtpmv_pfn +#undef clblasZtpsv +//#define clblasZtpsv clblasZtpsv_pfn +#undef clblasZtrmm +//#define clblasZtrmm clblasZtrmm_pfn +#undef clblasZtrmv +//#define clblasZtrmv clblasZtrmv_pfn +#undef clblasZtrsm +//#define clblasZtrsm clblasZtrsm_pfn +#undef clblasZtrsv +//#define clblasZtrsv clblasZtrsv_pfn +#undef clblasiCamax +//#define clblasiCamax clblasiCamax_pfn +#undef clblasiDamax +//#define clblasiDamax clblasiDamax_pfn +#undef clblasiSamax +//#define clblasiSamax clblasiSamax_pfn +#undef clblasiZamax +//#define clblasiZamax clblasiZamax_pfn + +// generated by parser_clblas.py +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCaxpy)(size_t N, cl_float2 alpha, const cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCcopy)(size_t N, const cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCdotc)(size_t N, cl_mem dotProduct, size_t offDP, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCdotu)(size_t N, cl_mem dotProduct, size_t offDP, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCgbmv)(clblasOrder order, clblasTranspose trans, size_t M, size_t N, size_t KL, size_t KU, cl_float2 alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem X, size_t offx, int incx, cl_float2 beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +extern CL_RUNTIME_EXPORT clblasStatus (*clblasCgemm)(clblasOrder order, clblasTranspose transA, clblasTranspose transB, size_t M, size_t N, size_t K, FloatComplex alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem B, size_t offB, size_t ldb, FloatComplex beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCgemv)(clblasOrder order, clblasTranspose transA, size_t M, size_t N, FloatComplex alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem x, size_t offx, int incx, FloatComplex beta, cl_mem y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCgerc)(clblasOrder order, size_t M, size_t N, cl_float2 alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCgeru)(clblasOrder order, size_t M, size_t N, cl_float2 alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasChbmv)(clblasOrder order, clblasUplo uplo, size_t N, size_t K, cl_float2 alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem X, size_t offx, int incx, cl_float2 beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasChemm)(clblasOrder order, clblasSide side, clblasUplo uplo, size_t M, size_t N, cl_float2 alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem B, size_t offb, size_t ldb, cl_float2 beta, cl_mem C, size_t offc, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasChemv)(clblasOrder order, clblasUplo uplo, size_t N, FloatComplex alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem X, size_t offx, int incx, FloatComplex beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCher)(clblasOrder order, clblasUplo uplo, size_t N, cl_float alpha, const cl_mem X, size_t offx, int incx, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCher2)(clblasOrder order, clblasUplo uplo, size_t N, cl_float2 alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCher2k)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, size_t N, size_t K, FloatComplex alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem B, size_t offb, size_t ldb, cl_float beta, cl_mem C, size_t offc, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCherk)(clblasOrder order, clblasUplo uplo, clblasTranspose transA, size_t N, size_t K, float alpha, const cl_mem A, size_t offa, size_t lda, float beta, cl_mem C, size_t offc, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasChpmv)(clblasOrder order, clblasUplo uplo, size_t N, cl_float2 alpha, const cl_mem AP, size_t offa, const cl_mem X, size_t offx, int incx, cl_float2 beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasChpr)(clblasOrder order, clblasUplo uplo, size_t N, cl_float alpha, const cl_mem X, size_t offx, int incx, cl_mem AP, size_t offa, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasChpr2)(clblasOrder order, clblasUplo uplo, size_t N, cl_float2 alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem AP, size_t offa, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCrotg)(cl_mem CA, size_t offCA, cl_mem CB, size_t offCB, cl_mem C, size_t offC, cl_mem S, size_t offS, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCscal)(size_t N, cl_float2 alpha, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCsrot)(size_t N, cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_float C, cl_float S, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCsscal)(size_t N, cl_float alpha, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCswap)(size_t N, cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCsymm)(clblasOrder order, clblasSide side, clblasUplo uplo, size_t M, size_t N, cl_float2 alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem B, size_t offb, size_t ldb, cl_float2 beta, cl_mem C, size_t offc, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCsyr2k)(clblasOrder order, clblasUplo uplo, clblasTranspose transAB, size_t N, size_t K, FloatComplex alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem B, size_t offB, size_t ldb, FloatComplex beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCsyrk)(clblasOrder order, clblasUplo uplo, clblasTranspose transA, size_t N, size_t K, FloatComplex alpha, const cl_mem A, size_t offA, size_t lda, FloatComplex beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCtbmv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, size_t K, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCtbsv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, size_t K, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCtpmv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, const cl_mem AP, size_t offa, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCtpsv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, const cl_mem A, size_t offa, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCtrmm)(clblasOrder order, clblasSide side, clblasUplo uplo, clblasTranspose transA, clblasDiag diag, size_t M, size_t N, FloatComplex alpha, const cl_mem A, size_t offA, size_t lda, cl_mem B, size_t offB, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCtrmv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCtrsm)(clblasOrder order, clblasSide side, clblasUplo uplo, clblasTranspose transA, clblasDiag diag, size_t M, size_t N, FloatComplex alpha, const cl_mem A, size_t offA, size_t lda, cl_mem B, size_t offB, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasCtrsv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDasum)(size_t N, cl_mem asum, size_t offAsum, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDaxpy)(size_t N, cl_double alpha, const cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDcopy)(size_t N, const cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDdot)(size_t N, cl_mem dotProduct, size_t offDP, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDgbmv)(clblasOrder order, clblasTranspose trans, size_t M, size_t N, size_t KL, size_t KU, cl_double alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem X, size_t offx, int incx, cl_double beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +extern CL_RUNTIME_EXPORT clblasStatus (*clblasDgemm)(clblasOrder order, clblasTranspose transA, clblasTranspose transB, size_t M, size_t N, size_t K, cl_double alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem B, size_t offB, size_t ldb, cl_double beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDgemv)(clblasOrder order, clblasTranspose transA, size_t M, size_t N, cl_double alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem x, size_t offx, int incx, cl_double beta, cl_mem y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDger)(clblasOrder order, size_t M, size_t N, cl_double alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDnrm2)(size_t N, cl_mem NRM2, size_t offNRM2, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDrot)(size_t N, cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_double C, cl_double S, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDrotg)(cl_mem DA, size_t offDA, cl_mem DB, size_t offDB, cl_mem C, size_t offC, cl_mem S, size_t offS, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDrotm)(size_t N, cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, const cl_mem DPARAM, size_t offDparam, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDrotmg)(cl_mem DD1, size_t offDD1, cl_mem DD2, size_t offDD2, cl_mem DX1, size_t offDX1, const cl_mem DY1, size_t offDY1, cl_mem DPARAM, size_t offDparam, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDsbmv)(clblasOrder order, clblasUplo uplo, size_t N, size_t K, cl_double alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem X, size_t offx, int incx, cl_double beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDscal)(size_t N, cl_double alpha, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDspmv)(clblasOrder order, clblasUplo uplo, size_t N, cl_double alpha, const cl_mem AP, size_t offa, const cl_mem X, size_t offx, int incx, cl_double beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDspr)(clblasOrder order, clblasUplo uplo, size_t N, cl_double alpha, const cl_mem X, size_t offx, int incx, cl_mem AP, size_t offa, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDspr2)(clblasOrder order, clblasUplo uplo, size_t N, cl_double alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem AP, size_t offa, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDswap)(size_t N, cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDsymm)(clblasOrder order, clblasSide side, clblasUplo uplo, size_t M, size_t N, cl_double alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem B, size_t offb, size_t ldb, cl_double beta, cl_mem C, size_t offc, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDsymv)(clblasOrder order, clblasUplo uplo, size_t N, cl_double alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem x, size_t offx, int incx, cl_double beta, cl_mem y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDsyr)(clblasOrder order, clblasUplo uplo, size_t N, cl_double alpha, const cl_mem X, size_t offx, int incx, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDsyr2)(clblasOrder order, clblasUplo uplo, size_t N, cl_double alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDsyr2k)(clblasOrder order, clblasUplo uplo, clblasTranspose transAB, size_t N, size_t K, cl_double alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem B, size_t offB, size_t ldb, cl_double beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDsyrk)(clblasOrder order, clblasUplo uplo, clblasTranspose transA, size_t N, size_t K, cl_double alpha, const cl_mem A, size_t offA, size_t lda, cl_double beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDtbmv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, size_t K, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDtbsv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, size_t K, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDtpmv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, const cl_mem AP, size_t offa, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDtpsv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, const cl_mem A, size_t offa, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDtrmm)(clblasOrder order, clblasSide side, clblasUplo uplo, clblasTranspose transA, clblasDiag diag, size_t M, size_t N, cl_double alpha, const cl_mem A, size_t offA, size_t lda, cl_mem B, size_t offB, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDtrmv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDtrsm)(clblasOrder order, clblasSide side, clblasUplo uplo, clblasTranspose transA, clblasDiag diag, size_t M, size_t N, cl_double alpha, const cl_mem A, size_t offA, size_t lda, cl_mem B, size_t offB, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDtrsv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDzasum)(size_t N, cl_mem asum, size_t offAsum, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasDznrm2)(size_t N, cl_mem NRM2, size_t offNRM2, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasGetVersion)(cl_uint* major, cl_uint* minor, cl_uint* patch); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSasum)(size_t N, cl_mem asum, size_t offAsum, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSaxpy)(size_t N, cl_float alpha, const cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasScasum)(size_t N, cl_mem asum, size_t offAsum, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasScnrm2)(size_t N, cl_mem NRM2, size_t offNRM2, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasScopy)(size_t N, const cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSdot)(size_t N, cl_mem dotProduct, size_t offDP, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +extern CL_RUNTIME_EXPORT clblasStatus (*clblasSetup)(); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSgbmv)(clblasOrder order, clblasTranspose trans, size_t M, size_t N, size_t KL, size_t KU, cl_float alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem X, size_t offx, int incx, cl_float beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +extern CL_RUNTIME_EXPORT clblasStatus (*clblasSgemm)(clblasOrder order, clblasTranspose transA, clblasTranspose transB, size_t M, size_t N, size_t K, cl_float alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem B, size_t offB, size_t ldb, cl_float beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSgemv)(clblasOrder order, clblasTranspose transA, size_t M, size_t N, cl_float alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem x, size_t offx, int incx, cl_float beta, cl_mem y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSger)(clblasOrder order, size_t M, size_t N, cl_float alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSnrm2)(size_t N, cl_mem NRM2, size_t offNRM2, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSrot)(size_t N, cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_float C, cl_float S, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSrotg)(cl_mem SA, size_t offSA, cl_mem SB, size_t offSB, cl_mem C, size_t offC, cl_mem S, size_t offS, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSrotm)(size_t N, cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, const cl_mem SPARAM, size_t offSparam, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSrotmg)(cl_mem SD1, size_t offSD1, cl_mem SD2, size_t offSD2, cl_mem SX1, size_t offSX1, const cl_mem SY1, size_t offSY1, cl_mem SPARAM, size_t offSparam, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSsbmv)(clblasOrder order, clblasUplo uplo, size_t N, size_t K, cl_float alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem X, size_t offx, int incx, cl_float beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSscal)(size_t N, cl_float alpha, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSspmv)(clblasOrder order, clblasUplo uplo, size_t N, cl_float alpha, const cl_mem AP, size_t offa, const cl_mem X, size_t offx, int incx, cl_float beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSspr)(clblasOrder order, clblasUplo uplo, size_t N, cl_float alpha, const cl_mem X, size_t offx, int incx, cl_mem AP, size_t offa, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSspr2)(clblasOrder order, clblasUplo uplo, size_t N, cl_float alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem AP, size_t offa, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSswap)(size_t N, cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSsymm)(clblasOrder order, clblasSide side, clblasUplo uplo, size_t M, size_t N, cl_float alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem B, size_t offb, size_t ldb, cl_float beta, cl_mem C, size_t offc, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSsymv)(clblasOrder order, clblasUplo uplo, size_t N, cl_float alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem x, size_t offx, int incx, cl_float beta, cl_mem y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSsyr)(clblasOrder order, clblasUplo uplo, size_t N, cl_float alpha, const cl_mem X, size_t offx, int incx, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSsyr2)(clblasOrder order, clblasUplo uplo, size_t N, cl_float alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSsyr2k)(clblasOrder order, clblasUplo uplo, clblasTranspose transAB, size_t N, size_t K, cl_float alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem B, size_t offB, size_t ldb, cl_float beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasSsyrk)(clblasOrder order, clblasUplo uplo, clblasTranspose transA, size_t N, size_t K, cl_float alpha, const cl_mem A, size_t offA, size_t lda, cl_float beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasStbmv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, size_t K, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasStbsv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, size_t K, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasStpmv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, const cl_mem AP, size_t offa, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasStpsv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, const cl_mem A, size_t offa, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasStrmm)(clblasOrder order, clblasSide side, clblasUplo uplo, clblasTranspose transA, clblasDiag diag, size_t M, size_t N, cl_float alpha, const cl_mem A, size_t offA, size_t lda, cl_mem B, size_t offB, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasStrmv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasStrsm)(clblasOrder order, clblasSide side, clblasUplo uplo, clblasTranspose transA, clblasDiag diag, size_t M, size_t N, cl_float alpha, const cl_mem A, size_t offA, size_t lda, cl_mem B, size_t offB, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasStrsv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +extern CL_RUNTIME_EXPORT void (*clblasTeardown)(); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZaxpy)(size_t N, cl_double2 alpha, const cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZcopy)(size_t N, const cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZdotc)(size_t N, cl_mem dotProduct, size_t offDP, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZdotu)(size_t N, cl_mem dotProduct, size_t offDP, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZdrot)(size_t N, cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_double C, cl_double S, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZdscal)(size_t N, cl_double alpha, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZgbmv)(clblasOrder order, clblasTranspose trans, size_t M, size_t N, size_t KL, size_t KU, cl_double2 alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem X, size_t offx, int incx, cl_double2 beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +extern CL_RUNTIME_EXPORT clblasStatus (*clblasZgemm)(clblasOrder order, clblasTranspose transA, clblasTranspose transB, size_t M, size_t N, size_t K, DoubleComplex alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem B, size_t offB, size_t ldb, DoubleComplex beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZgemv)(clblasOrder order, clblasTranspose transA, size_t M, size_t N, DoubleComplex alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem x, size_t offx, int incx, DoubleComplex beta, cl_mem y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZgerc)(clblasOrder order, size_t M, size_t N, cl_double2 alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZgeru)(clblasOrder order, size_t M, size_t N, cl_double2 alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZhbmv)(clblasOrder order, clblasUplo uplo, size_t N, size_t K, cl_double2 alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem X, size_t offx, int incx, cl_double2 beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZhemm)(clblasOrder order, clblasSide side, clblasUplo uplo, size_t M, size_t N, cl_double2 alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem B, size_t offb, size_t ldb, cl_double2 beta, cl_mem C, size_t offc, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZhemv)(clblasOrder order, clblasUplo uplo, size_t N, DoubleComplex alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem X, size_t offx, int incx, DoubleComplex beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZher)(clblasOrder order, clblasUplo uplo, size_t N, cl_double alpha, const cl_mem X, size_t offx, int incx, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZher2)(clblasOrder order, clblasUplo uplo, size_t N, cl_double2 alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem A, size_t offa, size_t lda, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZher2k)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, size_t N, size_t K, DoubleComplex alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem B, size_t offb, size_t ldb, cl_double beta, cl_mem C, size_t offc, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZherk)(clblasOrder order, clblasUplo uplo, clblasTranspose transA, size_t N, size_t K, double alpha, const cl_mem A, size_t offa, size_t lda, double beta, cl_mem C, size_t offc, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZhpmv)(clblasOrder order, clblasUplo uplo, size_t N, cl_double2 alpha, const cl_mem AP, size_t offa, const cl_mem X, size_t offx, int incx, cl_double2 beta, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZhpr)(clblasOrder order, clblasUplo uplo, size_t N, cl_double alpha, const cl_mem X, size_t offx, int incx, cl_mem AP, size_t offa, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZhpr2)(clblasOrder order, clblasUplo uplo, size_t N, cl_double2 alpha, const cl_mem X, size_t offx, int incx, const cl_mem Y, size_t offy, int incy, cl_mem AP, size_t offa, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZrotg)(cl_mem CA, size_t offCA, cl_mem CB, size_t offCB, cl_mem C, size_t offC, cl_mem S, size_t offS, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZscal)(size_t N, cl_double2 alpha, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZswap)(size_t N, cl_mem X, size_t offx, int incx, cl_mem Y, size_t offy, int incy, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZsymm)(clblasOrder order, clblasSide side, clblasUplo uplo, size_t M, size_t N, cl_double2 alpha, const cl_mem A, size_t offa, size_t lda, const cl_mem B, size_t offb, size_t ldb, cl_double2 beta, cl_mem C, size_t offc, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZsyr2k)(clblasOrder order, clblasUplo uplo, clblasTranspose transAB, size_t N, size_t K, DoubleComplex alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem B, size_t offB, size_t ldb, DoubleComplex beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZsyrk)(clblasOrder order, clblasUplo uplo, clblasTranspose transA, size_t N, size_t K, DoubleComplex alpha, const cl_mem A, size_t offA, size_t lda, DoubleComplex beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZtbmv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, size_t K, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZtbsv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, size_t K, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZtpmv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, const cl_mem AP, size_t offa, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZtpsv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, const cl_mem A, size_t offa, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZtrmm)(clblasOrder order, clblasSide side, clblasUplo uplo, clblasTranspose transA, clblasDiag diag, size_t M, size_t N, DoubleComplex alpha, const cl_mem A, size_t offA, size_t lda, cl_mem B, size_t offB, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZtrmv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZtrsm)(clblasOrder order, clblasSide side, clblasUplo uplo, clblasTranspose transA, clblasDiag diag, size_t M, size_t N, DoubleComplex alpha, const cl_mem A, size_t offA, size_t lda, cl_mem B, size_t offB, size_t ldb, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasZtrsv)(clblasOrder order, clblasUplo uplo, clblasTranspose trans, clblasDiag diag, size_t N, const cl_mem A, size_t offa, size_t lda, cl_mem X, size_t offx, int incx, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasiCamax)(size_t N, cl_mem iMax, size_t offiMax, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasiDamax)(size_t N, cl_mem iMax, size_t offiMax, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasiSamax)(size_t N, cl_mem iMax, size_t offiMax, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); +//extern CL_RUNTIME_EXPORT clblasStatus (*clblasiZamax)(size_t N, cl_mem iMax, size_t offiMax, const cl_mem X, size_t offx, int incx, cl_mem scratchBuff, cl_uint numCommandQueues, cl_command_queue* commandQueues, cl_uint numEventsInWaitList, const cl_event* eventWaitList, cl_event* events); diff --git a/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clfft.hpp b/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clfft.hpp new file mode 100644 index 0000000000..dff3b406a6 --- /dev/null +++ b/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clfft.hpp @@ -0,0 +1,146 @@ +// +// AUTOGENERATED, DO NOT EDIT +// +#ifndef OPENCV_CORE_OCL_RUNTIME_CLAMDFFT_HPP +#error "Invalid usage" +#endif + +// generated by parser_clfft.py +#define clfftBakePlan clfftBakePlan_ +#define clfftCopyPlan clfftCopyPlan_ +#define clfftCreateDefaultPlan clfftCreateDefaultPlan_ +#define clfftDestroyPlan clfftDestroyPlan_ +#define clfftEnqueueTransform clfftEnqueueTransform_ +#define clfftGetLayout clfftGetLayout_ +#define clfftGetPlanBatchSize clfftGetPlanBatchSize_ +#define clfftGetPlanContext clfftGetPlanContext_ +#define clfftGetPlanDim clfftGetPlanDim_ +#define clfftGetPlanDistance clfftGetPlanDistance_ +#define clfftGetPlanInStride clfftGetPlanInStride_ +#define clfftGetPlanLength clfftGetPlanLength_ +#define clfftGetPlanOutStride clfftGetPlanOutStride_ +#define clfftGetPlanPrecision clfftGetPlanPrecision_ +#define clfftGetPlanScale clfftGetPlanScale_ +#define clfftGetPlanTransposeResult clfftGetPlanTransposeResult_ +#define clfftGetResultLocation clfftGetResultLocation_ +#define clfftGetTmpBufSize clfftGetTmpBufSize_ +#define clfftGetVersion clfftGetVersion_ +#define clfftSetLayout clfftSetLayout_ +#define clfftSetPlanBatchSize clfftSetPlanBatchSize_ +#define clfftSetPlanCallback clfftSetPlanCallback_ +#define clfftSetPlanDim clfftSetPlanDim_ +#define clfftSetPlanDistance clfftSetPlanDistance_ +#define clfftSetPlanInStride clfftSetPlanInStride_ +#define clfftSetPlanLength clfftSetPlanLength_ +#define clfftSetPlanOutStride clfftSetPlanOutStride_ +#define clfftSetPlanPrecision clfftSetPlanPrecision_ +#define clfftSetPlanScale clfftSetPlanScale_ +#define clfftSetPlanTransposeResult clfftSetPlanTransposeResult_ +#define clfftSetResultLocation clfftSetResultLocation_ +#define clfftSetup clfftSetup_ +#define clfftTeardown clfftTeardown_ + +#include + +// generated by parser_clfft.py +#undef clfftBakePlan +#define clfftBakePlan clfftBakePlan_pfn +#undef clfftCopyPlan +//#define clfftCopyPlan clfftCopyPlan_pfn +#undef clfftCreateDefaultPlan +#define clfftCreateDefaultPlan clfftCreateDefaultPlan_pfn +#undef clfftDestroyPlan +#define clfftDestroyPlan clfftDestroyPlan_pfn +#undef clfftEnqueueTransform +#define clfftEnqueueTransform clfftEnqueueTransform_pfn +#undef clfftGetLayout +//#define clfftGetLayout clfftGetLayout_pfn +#undef clfftGetPlanBatchSize +//#define clfftGetPlanBatchSize clfftGetPlanBatchSize_pfn +#undef clfftGetPlanContext +//#define clfftGetPlanContext clfftGetPlanContext_pfn +#undef clfftGetPlanDim +//#define clfftGetPlanDim clfftGetPlanDim_pfn +#undef clfftGetPlanDistance +//#define clfftGetPlanDistance clfftGetPlanDistance_pfn +#undef clfftGetPlanInStride +//#define clfftGetPlanInStride clfftGetPlanInStride_pfn +#undef clfftGetPlanLength +//#define clfftGetPlanLength clfftGetPlanLength_pfn +#undef clfftGetPlanOutStride +//#define clfftGetPlanOutStride clfftGetPlanOutStride_pfn +#undef clfftGetPlanPrecision +//#define clfftGetPlanPrecision clfftGetPlanPrecision_pfn +#undef clfftGetPlanScale +//#define clfftGetPlanScale clfftGetPlanScale_pfn +#undef clfftGetPlanTransposeResult +//#define clfftGetPlanTransposeResult clfftGetPlanTransposeResult_pfn +#undef clfftGetResultLocation +//#define clfftGetResultLocation clfftGetResultLocation_pfn +#undef clfftGetTmpBufSize +#define clfftGetTmpBufSize clfftGetTmpBufSize_pfn +#undef clfftGetVersion +#define clfftGetVersion clfftGetVersion_pfn +#undef clfftSetLayout +#define clfftSetLayout clfftSetLayout_pfn +#undef clfftSetPlanBatchSize +#define clfftSetPlanBatchSize clfftSetPlanBatchSize_pfn +#undef clfftSetPlanCallback +//#define clfftSetPlanCallback clfftSetPlanCallback_pfn +#undef clfftSetPlanDim +//#define clfftSetPlanDim clfftSetPlanDim_pfn +#undef clfftSetPlanDistance +#define clfftSetPlanDistance clfftSetPlanDistance_pfn +#undef clfftSetPlanInStride +#define clfftSetPlanInStride clfftSetPlanInStride_pfn +#undef clfftSetPlanLength +//#define clfftSetPlanLength clfftSetPlanLength_pfn +#undef clfftSetPlanOutStride +#define clfftSetPlanOutStride clfftSetPlanOutStride_pfn +#undef clfftSetPlanPrecision +#define clfftSetPlanPrecision clfftSetPlanPrecision_pfn +#undef clfftSetPlanScale +#define clfftSetPlanScale clfftSetPlanScale_pfn +#undef clfftSetPlanTransposeResult +//#define clfftSetPlanTransposeResult clfftSetPlanTransposeResult_pfn +#undef clfftSetResultLocation +#define clfftSetResultLocation clfftSetResultLocation_pfn +#undef clfftSetup +#define clfftSetup clfftSetup_pfn +#undef clfftTeardown +#define clfftTeardown clfftTeardown_pfn + +// generated by parser_clfft.py +extern CL_RUNTIME_EXPORT clfftStatus (*clfftBakePlan)(clfftPlanHandle plHandle, cl_uint numQueues, cl_command_queue* commQueueFFT, void (CL_CALLBACK* pfn_notify) (clfftPlanHandle plHandle, void* user_data), void* user_data); +//extern CL_RUNTIME_EXPORT clfftStatus (*clfftCopyPlan)(clfftPlanHandle* out_plHandle, cl_context new_context, clfftPlanHandle in_plHandle); +extern CL_RUNTIME_EXPORT clfftStatus (*clfftCreateDefaultPlan)(clfftPlanHandle* plHandle, cl_context context, const clfftDim dim, const size_t* clLengths); +extern CL_RUNTIME_EXPORT clfftStatus (*clfftDestroyPlan)(clfftPlanHandle* plHandle); +extern CL_RUNTIME_EXPORT clfftStatus (*clfftEnqueueTransform)(clfftPlanHandle plHandle, clfftDirection dir, cl_uint numQueuesAndEvents, cl_command_queue* commQueues, cl_uint numWaitEvents, const cl_event* waitEvents, cl_event* outEvents, cl_mem* inputBuffers, cl_mem* outputBuffers, cl_mem tmpBuffer); +//extern CL_RUNTIME_EXPORT clfftStatus (*clfftGetLayout)(const clfftPlanHandle plHandle, clfftLayout* iLayout, clfftLayout* oLayout); +//extern CL_RUNTIME_EXPORT clfftStatus (*clfftGetPlanBatchSize)(const clfftPlanHandle plHandle, size_t* batchSize); +//extern CL_RUNTIME_EXPORT clfftStatus (*clfftGetPlanContext)(const clfftPlanHandle plHandle, cl_context* context); +//extern CL_RUNTIME_EXPORT clfftStatus (*clfftGetPlanDim)(const clfftPlanHandle plHandle, clfftDim* dim, cl_uint* size); +//extern CL_RUNTIME_EXPORT clfftStatus (*clfftGetPlanDistance)(const clfftPlanHandle plHandle, size_t* iDist, size_t* oDist); +//extern CL_RUNTIME_EXPORT clfftStatus (*clfftGetPlanInStride)(const clfftPlanHandle plHandle, const clfftDim dim, size_t* clStrides); +//extern CL_RUNTIME_EXPORT clfftStatus (*clfftGetPlanLength)(const clfftPlanHandle plHandle, const clfftDim dim, size_t* clLengths); +//extern CL_RUNTIME_EXPORT clfftStatus (*clfftGetPlanOutStride)(const clfftPlanHandle plHandle, const clfftDim dim, size_t* clStrides); +//extern CL_RUNTIME_EXPORT clfftStatus (*clfftGetPlanPrecision)(const clfftPlanHandle plHandle, clfftPrecision* precision); +//extern CL_RUNTIME_EXPORT clfftStatus (*clfftGetPlanScale)(const clfftPlanHandle plHandle, clfftDirection dir, cl_float* scale); +//extern CL_RUNTIME_EXPORT clfftStatus (*clfftGetPlanTransposeResult)(const clfftPlanHandle plHandle, clfftResultTransposed* transposed); +//extern CL_RUNTIME_EXPORT clfftStatus (*clfftGetResultLocation)(const clfftPlanHandle plHandle, clfftResultLocation* placeness); +extern CL_RUNTIME_EXPORT clfftStatus (*clfftGetTmpBufSize)(const clfftPlanHandle plHandle, size_t* buffersize); +extern CL_RUNTIME_EXPORT clfftStatus (*clfftGetVersion)(cl_uint* major, cl_uint* minor, cl_uint* patch); +extern CL_RUNTIME_EXPORT clfftStatus (*clfftSetLayout)(clfftPlanHandle plHandle, clfftLayout iLayout, clfftLayout oLayout); +extern CL_RUNTIME_EXPORT clfftStatus (*clfftSetPlanBatchSize)(clfftPlanHandle plHandle, size_t batchSize); +//extern CL_RUNTIME_EXPORT clfftStatus (*clfftSetPlanCallback)(clfftPlanHandle plHandle, const char* funcName, const char* funcString, int localMemSize, clfftCallbackType callbackType, cl_mem* userdata, int numUserdataBuffers); +//extern CL_RUNTIME_EXPORT clfftStatus (*clfftSetPlanDim)(clfftPlanHandle plHandle, const clfftDim dim); +extern CL_RUNTIME_EXPORT clfftStatus (*clfftSetPlanDistance)(clfftPlanHandle plHandle, size_t iDist, size_t oDist); +extern CL_RUNTIME_EXPORT clfftStatus (*clfftSetPlanInStride)(clfftPlanHandle plHandle, const clfftDim dim, size_t* clStrides); +//extern CL_RUNTIME_EXPORT clfftStatus (*clfftSetPlanLength)(clfftPlanHandle plHandle, const clfftDim dim, const size_t* clLengths); +extern CL_RUNTIME_EXPORT clfftStatus (*clfftSetPlanOutStride)(clfftPlanHandle plHandle, const clfftDim dim, size_t* clStrides); +extern CL_RUNTIME_EXPORT clfftStatus (*clfftSetPlanPrecision)(clfftPlanHandle plHandle, clfftPrecision precision); +extern CL_RUNTIME_EXPORT clfftStatus (*clfftSetPlanScale)(clfftPlanHandle plHandle, clfftDirection dir, cl_float scale); +//extern CL_RUNTIME_EXPORT clfftStatus (*clfftSetPlanTransposeResult)(clfftPlanHandle plHandle, clfftResultTransposed transposed); +extern CL_RUNTIME_EXPORT clfftStatus (*clfftSetResultLocation)(clfftPlanHandle plHandle, clfftResultLocation placeness); +extern CL_RUNTIME_EXPORT clfftStatus (*clfftSetup)(const clfftSetupData* setupData); +extern CL_RUNTIME_EXPORT clfftStatus (*clfftTeardown)(); diff --git a/modules/core/include/opencv2/core/opencl/runtime/opencl_clamdblas.hpp b/modules/core/include/opencv2/core/opencl/runtime/opencl_clblas.hpp similarity index 98% rename from modules/core/include/opencv2/core/opencl/runtime/opencl_clamdblas.hpp rename to modules/core/include/opencv2/core/opencl/runtime/opencl_clblas.hpp index 2ad8ac0b5d..ccddf8f76c 100644 --- a/modules/core/include/opencv2/core/opencl/runtime/opencl_clamdblas.hpp +++ b/modules/core/include/opencv2/core/opencl/runtime/opencl_clblas.hpp @@ -46,7 +46,7 @@ #include "opencl_core.hpp" -#include "autogenerated/opencl_clamdblas.hpp" +#include "autogenerated/opencl_clblas.hpp" #endif // HAVE_CLAMDBLAS diff --git a/modules/core/include/opencv2/core/opencl/runtime/opencl_clamdfft.hpp b/modules/core/include/opencv2/core/opencl/runtime/opencl_clfft.hpp similarity index 98% rename from modules/core/include/opencv2/core/opencl/runtime/opencl_clamdfft.hpp rename to modules/core/include/opencv2/core/opencl/runtime/opencl_clfft.hpp index a328f722fc..7f4af5e60b 100644 --- a/modules/core/include/opencv2/core/opencl/runtime/opencl_clamdfft.hpp +++ b/modules/core/include/opencv2/core/opencl/runtime/opencl_clfft.hpp @@ -46,7 +46,7 @@ #include "opencl_core.hpp" -#include "autogenerated/opencl_clamdfft.hpp" +#include "autogenerated/opencl_clfft.hpp" #endif // HAVE_CLAMDFFT diff --git a/modules/core/include/opencv2/core/types_c.h b/modules/core/include/opencv2/core/types_c.h index 97aeab375f..32f3c8c999 100644 --- a/modules/core/include/opencv2/core/types_c.h +++ b/modules/core/include/opencv2/core/types_c.h @@ -358,7 +358,11 @@ _IplImage needed for correct deallocation */ #if defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus) - _IplImage() {} + _IplImage() + { + memset(this, 0, sizeof(*this)); // valid for POD structure + nSize = sizeof(IplImage); + } _IplImage(const cv::Mat& m) { *this = cvIplImage(m); } #endif } diff --git a/modules/core/misc/java/src/java/core+Mat.java b/modules/core/misc/java/src/java/core+Mat.java index 641d9f8ae8..5fcc727738 100644 --- a/modules/core/misc/java/src/java/core+Mat.java +++ b/modules/core/misc/java/src/java/core+Mat.java @@ -1128,6 +1128,458 @@ public class Mat { return cols(); } + // javadoc:Mat::at(clazz, row, col) + @SuppressWarnings("unchecked") + public Atable at(Class clazz, int row, int col) { + if (clazz == Byte.class || clazz == byte.class) { + return (Atable)new AtableByte(this, row, col); + } else if (clazz == Double.class || clazz == double.class) { + return (Atable)new AtableDouble(this, row, col); + } else if (clazz == Float.class || clazz == float.class) { + return (Atable)new AtableFloat(this, row, col); + } else if (clazz == Integer.class || clazz == int.class) { + return (Atable)new AtableInteger(this, row, col); + } else if (clazz == Short.class || clazz == short.class) { + return (Atable)new AtableShort(this, row, col); + } else { + throw new RuntimeException("Unsupported class type"); + } + } + + // javadoc:Mat::at(clazz, idx) + @SuppressWarnings("unchecked") + public Atable at(Class clazz, int[] idx) { + if (clazz == Byte.class || clazz == byte.class) { + return (Atable)new AtableByte(this, idx); + } else if (clazz == Double.class || clazz == double.class) { + return (Atable)new AtableDouble(this, idx); + } else if (clazz == Float.class || clazz == float.class) { + return (Atable)new AtableFloat(this, idx); + } else if (clazz == Integer.class || clazz == int.class) { + return (Atable)new AtableInteger(this, idx); + } else if (clazz == Short.class || clazz == short.class) { + return (Atable)new AtableShort(this, idx); + } else { + throw new RuntimeException("Unsupported class parameter"); + } + } + + public static class Tuple2 { + public Tuple2(T _0, T _1) { + this._0 = _0; + this._1 = _1; + } + + public T get_0() { + return _0; + } + + public T get_1() { + return _1; + } + + private final T _0; + private final T _1; + } + + public static class Tuple3 { + public Tuple3(T _0, T _1, T _2) { + this._0 = _0; + this._1 = _1; + this._2 = _2; + } + + public T get_0() { + return _0; + } + + public T get_1() { + return _1; + } + + public T get_2() { + return _2; + } + + private final T _0; + private final T _1; + private final T _2; + } + + public static class Tuple4 { + public Tuple4(T _0, T _1, T _2, T _3) { + this._0 = _0; + this._1 = _1; + this._2 = _2; + this._3 = _3; + } + + public T get_0() { + return _0; + } + + public T get_1() { + return _1; + } + + public T get_2() { + return _2; + } + + public T get_3() { + return _3; + } + + private final T _0; + private final T _1; + private final T _2; + private final T _3; + } + + public interface Atable { + T getV(); + void setV(T v); + Tuple2 getV2c(); + void setV2c(Tuple2 v); + Tuple3 getV3c(); + void setV3c(Tuple3 v); + Tuple4 getV4c(); + void setV4c(Tuple4 v); + } + + private static class AtableBase { + + protected AtableBase(Mat mat, int row, int col) { + this.mat = mat; + indices = new int[2]; + indices[0] = row; + indices[1] = col; + } + + protected AtableBase(Mat mat, int[] indices) { + this.mat = mat; + this.indices = indices; + } + + protected final Mat mat; + protected final int[] indices; + } + + private static class AtableByte extends AtableBase implements Atable { + + public AtableByte(Mat mat, int row, int col) { + super(mat, row, col); + } + + public AtableByte(Mat mat, int[] indices) { + super(mat, indices); + } + + @Override + public Byte getV() { + byte[] data = new byte[1]; + mat.get(indices, data); + return data[0]; + } + + @Override + public void setV(Byte v) { + byte[] data = new byte[] { v }; + mat.put(indices, data); + } + + @Override + public Tuple2 getV2c() { + byte[] data = new byte[2]; + mat.get(indices, data); + return new Tuple2(data[0], data[1]); + } + + @Override + public void setV2c(Tuple2 v) { + byte[] data = new byte[] { v._0, v._1 }; + mat.put(indices, data); + } + + @Override + public Tuple3 getV3c() { + byte[] data = new byte[3]; + mat.get(indices, data); + return new Tuple3(data[0], data[1], data[2]); + } + + @Override + public void setV3c(Tuple3 v) { + byte[] data = new byte[] { v._0, v._1, v._2 }; + mat.put(indices, data); + } + + @Override + public Tuple4 getV4c() { + byte[] data = new byte[4]; + mat.get(indices, data); + return new Tuple4(data[0], data[1], data[2], data[3]); + } + + @Override + public void setV4c(Tuple4 v) { + byte[] data = new byte[] { v._0, v._1, v._2, v._3 }; + mat.put(indices, data); + } + } + + private static class AtableDouble extends AtableBase implements Atable { + + public AtableDouble(Mat mat, int row, int col) { + super(mat, row, col); + } + + public AtableDouble(Mat mat, int[] indices) { + super(mat, indices); + } + + @Override + public Double getV() { + double[] data = new double[1]; + mat.get(indices, data); + return data[0]; + } + + @Override + public void setV(Double v) { + double[] data = new double[] { v }; + mat.put(indices, data); + } + + @Override + public Tuple2 getV2c() { + double[] data = new double[2]; + mat.get(indices, data); + return new Tuple2(data[0], data[1]); + } + + @Override + public void setV2c(Tuple2 v) { + double[] data = new double[] { v._0, v._1 }; + mat.put(indices, data); + } + + @Override + public Tuple3 getV3c() { + double[] data = new double[3]; + mat.get(indices, data); + return new Tuple3(data[0], data[1], data[2]); + } + + @Override + public void setV3c(Tuple3 v) { + double[] data = new double[] { v._0, v._1, v._2 }; + mat.put(indices, data); + } + + @Override + public Tuple4 getV4c() { + double[] data = new double[4]; + mat.get(indices, data); + return new Tuple4(data[0], data[1], data[2], data[3]); + } + + @Override + public void setV4c(Tuple4 v) { + double[] data = new double[] { v._0, v._1, v._2, v._3 }; + mat.put(indices, data); + } + } + + private static class AtableFloat extends AtableBase implements Atable { + + public AtableFloat(Mat mat, int row, int col) { + super(mat, row, col); + } + + public AtableFloat(Mat mat, int[] indices) { + super(mat, indices); + } + + @Override + public Float getV() { + float[] data = new float[1]; + mat.get(indices, data); + return data[0]; + } + + @Override + public void setV(Float v) { + float[] data = new float[] { v }; + mat.put(indices, data); + } + + @Override + public Tuple2 getV2c() { + float[] data = new float[2]; + mat.get(indices, data); + return new Tuple2(data[0], data[1]); + } + + @Override + public void setV2c(Tuple2 v) { + float[] data = new float[] { v._0, v._1 }; + mat.put(indices, data); + } + + @Override + public Tuple3 getV3c() { + float[] data = new float[3]; + mat.get(indices, data); + return new Tuple3(data[0], data[1], data[2]); + } + + @Override + public void setV3c(Tuple3 v) { + float[] data = new float[] { v._0, v._1, v._2 }; + mat.put(indices, data); + } + + @Override + public Tuple4 getV4c() { + float[] data = new float[4]; + mat.get(indices, data); + return new Tuple4(data[0], data[1], data[2], data[3]); + } + + @Override + public void setV4c(Tuple4 v) { + double[] data = new double[] { v._0, v._1, v._2, v._3 }; + mat.put(indices, data); + } + } + + private static class AtableInteger extends AtableBase implements Atable { + + public AtableInteger(Mat mat, int row, int col) { + super(mat, row, col); + } + + public AtableInteger(Mat mat, int[] indices) { + super(mat, indices); + } + + @Override + public Integer getV() { + int[] data = new int[1]; + mat.get(indices, data); + return data[0]; + } + + @Override + public void setV(Integer v) { + int[] data = new int[] { v }; + mat.put(indices, data); + } + + @Override + public Tuple2 getV2c() { + int[] data = new int[2]; + mat.get(indices, data); + return new Tuple2(data[0], data[1]); + } + + @Override + public void setV2c(Tuple2 v) { + int[] data = new int[] { v._0, v._1 }; + mat.put(indices, data); + } + + @Override + public Tuple3 getV3c() { + int[] data = new int[3]; + mat.get(indices, data); + return new Tuple3(data[0], data[1], data[2]); + } + + @Override + public void setV3c(Tuple3 v) { + int[] data = new int[] { v._0, v._1, v._2 }; + mat.put(indices, data); + } + + @Override + public Tuple4 getV4c() { + int[] data = new int[4]; + mat.get(indices, data); + return new Tuple4(data[0], data[1], data[2], data[3]); + } + + @Override + public void setV4c(Tuple4 v) { + int[] data = new int[] { v._0, v._1, v._2, v._3 }; + mat.put(indices, data); + } + } + + private static class AtableShort extends AtableBase implements Atable { + + public AtableShort(Mat mat, int row, int col) { + super(mat, row, col); + } + + public AtableShort(Mat mat, int[] indices) { + super(mat, indices); + } + + @Override + public Short getV() { + short[] data = new short[1]; + mat.get(indices, data); + return data[0]; + } + + @Override + public void setV(Short v) { + short[] data = new short[] { v }; + mat.put(indices, data); + } + + @Override + public Tuple2 getV2c() { + short[] data = new short[2]; + mat.get(indices, data); + return new Tuple2(data[0], data[1]); + } + + @Override + public void setV2c(Tuple2 v) { + short[] data = new short[] { v._0, v._1 }; + mat.put(indices, data); + } + + @Override + public Tuple3 getV3c() { + short[] data = new short[3]; + mat.get(indices, data); + return new Tuple3(data[0], data[1], data[2]); + } + + @Override + public void setV3c(Tuple3 v) { + short[] data = new short[] { v._0, v._1, v._2 }; + mat.put(indices, data); + } + + @Override + public Tuple4 getV4c() { + short[] data = new short[4]; + mat.get(indices, data); + return new Tuple4(data[0], data[1], data[2], data[3]); + } + + @Override + public void setV4c(Tuple4 v) { + short[] data = new short[] { v._0, v._1, v._2, v._3 }; + mat.put(indices, data); + } + } + // javadoc:Mat::getNativeObjAddr() public long getNativeObjAddr() { return nativeObj; diff --git a/modules/core/misc/java/src/java/core+MatAt.kt b/modules/core/misc/java/src/java/core+MatAt.kt new file mode 100644 index 0000000000..f48a3deaed --- /dev/null +++ b/modules/core/misc/java/src/java/core+MatAt.kt @@ -0,0 +1,99 @@ +package org.opencv.core + +import org.opencv.core.Mat.* +import java.lang.RuntimeException + +/*** + * Example use: + * + * val (b, g, r) = mat.at(50, 50).v3c + * mat.at(50, 50).val = T3(245u, 113u, 34u) + * + */ +@Suppress("UNCHECKED_CAST") +inline fun Mat.at(row: Int, col: Int) : Atable = + when (T::class) { + Byte::class, Double::class, Float::class, Int::class, Short::class -> this.at( + T::class.java, + row, + col + ) + UByte::class -> AtableUByte(this, row, col) as Atable + else -> throw RuntimeException("Unsupported class type") + } + +@Suppress("UNCHECKED_CAST") +inline fun Mat.at(idx: IntArray) : Atable = + when (T::class) { + Byte::class, Double::class, Float::class, Int::class, Short::class -> this.at( + T::class.java, + idx + ) + UByte::class -> AtableUByte(this, idx) as Atable + else -> throw RuntimeException("Unsupported class type") + } + +class AtableUByte(val mat: Mat, val indices: IntArray): Atable { + + constructor(mat: Mat, row: Int, col: Int) : this(mat, intArrayOf(row, col)) + + override fun getV(): UByte { + val data = ByteArray(1) + mat[indices, data] + return data[0].toUByte() + } + + override fun setV(v: UByte) { + val data = byteArrayOf(v.toByte()) + mat.put(indices, data) + } + + override fun getV2c(): Tuple2 { + val data = ByteArray(2) + mat[indices, data] + return Tuple2(data[0].toUByte(), data[1].toUByte()) + } + + override fun setV2c(v: Tuple2) { + val data = byteArrayOf(v._0.toByte(), v._1.toByte()) + mat.put(indices, data) + } + + override fun getV3c(): Tuple3 { + val data = ByteArray(3) + mat[indices, data] + return Tuple3(data[0].toUByte(), data[1].toUByte(), data[2].toUByte()) + } + + override fun setV3c(v: Tuple3) { + val data = byteArrayOf(v._0.toByte(), v._1.toByte(), v._2.toByte()) + mat.put(indices, data) + } + + override fun getV4c(): Tuple4 { + val data = ByteArray(4) + mat[indices, data] + return Tuple4(data[0].toUByte(), data[1].toUByte(), data[2].toUByte(), data[3].toUByte()) + } + + override fun setV4c(v: Tuple4) { + val data = byteArrayOf(v._0.toByte(), v._1.toByte(), v._2.toByte(), v._3.toByte()) + mat.put(indices, data) + } +} + +operator fun Tuple2.component1(): T = this._0 +operator fun Tuple2.component2(): T = this._1 + +operator fun Tuple3.component1(): T = this._0 +operator fun Tuple3.component2(): T = this._1 +operator fun Tuple3.component3(): T = this._2 + +operator fun Tuple4.component1(): T = this._0 +operator fun Tuple4.component2(): T = this._1 +operator fun Tuple4.component3(): T = this._2 +operator fun Tuple4.component4(): T = this._3 + +fun T2(_0: T, _1: T) : Tuple2 = Tuple2(_0, _1) +fun T3(_0: T, _1: T, _2: T) : Tuple3 = Tuple3(_0, _1, _2) +fun T4(_0: T, _1: T, _2: T, _3: T) : Tuple4 = Tuple4(_0, _1, _2, _3) diff --git a/modules/core/misc/java/test/MatTest.java b/modules/core/misc/java/test/MatTest.java index 00e7b7cb32..3075dba16b 100644 --- a/modules/core/misc/java/test/MatTest.java +++ b/modules/core/misc/java/test/MatTest.java @@ -1285,4 +1285,31 @@ public class MatTest extends OpenCVTestCase { assertEquals(5, bbuf.get(63*80 + 63)); } + public void testMatAt() { + Mat uc1 = new Mat(2, 3, CvType.CV_8S) { + { + put(0, 0, 1, 2, 3); + put(1, 0, 4, 5, 6); + } + }; + assertEquals((byte)1, uc1.at(Byte.class, 0, 0).getV().byteValue()); + assertEquals((byte)2, uc1.at(Byte.class, 0, 1).getV().byteValue()); + assertEquals((byte)3, uc1.at(Byte.class, 0, 2).getV().byteValue()); + assertEquals((byte)4, uc1.at(Byte.class, 1, 0).getV().byteValue()); + assertEquals((byte)5, uc1.at(Byte.class, 1, 1).getV().byteValue()); + assertEquals((byte)6, uc1.at(Byte.class, 1, 2).getV().byteValue()); + uc1.at(Byte.class, 0, 0).setV((byte)7); + uc1.at(Byte.class, 0, 1).setV((byte)8); + uc1.at(Byte.class, 0, 2).setV((byte)9); + uc1.at(Byte.class, 1, 0).setV((byte)10); + uc1.at(Byte.class, 1, 1).setV((byte)11); + uc1.at(Byte.class, 1, 2).setV((byte)12); + byte[] data = new byte[6]; + uc1.get(0, 0, data); + assertArrayEquals(data, new byte[] {7, 8, 9, 10, 11, 12}); + Mat.Tuple3 bgr = rgbLena.at(Byte.class, 0, 0).getV3c(); + assertEquals(bgr.get_0().byteValue(), (byte)128); + assertEquals(bgr.get_1().byteValue(), (byte)138); + assertEquals(bgr.get_2().byteValue(), (byte)225); + } } diff --git a/modules/core/misc/objc/common/MatExt.swift b/modules/core/misc/objc/common/MatExt.swift index f6b3072345..5ce3a5e6fb 100644 --- a/modules/core/misc/objc/common/MatExt.swift +++ b/modules/core/misc/objc/common/MatExt.swift @@ -33,6 +33,10 @@ func throwIncompatibleBufferSize(count: Int, channels: Int32) throws { ) } +public typealias T2 = (T, T) +public typealias T3 = (T, T, T) +public typealias T4 = (T, T, T, T) + public extension Mat { convenience init(rows:Int32, cols:Int32, type:Int32, data:[Int8]) { @@ -242,3 +246,350 @@ public extension Mat { return __get(indices as [NSNumber]) as! [Double] } } + +public protocol Atable { + static func getAt(m: Mat, indices:[Int32]) -> Self + static func putAt(m: Mat, indices:[Int32], v: Self) + static func getAt2c(m: Mat, indices:[Int32]) -> (Self, Self) + static func putAt2c(m: Mat, indices:[Int32], v: (Self, Self)) + static func getAt3c(m: Mat, indices:[Int32]) -> (Self, Self, Self) + static func putAt3c(m: Mat, indices:[Int32], v: (Self, Self, Self)) + static func getAt4c(m: Mat, indices:[Int32]) -> (Self, Self, Self, Self) + static func putAt4c(m: Mat, indices:[Int32], v: (Self, Self, Self, Self)) +} + +public class MatAt { + + init(mat: Mat, indices: [Int32]) { + self.mat = mat + self.indices = indices + } + + private let mat: Mat + private let indices: [Int32] + public var v: N { + get { + return N.getAt(m: mat, indices: indices) + } + set(value) { + N.putAt(m: mat, indices: indices, v: value) + } + } + public var v2c: (N, N) { + get { + return N.getAt2c(m: mat, indices: indices) + } + set(value) { + N.putAt2c(m: mat, indices: indices, v: value) + } + } + public var v3c: (N, N, N) { + get { + return N.getAt3c(m: mat, indices: indices) + } + set(value) { + N.putAt3c(m: mat, indices: indices, v: value) + } + } + public var v4c: (N, N, N, N) { + get { + return N.getAt4c(m: mat, indices: indices) + } + set(value) { + N.putAt4c(m: mat, indices: indices, v: value) + } + } +} + +extension UInt8: Atable { + public static func getAt(m: Mat, indices:[Int32]) -> UInt8 { + var tmp = [Int8](repeating: 0, count: 1) + try! m.get(indices: indices, data: &tmp) + return UInt8(bitPattern: tmp[0]) + } + + public static func putAt(m: Mat, indices: [Int32], v: UInt8) { + let tmp = [Int8(bitPattern: v)] + try! m.put(indices: indices, data: tmp) + } + + public static func getAt2c(m: Mat, indices:[Int32]) -> (UInt8, UInt8) { + var tmp = [Int8](repeating: 0, count: 2) + try! m.get(indices: indices, data: &tmp) + return (UInt8(bitPattern: tmp[0]), UInt8(bitPattern: tmp[1])) + } + + public static func putAt2c(m: Mat, indices: [Int32], v: (UInt8, UInt8)) { + let tmp = [Int8(bitPattern: v.0), Int8(bitPattern: v.1)] + try! m.put(indices: indices, data: tmp) + } + + public static func getAt3c(m: Mat, indices:[Int32]) -> (UInt8, UInt8, UInt8) { + var tmp = [Int8](repeating: 0, count: 3) + try! m.get(indices: indices, data: &tmp) + return (UInt8(bitPattern: tmp[0]), UInt8(bitPattern: tmp[1]), UInt8(bitPattern: tmp[2])) + } + + public static func putAt3c(m: Mat, indices: [Int32], v: (UInt8, UInt8, UInt8)) { + let tmp = [Int8(bitPattern: v.0), Int8(bitPattern: v.1), Int8(bitPattern: v.2)] + try! m.put(indices: indices, data: tmp) + } + + public static func getAt4c(m: Mat, indices:[Int32]) -> (UInt8, UInt8, UInt8, UInt8) { + var tmp = [Int8](repeating: 0, count: 4) + try! m.get(indices: indices, data: &tmp) + return (UInt8(bitPattern: tmp[0]), UInt8(bitPattern: tmp[1]), UInt8(bitPattern: tmp[2]), UInt8(bitPattern: tmp[3])) + } + + public static func putAt4c(m: Mat, indices: [Int32], v: (UInt8, UInt8, UInt8, UInt8)) { + let tmp = [Int8(bitPattern: v.0), Int8(bitPattern: v.1), Int8(bitPattern: v.2), Int8(bitPattern: v.3)] + try! m.put(indices: indices, data: tmp) + } +} + +extension Int8: Atable { + public static func getAt(m: Mat, indices:[Int32]) -> Int8 { + var tmp = [Int8](repeating: 0, count: 1) + try! m.get(indices: indices, data: &tmp) + return tmp[0] + } + + public static func putAt(m: Mat, indices: [Int32], v: Int8) { + let tmp = [v] + try! m.put(indices: indices, data: tmp) + } + + public static func getAt2c(m: Mat, indices:[Int32]) -> (Int8, Int8) { + var tmp = [Int8](repeating: 0, count: 2) + try! m.get(indices: indices, data: &tmp) + return (tmp[0], tmp[1]) + } + + public static func putAt2c(m: Mat, indices: [Int32], v: (Int8, Int8)) { + let tmp = [v.0, v.1] + try! m.put(indices: indices, data: tmp) + } + + public static func getAt3c(m: Mat, indices:[Int32]) -> (Int8, Int8, Int8) { + var tmp = [Int8](repeating: 0, count: 3) + try! m.get(indices: indices, data: &tmp) + return (tmp[0], tmp[1], tmp[2]) + } + + public static func putAt3c(m: Mat, indices: [Int32], v: (Int8, Int8, Int8)) { + let tmp = [v.0, v.1, v.2] + try! m.put(indices: indices, data: tmp) + } + + public static func getAt4c(m: Mat, indices:[Int32]) -> (Int8, Int8, Int8, Int8) { + var tmp = [Int8](repeating: 0, count: 4) + try! m.get(indices: indices, data: &tmp) + return (tmp[0], tmp[1], tmp[2], tmp[3]) + } + + public static func putAt4c(m: Mat, indices: [Int32], v: (Int8, Int8, Int8, Int8)) { + let tmp = [v.0, v.1, v.2, v.3] + try! m.put(indices: indices, data: tmp) + } +} + +extension Double: Atable { + public static func getAt(m: Mat, indices:[Int32]) -> Double { + var tmp = [Double](repeating: 0, count: 1) + try! m.get(indices: indices, data: &tmp) + return tmp[0] + } + + public static func putAt(m: Mat, indices: [Int32], v: Double) { + let tmp = [v] + try! m.put(indices: indices, data: tmp) + } + + public static func getAt2c(m: Mat, indices:[Int32]) -> (Double, Double) { + var tmp = [Double](repeating: 0, count: 2) + try! m.get(indices: indices, data: &tmp) + return (tmp[0], tmp[1]) + } + + public static func putAt2c(m: Mat, indices: [Int32], v: (Double, Double)) { + let tmp = [v.0, v.1] + try! m.put(indices: indices, data: tmp) + } + + public static func getAt3c(m: Mat, indices:[Int32]) -> (Double, Double, Double) { + var tmp = [Double](repeating: 0, count: 3) + try! m.get(indices: indices, data: &tmp) + return (tmp[0], tmp[1], tmp[2]) + } + + public static func putAt3c(m: Mat, indices: [Int32], v: (Double, Double, Double)) { + let tmp = [v.0, v.1, v.2] + try! m.put(indices: indices, data: tmp) + } + + public static func getAt4c(m: Mat, indices:[Int32]) -> (Double, Double, Double, Double) { + var tmp = [Double](repeating: 0, count: 4) + try! m.get(indices: indices, data: &tmp) + return (tmp[0], tmp[1], tmp[2], tmp[3]) + } + + public static func putAt4c(m: Mat, indices: [Int32], v: (Double, Double, Double, Double)) { + let tmp = [v.0, v.1, v.2, v.3] + try! m.put(indices: indices, data: tmp) + } +} + +extension Float: Atable { + public static func getAt(m: Mat, indices:[Int32]) -> Float { + var tmp = [Float](repeating: 0, count: 1) + try! m.get(indices: indices, data: &tmp) + return tmp[0] + } + + public static func putAt(m: Mat, indices: [Int32], v: Float) { + let tmp = [v] + try! m.put(indices: indices, data: tmp) + } + + public static func getAt2c(m: Mat, indices:[Int32]) -> (Float, Float) { + var tmp = [Float](repeating: 0, count: 2) + try! m.get(indices: indices, data: &tmp) + return (tmp[0], tmp[1]) + } + + public static func putAt2c(m: Mat, indices: [Int32], v: (Float, Float)) { + let tmp = [v.0, v.1] + try! m.put(indices: indices, data: tmp) + } + + public static func getAt3c(m: Mat, indices:[Int32]) -> (Float, Float, Float) { + var tmp = [Float](repeating: 0, count: 3) + try! m.get(indices: indices, data: &tmp) + return (tmp[0], tmp[1], tmp[2]) + } + + public static func putAt3c(m: Mat, indices: [Int32], v: (Float, Float, Float)) { + let tmp = [v.0, v.1, v.2] + try! m.put(indices: indices, data: tmp) + } + + public static func getAt4c(m: Mat, indices:[Int32]) -> (Float, Float, Float, Float) { + var tmp = [Float](repeating: 0, count: 4) + try! m.get(indices: indices, data: &tmp) + return (tmp[0], tmp[1], tmp[2], tmp[3]) + } + + public static func putAt4c(m: Mat, indices: [Int32], v: (Float, Float, Float, Float)) { + let tmp = [v.0, v.1, v.2, v.3] + try! m.put(indices: indices, data: tmp) + } +} + +extension Int32: Atable { + public static func getAt(m: Mat, indices:[Int32]) -> Int32 { + var tmp = [Int32](repeating: 0, count: 1) + try! m.get(indices: indices, data: &tmp) + return tmp[0] + } + + public static func putAt(m: Mat, indices: [Int32], v: Int32) { + let tmp = [v] + try! m.put(indices: indices, data: tmp) + } + + public static func getAt2c(m: Mat, indices:[Int32]) -> (Int32, Int32) { + var tmp = [Int32](repeating: 0, count: 2) + try! m.get(indices: indices, data: &tmp) + return (tmp[0], tmp[1]) + } + + public static func putAt2c(m: Mat, indices: [Int32], v: (Int32, Int32)) { + let tmp = [v.0, v.1] + try! m.put(indices: indices, data: tmp) + } + + public static func getAt3c(m: Mat, indices:[Int32]) -> (Int32, Int32, Int32) { + var tmp = [Int32](repeating: 0, count: 3) + try! m.get(indices: indices, data: &tmp) + return (tmp[0], tmp[1], tmp[2]) + } + + public static func putAt3c(m: Mat, indices: [Int32], v: (Int32, Int32, Int32)) { + let tmp = [v.0, v.1, v.2] + try! m.put(indices: indices, data: tmp) + } + + public static func getAt4c(m: Mat, indices:[Int32]) -> (Int32, Int32, Int32, Int32) { + var tmp = [Int32](repeating: 0, count: 4) + try! m.get(indices: indices, data: &tmp) + return (tmp[0], tmp[1], tmp[2], tmp[3]) + } + + public static func putAt4c(m: Mat, indices: [Int32], v: (Int32, Int32, Int32, Int32)) { + let tmp = [v.0, v.1, v.2, v.3] + try! m.put(indices: indices, data: tmp) + } +} + +extension Int16: Atable { + public static func getAt(m: Mat, indices:[Int32]) -> Int16 { + var tmp = [Int16](repeating: 0, count: 1) + try! m.get(indices: indices, data: &tmp) + return tmp[0] + } + + public static func putAt(m: Mat, indices: [Int32], v: Int16) { + let tmp = [v] + try! m.put(indices: indices, data: tmp) + } + + public static func getAt2c(m: Mat, indices:[Int32]) -> (Int16, Int16) { + var tmp = [Int16](repeating: 0, count: 2) + try! m.get(indices: indices, data: &tmp) + return (tmp[0], tmp[1]) + } + + public static func putAt2c(m: Mat, indices: [Int32], v: (Int16, Int16)) { + let tmp = [v.0, v.1] + try! m.put(indices: indices, data: tmp) + } + + public static func getAt3c(m: Mat, indices:[Int32]) -> (Int16, Int16, Int16) { + var tmp = [Int16](repeating: 0, count: 3) + try! m.get(indices: indices, data: &tmp) + return (tmp[0], tmp[1], tmp[2]) + } + + public static func putAt3c(m: Mat, indices: [Int32], v: (Int16, Int16, Int16)) { + let tmp = [v.0, v.1, v.2] + try! m.put(indices: indices, data: tmp) + } + + public static func getAt4c(m: Mat, indices:[Int32]) -> (Int16, Int16, Int16, Int16) { + var tmp = [Int16](repeating: 0, count: 4) + try! m.get(indices: indices, data: &tmp) + return (tmp[0], tmp[1], tmp[2], tmp[3]) + } + + public static func putAt4c(m: Mat, indices: [Int32], v: (Int16, Int16, Int16, Int16)) { + let tmp = [v.0, v.1, v.2, v.3] + try! m.put(indices: indices, data: tmp) + } +} + +/*** + * Example use: + * + * let elemantVal: UInt8 = mat.at(row: 50, col: 50).v + * mat.at(row: 50, col: 50).v = 245 + * + */ +public extension Mat { + func at(row: Int32, col: Int32) -> MatAt { + return MatAt(mat: self, indices: [row, col]) + } + + func at(indices:[Int32]) -> MatAt { + return MatAt(mat: self, indices: indices) + } +} diff --git a/modules/core/misc/objc/test/MatTest.swift b/modules/core/misc/objc/test/MatTest.swift index af26eb0bdb..14c440b5eb 100644 --- a/modules/core/misc/objc/test/MatTest.swift +++ b/modules/core/misc/objc/test/MatTest.swift @@ -1143,4 +1143,28 @@ class MatTests: OpenCVTestCase { XCTAssertEqual(5, bufferOut[63*80 + 63]) } + func testMatAt() { + let uc1 = Mat(rows: 2, cols: 3, type: CvType.CV_8U) + try! uc1.put(row: 0, col: 0, data: [1, 2, 3, 4, 5, 6] as [Int8]) + XCTAssertEqual(UInt8(1), uc1.at(row: 0, col: 0).v) + XCTAssertEqual(UInt8(2), uc1.at(row: 0, col: 1).v) + XCTAssertEqual(UInt8(3), uc1.at(row: 0, col: 2).v) + XCTAssertEqual(UInt8(4), uc1.at(row: 1, col: 0).v) + XCTAssertEqual(UInt8(5), uc1.at(row: 1, col: 1).v) + XCTAssertEqual(UInt8(6), uc1.at(row: 1, col: 2).v) + uc1.at(row: 0, col: 0).v = UInt8(7) + uc1.at(row: 0, col: 1).v = UInt8(8) + uc1.at(row: 0, col: 2).v = UInt8(9) + uc1.at(row: 1, col: 0).v = UInt8(10) + uc1.at(row: 1, col: 1).v = UInt8(11) + uc1.at(row: 1, col: 2).v = UInt8(12) + var data = [Int8](repeating: 0, count: 6) + try! uc1.get(row: 0, col: 0, data: &data) + XCTAssertEqual(data, [7, 8, 9, 10, 11, 12] as [Int8]) + let (b, g, r): T3 = rgbLena.at(row: 0, col: 0).v3c + XCTAssertEqual(b, UInt8(128)) + XCTAssertEqual(g, UInt8(138)) + XCTAssertEqual(r, UInt8(225)) + } + } diff --git a/modules/core/perf/opencl/perf_usage_flags.cpp b/modules/core/perf/opencl/perf_usage_flags.cpp index d59087121f..0717121d1c 100644 --- a/modules/core/perf/opencl/perf_usage_flags.cpp +++ b/modules/core/perf/opencl/perf_usage_flags.cpp @@ -12,25 +12,33 @@ namespace opencv_test { namespace ocl { -typedef TestBaseWithParam > UsageFlagsBoolFixture; +typedef TestBaseWithParam> SizeUsageFlagsFixture; -OCL_PERF_TEST_P(UsageFlagsBoolFixture, UsageFlags_AllocHostMem, ::testing::Combine(OCL_TEST_SIZES, Bool())) +OCL_PERF_TEST_P(SizeUsageFlagsFixture, UsageFlags_AllocMem, + ::testing::Combine( + OCL_TEST_SIZES, + testing::Values(USAGE_DEFAULT, USAGE_ALLOCATE_HOST_MEMORY, USAGE_ALLOCATE_DEVICE_MEMORY), // USAGE_ALLOCATE_SHARED_MEMORY + testing::Values(USAGE_DEFAULT, USAGE_ALLOCATE_HOST_MEMORY, USAGE_ALLOCATE_DEVICE_MEMORY), // USAGE_ALLOCATE_SHARED_MEMORY + testing::Values(USAGE_DEFAULT, USAGE_ALLOCATE_HOST_MEMORY, USAGE_ALLOCATE_DEVICE_MEMORY) // USAGE_ALLOCATE_SHARED_MEMORY + )) { Size sz = get<0>(GetParam()); - bool allocHostMem = get<1>(GetParam()); + UMatUsageFlags srcAllocMem = get<1>(GetParam()); + UMatUsageFlags dstAllocMem = get<2>(GetParam()); + UMatUsageFlags finalAllocMem = get<3>(GetParam()); - UMat src(sz, CV_8UC1, Scalar::all(128)); + UMat src(sz, CV_8UC1, Scalar::all(128), srcAllocMem); OCL_TEST_CYCLE() { - UMat dst(allocHostMem ? USAGE_ALLOCATE_HOST_MEMORY : USAGE_DEFAULT); + UMat dst(dstAllocMem); cv::add(src, Scalar::all(1), dst); { Mat canvas = dst.getMat(ACCESS_RW); cv::putText(canvas, "Test", Point(20, 20), FONT_HERSHEY_PLAIN, 1, Scalar::all(255)); } - UMat final; + UMat final(finalAllocMem); cv::subtract(dst, Scalar::all(1), final); } diff --git a/modules/core/src/directx.cpp b/modules/core/src/directx.cpp index d17adc6b48..2dbc3e2763 100644 --- a/modules/core/src/directx.cpp +++ b/modules/core/src/directx.cpp @@ -80,15 +80,15 @@ int getTypeFromDXGI_FORMAT(const int iDXGI_FORMAT) case DXGI_FORMAT_R32G32B32_UINT: case DXGI_FORMAT_R32G32B32_SINT: return CV_32SC3; //case DXGI_FORMAT_R16G16B16A16_TYPELESS: - //case DXGI_FORMAT_R16G16B16A16_FLOAT: + case DXGI_FORMAT_R16G16B16A16_FLOAT: return CV_16FC4; case DXGI_FORMAT_R16G16B16A16_UNORM: case DXGI_FORMAT_R16G16B16A16_UINT: return CV_16UC4; case DXGI_FORMAT_R16G16B16A16_SNORM: case DXGI_FORMAT_R16G16B16A16_SINT: return CV_16SC4; //case DXGI_FORMAT_R32G32_TYPELESS: - //case DXGI_FORMAT_R32G32_FLOAT: - //case DXGI_FORMAT_R32G32_UINT: - //case DXGI_FORMAT_R32G32_SINT: + case DXGI_FORMAT_R32G32_FLOAT: return CV_32FC2; + case DXGI_FORMAT_R32G32_UINT: + case DXGI_FORMAT_R32G32_SINT: return CV_32SC2; //case DXGI_FORMAT_R32G8X24_TYPELESS: //case DXGI_FORMAT_D32_FLOAT_S8X24_UINT: //case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS: @@ -104,13 +104,13 @@ int getTypeFromDXGI_FORMAT(const int iDXGI_FORMAT) case DXGI_FORMAT_R8G8B8A8_SNORM: case DXGI_FORMAT_R8G8B8A8_SINT: return CV_8SC4; //case DXGI_FORMAT_R16G16_TYPELESS: - //case DXGI_FORMAT_R16G16_FLOAT: + case DXGI_FORMAT_R16G16_FLOAT: return CV_16FC2; case DXGI_FORMAT_R16G16_UNORM: case DXGI_FORMAT_R16G16_UINT: return CV_16UC2; case DXGI_FORMAT_R16G16_SNORM: case DXGI_FORMAT_R16G16_SINT: return CV_16SC2; //case DXGI_FORMAT_R32_TYPELESS: - //case DXGI_FORMAT_D32_FLOAT: + case DXGI_FORMAT_D32_FLOAT: case DXGI_FORMAT_R32_FLOAT: return CV_32FC1; case DXGI_FORMAT_R32_UINT: case DXGI_FORMAT_R32_SINT: return CV_32SC1; @@ -124,7 +124,7 @@ int getTypeFromDXGI_FORMAT(const int iDXGI_FORMAT) case DXGI_FORMAT_R8G8_SNORM: case DXGI_FORMAT_R8G8_SINT: return CV_8SC2; //case DXGI_FORMAT_R16_TYPELESS: - //case DXGI_FORMAT_R16_FLOAT: + case DXGI_FORMAT_R16_FLOAT: return CV_16FC1; case DXGI_FORMAT_D16_UNORM: case DXGI_FORMAT_R16_UNORM: case DXGI_FORMAT_R16_UINT: return CV_16UC1; @@ -138,8 +138,8 @@ int getTypeFromDXGI_FORMAT(const int iDXGI_FORMAT) case DXGI_FORMAT_A8_UNORM: return CV_8UC1; //case DXGI_FORMAT_R1_UNORM: //case DXGI_FORMAT_R9G9B9E5_SHAREDEXP: - //case DXGI_FORMAT_R8G8_B8G8_UNORM: - //case DXGI_FORMAT_G8R8_G8B8_UNORM: + case DXGI_FORMAT_R8G8_B8G8_UNORM: + case DXGI_FORMAT_G8R8_G8B8_UNORM: return CV_8UC4; //case DXGI_FORMAT_BC1_TYPELESS: //case DXGI_FORMAT_BC1_UNORM: //case DXGI_FORMAT_BC1_UNORM_SRGB: diff --git a/modules/core/src/dxt.cpp b/modules/core/src/dxt.cpp index 87873666d9..ab42a40a44 100644 --- a/modules/core/src/dxt.cpp +++ b/modules/core/src/dxt.cpp @@ -40,7 +40,7 @@ //M*/ #include "precomp.hpp" -#include "opencv2/core/opencl/runtime/opencl_clamdfft.hpp" +#include "opencv2/core/opencl/runtime/opencl_clfft.hpp" #include "opencv2/core/opencl/runtime/opencl_core.hpp" #include "opencl_kernels_core.hpp" #include @@ -2420,7 +2420,7 @@ namespace cv { #define CLAMDDFT_Assert(func) \ { \ - clAmdFftStatus s = (func); \ + clfftStatus s = (func); \ CV_Assert(s == CLFFT_SUCCESS); \ } @@ -2437,8 +2437,8 @@ class PlanCache bool dft_scale = (flags & DFT_SCALE) != 0; bool dft_rows = (flags & DFT_ROWS) != 0; - clAmdFftLayout inLayout = CLFFT_REAL, outLayout = CLFFT_REAL; - clAmdFftDim dim = dft_size.height == 1 || dft_rows ? CLFFT_1D : CLFFT_2D; + clfftLayout inLayout = CLFFT_REAL, outLayout = CLFFT_REAL; + clfftDim dim = dft_size.height == 1 || dft_rows ? CLFFT_1D : CLFFT_2D; size_t batchSize = dft_rows ? dft_size.height : 1; size_t clLengthsIn[3] = { (size_t)dft_size.width, dft_rows ? 1 : (size_t)dft_size.height, 1 }; @@ -2475,28 +2475,30 @@ class PlanCache clStridesIn[2] = dft_rows ? clStridesIn[1] : dft_size.width * clStridesIn[1]; clStridesOut[2] = dft_rows ? clStridesOut[1] : dft_size.width * clStridesOut[1]; - CLAMDDFT_Assert(clAmdFftCreateDefaultPlan(&plHandle, (cl_context)ocl::Context::getDefault().ptr(), dim, clLengthsIn)) + CLAMDDFT_Assert(clfftCreateDefaultPlan(&plHandle, (cl_context)ocl::Context::getDefault().ptr(), dim, clLengthsIn)) // setting plan properties - CLAMDDFT_Assert(clAmdFftSetPlanPrecision(plHandle, doubleFP ? CLFFT_DOUBLE : CLFFT_SINGLE)); - CLAMDDFT_Assert(clAmdFftSetResultLocation(plHandle, inplace ? CLFFT_INPLACE : CLFFT_OUTOFPLACE)) - CLAMDDFT_Assert(clAmdFftSetLayout(plHandle, inLayout, outLayout)) - CLAMDDFT_Assert(clAmdFftSetPlanBatchSize(plHandle, batchSize)) - CLAMDDFT_Assert(clAmdFftSetPlanInStride(plHandle, dim, clStridesIn)) - CLAMDDFT_Assert(clAmdFftSetPlanOutStride(plHandle, dim, clStridesOut)) - CLAMDDFT_Assert(clAmdFftSetPlanDistance(plHandle, clStridesIn[dim], clStridesOut[dim])) + CLAMDDFT_Assert(clfftSetPlanPrecision(plHandle, doubleFP ? CLFFT_DOUBLE : CLFFT_SINGLE)); + CLAMDDFT_Assert(clfftSetResultLocation(plHandle, inplace ? CLFFT_INPLACE : CLFFT_OUTOFPLACE)) + CLAMDDFT_Assert(clfftSetLayout(plHandle, inLayout, outLayout)) + CLAMDDFT_Assert(clfftSetPlanBatchSize(plHandle, batchSize)) + CLAMDDFT_Assert(clfftSetPlanInStride(plHandle, dim, clStridesIn)) + CLAMDDFT_Assert(clfftSetPlanOutStride(plHandle, dim, clStridesOut)) + CLAMDDFT_Assert(clfftSetPlanDistance(plHandle, clStridesIn[dim], clStridesOut[dim])) float scale = dft_scale ? 1.0f / (dft_rows ? dft_size.width : dft_size.area()) : 1.0f; - CLAMDDFT_Assert(clAmdFftSetPlanScale(plHandle, dft_inverse ? CLFFT_BACKWARD : CLFFT_FORWARD, scale)) + CLAMDDFT_Assert(clfftSetPlanScale(plHandle, dft_inverse ? CLFFT_BACKWARD : CLFFT_FORWARD, scale)) // ready to bake cl_command_queue queue = (cl_command_queue)ocl::Queue::getDefault().ptr(); - CLAMDDFT_Assert(clAmdFftBakePlan(plHandle, 1, &queue, NULL, NULL)) + CLAMDDFT_Assert(clfftBakePlan(plHandle, 1, &queue, NULL, NULL)) } ~FftPlan() { -// clAmdFftDestroyPlan(&plHandle); + // Do not tear down clFFT. + // The user application may still use clFFT even after OpenCV is unloaded. + /*clfftDestroyPlan(&plHandle);*/ } friend class PlanCache; @@ -2510,7 +2512,7 @@ class PlanCache FftType fftType; cl_context context; - clAmdFftPlanHandle plHandle; + clfftPlanHandle plHandle; }; public: @@ -2519,8 +2521,8 @@ public: CV_SINGLETON_LAZY_INIT_REF(PlanCache, new PlanCache()) } - clAmdFftPlanHandle getPlanHandle(const Size & dft_size, int src_step, int dst_step, bool doubleFP, - bool inplace, int flags, FftType fftType) + clfftPlanHandle getPlanHandle(const Size & dft_size, int src_step, int dst_step, bool doubleFP, + bool inplace, int flags, FftType fftType) { cl_context currentContext = (cl_context)ocl::Context::getDefault().ptr(); @@ -2620,13 +2622,13 @@ static bool ocl_dft_amdfft(InputArray _src, OutputArray _dst, int flags) UMat src = _src.getUMat(), dst = _dst.getUMat(); bool inplace = src.u == dst.u; - clAmdFftPlanHandle plHandle = PlanCache::getInstance(). + clfftPlanHandle plHandle = PlanCache::getInstance(). getPlanHandle(ssize, (int)src.step, (int)dst.step, depth == CV_64F, inplace, flags, fftType); // get the bufferSize size_t bufferSize = 0; - CLAMDDFT_Assert(clAmdFftGetTmpBufSize(plHandle, &bufferSize)) + CLAMDDFT_Assert(clfftGetTmpBufSize(plHandle, &bufferSize)) UMat tmpBuffer(1, (int)bufferSize, CV_8UC1); cl_mem srcarg = (cl_mem)src.handle(ACCESS_READ); @@ -2635,9 +2637,9 @@ static bool ocl_dft_amdfft(InputArray _src, OutputArray _dst, int flags) cl_command_queue queue = (cl_command_queue)ocl::Queue::getDefault().ptr(); cl_event e = 0; - CLAMDDFT_Assert(clAmdFftEnqueueTransform(plHandle, dft_inverse ? CLFFT_BACKWARD : CLFFT_FORWARD, - 1, &queue, 0, NULL, &e, - &srcarg, &dstarg, (cl_mem)tmpBuffer.handle(ACCESS_RW))) + CLAMDDFT_Assert(clfftEnqueueTransform(plHandle, dft_inverse ? CLFFT_BACKWARD : CLFFT_FORWARD, + 1, &queue, 0, NULL, &e, + &srcarg, &dstarg, (cl_mem)tmpBuffer.handle(ACCESS_RW))) tmpBuffer.addref(); clSetEventCallback(e, CL_COMPLETE, oclCleanupCallback, tmpBuffer.u); diff --git a/modules/core/src/intel_gpu_gemm.inl.hpp b/modules/core/src/intel_gpu_gemm.inl.hpp index fbd567b949..a73e71a67d 100644 --- a/modules/core/src/intel_gpu_gemm.inl.hpp +++ b/modules/core/src/intel_gpu_gemm.inl.hpp @@ -26,7 +26,7 @@ #include #include "opencl_kernels_core.hpp" -#include "opencv2/core/opencl/runtime/opencl_clamdblas.hpp" +#include "opencv2/core/opencl/runtime/opencl_clblas.hpp" #include "opencv2/core/opencl/runtime/opencl_core.hpp" namespace cv diff --git a/modules/core/src/matmul.dispatch.cpp b/modules/core/src/matmul.dispatch.cpp index f4bd14b5dd..651c454490 100644 --- a/modules/core/src/matmul.dispatch.cpp +++ b/modules/core/src/matmul.dispatch.cpp @@ -43,7 +43,7 @@ #include "precomp.hpp" #include "opencl_kernels_core.hpp" -#include "opencv2/core/opencl/runtime/opencl_clamdblas.hpp" +#include "opencv2/core/opencl/runtime/opencl_clblas.hpp" #include "opencv2/core/opencl/runtime/opencl_core.hpp" #include "intel_gpu_gemm.inl.hpp" @@ -106,47 +106,47 @@ static bool ocl_gemm_amdblas( InputArray matA, InputArray matB, double alpha, int offa = (int)A.offset / esz, offb = (int)B.offset / esz, offc = (int)D.offset / esz; cl_command_queue clq = (cl_command_queue)ocl::Queue::getDefault().ptr(); - clAmdBlasTranspose transA = atrans ? clAmdBlasTrans : clAmdBlasNoTrans; - clAmdBlasTranspose transB = btrans ? clAmdBlasTrans : clAmdBlasNoTrans; - clAmdBlasOrder order = clAmdBlasRowMajor; - clAmdBlasStatus status = clAmdBlasSuccess; + clblasTranspose transA = atrans ? clblasTrans : clblasNoTrans; + clblasTranspose transB = btrans ? clblasTrans : clblasNoTrans; + clblasOrder order = clblasRowMajor; + clblasStatus status = clblasSuccess; if (type == CV_32FC1) - status = clAmdBlasSgemmEx(order, transA, transB, M, N, K, - (cl_float)alpha, (const cl_mem)A.handle(ACCESS_READ), offa, lda, - (const cl_mem)B.handle(ACCESS_READ), offb, ldb, - (cl_float)beta, (cl_mem)D.handle(ACCESS_RW), offc, ldc, - 1, &clq, 0, NULL, NULL); + status = clblasSgemm(order, transA, transB, M, N, K, + (cl_float)alpha, (const cl_mem)A.handle(ACCESS_READ), offa, lda, + (const cl_mem)B.handle(ACCESS_READ), offb, ldb, + (cl_float)beta, (cl_mem)D.handle(ACCESS_RW), offc, ldc, + 1, &clq, 0, NULL, NULL); else if (type == CV_64FC1) - status = clAmdBlasDgemmEx(order, transA, transB, M, N, K, - alpha, (const cl_mem)A.handle(ACCESS_READ), offa, lda, - (const cl_mem)B.handle(ACCESS_READ), offb, ldb, - beta, (cl_mem)D.handle(ACCESS_RW), offc, ldc, - 1, &clq, 0, NULL, NULL); + status = clblasDgemm(order, transA, transB, M, N, K, + alpha, (const cl_mem)A.handle(ACCESS_READ), offa, lda, + (const cl_mem)B.handle(ACCESS_READ), offb, ldb, + beta, (cl_mem)D.handle(ACCESS_RW), offc, ldc, + 1, &clq, 0, NULL, NULL); else if (type == CV_32FC2) { cl_float2 alpha_2 = { { (cl_float)alpha, 0 } }; cl_float2 beta_2 = { { (cl_float)beta, 0 } }; - status = clAmdBlasCgemmEx(order, transA, transB, M, N, K, - alpha_2, (const cl_mem)A.handle(ACCESS_READ), offa, lda, - (const cl_mem)B.handle(ACCESS_READ), offb, ldb, - beta_2, (cl_mem)D.handle(ACCESS_RW), offc, ldc, - 1, &clq, 0, NULL, NULL); + status = clblasCgemm(order, transA, transB, M, N, K, + alpha_2, (const cl_mem)A.handle(ACCESS_READ), offa, lda, + (const cl_mem)B.handle(ACCESS_READ), offb, ldb, + beta_2, (cl_mem)D.handle(ACCESS_RW), offc, ldc, + 1, &clq, 0, NULL, NULL); } else if (type == CV_64FC2) { cl_double2 alpha_2 = { { alpha, 0 } }; cl_double2 beta_2 = { { beta, 0 } }; - status = clAmdBlasZgemmEx(order, transA, transB, M, N, K, - alpha_2, (const cl_mem)A.handle(ACCESS_READ), offa, lda, - (const cl_mem)B.handle(ACCESS_READ), offb, ldb, - beta_2, (cl_mem)D.handle(ACCESS_RW), offc, ldc, - 1, &clq, 0, NULL, NULL); + status = clblasZgemm(order, transA, transB, M, N, K, + alpha_2, (const cl_mem)A.handle(ACCESS_READ), offa, lda, + (const cl_mem)B.handle(ACCESS_READ), offb, ldb, + beta_2, (cl_mem)D.handle(ACCESS_RW), offc, ldc, + 1, &clq, 0, NULL, NULL); } else CV_Error(Error::StsUnsupportedFormat, ""); - return status == clAmdBlasSuccess; + return status == clblasSuccess; } #endif diff --git a/modules/core/src/ocl.cpp b/modules/core/src/ocl.cpp index 8749b29ec8..0e97cf52fe 100644 --- a/modules/core/src/ocl.cpp +++ b/modules/core/src/ocl.cpp @@ -108,8 +108,8 @@ #define CV_OPENCL_SVM_TRACE_ERROR_P(...) #endif -#include "opencv2/core/opencl/runtime/opencl_clamdblas.hpp" -#include "opencv2/core/opencl/runtime/opencl_clamdfft.hpp" +#include "opencv2/core/opencl/runtime/opencl_clblas.hpp" +#include "opencv2/core/opencl/runtime/opencl_clfft.hpp" #include "opencv2/core/opencl/runtime/opencl_core.hpp" @@ -1254,11 +1254,13 @@ public: ~AmdBlasHelper() { - try + // Do not tear down clBLAS. + // The user application may still use clBLAS even after OpenCV is unloaded. + /*try { - clAmdBlasTeardown(); + clblasTeardown(); } - catch (...) { } + catch (...) { }*/ } protected: @@ -1274,7 +1276,7 @@ protected: { try { - g_isAmdBlasAvailable = clAmdBlasSetup() == clAmdBlasSuccess; + g_isAmdBlasAvailable = clblasSetup() == clblasSuccess; } catch (...) { @@ -1328,11 +1330,13 @@ public: ~AmdFftHelper() { - try + // Do not tear down clFFT. + // The user application may still use clFFT even after OpenCV is unloaded. + /*try { -// clAmdFftTeardown(); + clfftTeardown(); } - catch (...) { } + catch (...) { }*/ } protected: @@ -1349,10 +1353,10 @@ protected: try { cl_uint major, minor, patch; - CV_Assert(clAmdFftInitSetupData(&setupData) == CLFFT_SUCCESS); + CV_Assert(clfftInitSetupData(&setupData) == CLFFT_SUCCESS); // it throws exception in case AmdFft binaries are not found - CV_Assert(clAmdFftGetVersion(&major, &minor, &patch) == CLFFT_SUCCESS); + CV_Assert(clfftGetVersion(&major, &minor, &patch) == CLFFT_SUCCESS); g_isAmdFftAvailable = true; } catch (const Exception &) @@ -1369,12 +1373,12 @@ protected: } private: - static clAmdFftSetupData setupData; + static clfftSetupData setupData; static bool g_isAmdFftInitialized; static bool g_isAmdFftAvailable; }; -clAmdFftSetupData AmdFftHelper::setupData; +clfftSetupData AmdFftHelper::setupData; bool AmdFftHelper::g_isAmdFftAvailable = false; bool AmdFftHelper::g_isAmdFftInitialized = false; @@ -5518,13 +5522,19 @@ public: && !(u->originalUMatData && u->originalUMatData->handle) ) { - handle = clCreateBuffer(ctx_handle, CL_MEM_USE_HOST_PTR|createFlags, + // Change the host-side origdata[size] to "pinned memory" that enables fast + // DMA-transfers over PCIe to the device. Often used with clEnqueueMapBuffer/clEnqueueUnmapMemObject + handle = clCreateBuffer(ctx_handle, CL_MEM_USE_HOST_PTR|(createFlags & ~CL_MEM_ALLOC_HOST_PTR), u->size, u->origdata, &retval); - CV_OCL_DBG_CHECK_RESULT(retval, cv::format("clCreateBuffer(CL_MEM_USE_HOST_PTR|createFlags, sz=%lld, origdata=%p) => %p", + CV_OCL_DBG_CHECK_RESULT(retval, cv::format("clCreateBuffer(CL_MEM_USE_HOST_PTR|(createFlags & ~CL_MEM_ALLOC_HOST_PTR), sz=%lld, origdata=%p) => %p", (long long int)u->size, u->origdata, (void*)handle).c_str()); } if((!handle || retval < 0) && !(accessFlags & ACCESS_FAST)) { + // Allocate device-side memory and immediately copy data from the host-side pointer origdata[size]. + // If createFlags=CL_MEM_ALLOC_HOST_PTR (aka cv::USAGE_ALLOCATE_HOST_MEMORY), then + // additionally allocate a host-side "pinned" duplicate of the origdata that is + // managed by OpenCL. This is potentially faster in unaligned/unmanaged scenarios. handle = clCreateBuffer(ctx_handle, CL_MEM_COPY_HOST_PTR|CL_MEM_READ_WRITE|createFlags, u->size, u->origdata, &retval); CV_OCL_DBG_CHECK_RESULT(retval, cv::format("clCreateBuffer(CL_MEM_COPY_HOST_PTR|CL_MEM_READ_WRITE|createFlags, sz=%lld, origdata=%p) => %p", diff --git a/modules/core/src/opencl/runtime/autogenerated/opencl_clamdblas_impl.hpp b/modules/core/src/opencl/runtime/autogenerated/opencl_clamdblas_impl.hpp deleted file mode 100644 index 9c7e4d1480..0000000000 --- a/modules/core/src/opencl/runtime/autogenerated/opencl_clamdblas_impl.hpp +++ /dev/null @@ -1,1358 +0,0 @@ -// -// AUTOGENERATED, DO NOT EDIT -// -// generated by parser_clamdblas.py -enum OPENCLAMDBLAS_FN_ID { -// OPENCLAMDBLAS_FN_clAmdBlasAddScratchImage = 0, -// OPENCLAMDBLAS_FN_clAmdBlasCaxpy = 1, -// OPENCLAMDBLAS_FN_clAmdBlasCcopy = 2, -// OPENCLAMDBLAS_FN_clAmdBlasCdotc = 3, -// OPENCLAMDBLAS_FN_clAmdBlasCdotu = 4, -// OPENCLAMDBLAS_FN_clAmdBlasCgbmv = 5, -// OPENCLAMDBLAS_FN_clAmdBlasCgemm = 6, - OPENCLAMDBLAS_FN_clAmdBlasCgemmEx = 7, -// OPENCLAMDBLAS_FN_clAmdBlasCgemv = 8, -// OPENCLAMDBLAS_FN_clAmdBlasCgemvEx = 9, -// OPENCLAMDBLAS_FN_clAmdBlasCgerc = 10, -// OPENCLAMDBLAS_FN_clAmdBlasCgeru = 11, -// OPENCLAMDBLAS_FN_clAmdBlasChbmv = 12, -// OPENCLAMDBLAS_FN_clAmdBlasChemm = 13, -// OPENCLAMDBLAS_FN_clAmdBlasChemv = 14, -// OPENCLAMDBLAS_FN_clAmdBlasCher = 15, -// OPENCLAMDBLAS_FN_clAmdBlasCher2 = 16, -// OPENCLAMDBLAS_FN_clAmdBlasCher2k = 17, -// OPENCLAMDBLAS_FN_clAmdBlasCherk = 18, -// OPENCLAMDBLAS_FN_clAmdBlasChpmv = 19, -// OPENCLAMDBLAS_FN_clAmdBlasChpr = 20, -// OPENCLAMDBLAS_FN_clAmdBlasChpr2 = 21, -// OPENCLAMDBLAS_FN_clAmdBlasCrotg = 22, -// OPENCLAMDBLAS_FN_clAmdBlasCscal = 23, -// OPENCLAMDBLAS_FN_clAmdBlasCsrot = 24, -// OPENCLAMDBLAS_FN_clAmdBlasCsscal = 25, -// OPENCLAMDBLAS_FN_clAmdBlasCswap = 26, -// OPENCLAMDBLAS_FN_clAmdBlasCsymm = 27, -// OPENCLAMDBLAS_FN_clAmdBlasCsyr2k = 28, -// OPENCLAMDBLAS_FN_clAmdBlasCsyr2kEx = 29, -// OPENCLAMDBLAS_FN_clAmdBlasCsyrk = 30, -// OPENCLAMDBLAS_FN_clAmdBlasCsyrkEx = 31, -// OPENCLAMDBLAS_FN_clAmdBlasCtbmv = 32, -// OPENCLAMDBLAS_FN_clAmdBlasCtbsv = 33, -// OPENCLAMDBLAS_FN_clAmdBlasCtpmv = 34, -// OPENCLAMDBLAS_FN_clAmdBlasCtpsv = 35, -// OPENCLAMDBLAS_FN_clAmdBlasCtrmm = 36, -// OPENCLAMDBLAS_FN_clAmdBlasCtrmmEx = 37, -// OPENCLAMDBLAS_FN_clAmdBlasCtrmv = 38, -// OPENCLAMDBLAS_FN_clAmdBlasCtrsm = 39, -// OPENCLAMDBLAS_FN_clAmdBlasCtrsmEx = 40, -// OPENCLAMDBLAS_FN_clAmdBlasCtrsv = 41, -// OPENCLAMDBLAS_FN_clAmdBlasDasum = 42, -// OPENCLAMDBLAS_FN_clAmdBlasDaxpy = 43, -// OPENCLAMDBLAS_FN_clAmdBlasDcopy = 44, -// OPENCLAMDBLAS_FN_clAmdBlasDdot = 45, -// OPENCLAMDBLAS_FN_clAmdBlasDgbmv = 46, -// OPENCLAMDBLAS_FN_clAmdBlasDgemm = 47, - OPENCLAMDBLAS_FN_clAmdBlasDgemmEx = 48, -// OPENCLAMDBLAS_FN_clAmdBlasDgemv = 49, -// OPENCLAMDBLAS_FN_clAmdBlasDgemvEx = 50, -// OPENCLAMDBLAS_FN_clAmdBlasDger = 51, -// OPENCLAMDBLAS_FN_clAmdBlasDnrm2 = 52, -// OPENCLAMDBLAS_FN_clAmdBlasDrot = 53, -// OPENCLAMDBLAS_FN_clAmdBlasDrotg = 54, -// OPENCLAMDBLAS_FN_clAmdBlasDrotm = 55, -// OPENCLAMDBLAS_FN_clAmdBlasDrotmg = 56, -// OPENCLAMDBLAS_FN_clAmdBlasDsbmv = 57, -// OPENCLAMDBLAS_FN_clAmdBlasDscal = 58, -// OPENCLAMDBLAS_FN_clAmdBlasDspmv = 59, -// OPENCLAMDBLAS_FN_clAmdBlasDspr = 60, -// OPENCLAMDBLAS_FN_clAmdBlasDspr2 = 61, -// OPENCLAMDBLAS_FN_clAmdBlasDswap = 62, -// OPENCLAMDBLAS_FN_clAmdBlasDsymm = 63, -// OPENCLAMDBLAS_FN_clAmdBlasDsymv = 64, -// OPENCLAMDBLAS_FN_clAmdBlasDsymvEx = 65, -// OPENCLAMDBLAS_FN_clAmdBlasDsyr = 66, -// OPENCLAMDBLAS_FN_clAmdBlasDsyr2 = 67, -// OPENCLAMDBLAS_FN_clAmdBlasDsyr2k = 68, -// OPENCLAMDBLAS_FN_clAmdBlasDsyr2kEx = 69, -// OPENCLAMDBLAS_FN_clAmdBlasDsyrk = 70, -// OPENCLAMDBLAS_FN_clAmdBlasDsyrkEx = 71, -// OPENCLAMDBLAS_FN_clAmdBlasDtbmv = 72, -// OPENCLAMDBLAS_FN_clAmdBlasDtbsv = 73, -// OPENCLAMDBLAS_FN_clAmdBlasDtpmv = 74, -// OPENCLAMDBLAS_FN_clAmdBlasDtpsv = 75, -// OPENCLAMDBLAS_FN_clAmdBlasDtrmm = 76, -// OPENCLAMDBLAS_FN_clAmdBlasDtrmmEx = 77, -// OPENCLAMDBLAS_FN_clAmdBlasDtrmv = 78, -// OPENCLAMDBLAS_FN_clAmdBlasDtrsm = 79, -// OPENCLAMDBLAS_FN_clAmdBlasDtrsmEx = 80, -// OPENCLAMDBLAS_FN_clAmdBlasDtrsv = 81, -// OPENCLAMDBLAS_FN_clAmdBlasDzasum = 82, -// OPENCLAMDBLAS_FN_clAmdBlasDznrm2 = 83, -// OPENCLAMDBLAS_FN_clAmdBlasGetVersion = 84, -// OPENCLAMDBLAS_FN_clAmdBlasRemoveScratchImage = 85, -// OPENCLAMDBLAS_FN_clAmdBlasSasum = 86, -// OPENCLAMDBLAS_FN_clAmdBlasSaxpy = 87, -// OPENCLAMDBLAS_FN_clAmdBlasScasum = 88, -// OPENCLAMDBLAS_FN_clAmdBlasScnrm2 = 89, -// OPENCLAMDBLAS_FN_clAmdBlasScopy = 90, -// OPENCLAMDBLAS_FN_clAmdBlasSdot = 91, - OPENCLAMDBLAS_FN_clAmdBlasSetup = 92, -// OPENCLAMDBLAS_FN_clAmdBlasSgbmv = 93, -// OPENCLAMDBLAS_FN_clAmdBlasSgemm = 94, - OPENCLAMDBLAS_FN_clAmdBlasSgemmEx = 95, -// OPENCLAMDBLAS_FN_clAmdBlasSgemv = 96, -// OPENCLAMDBLAS_FN_clAmdBlasSgemvEx = 97, -// OPENCLAMDBLAS_FN_clAmdBlasSger = 98, -// OPENCLAMDBLAS_FN_clAmdBlasSnrm2 = 99, -// OPENCLAMDBLAS_FN_clAmdBlasSrot = 100, -// OPENCLAMDBLAS_FN_clAmdBlasSrotg = 101, -// OPENCLAMDBLAS_FN_clAmdBlasSrotm = 102, -// OPENCLAMDBLAS_FN_clAmdBlasSrotmg = 103, -// OPENCLAMDBLAS_FN_clAmdBlasSsbmv = 104, -// OPENCLAMDBLAS_FN_clAmdBlasSscal = 105, -// OPENCLAMDBLAS_FN_clAmdBlasSspmv = 106, -// OPENCLAMDBLAS_FN_clAmdBlasSspr = 107, -// OPENCLAMDBLAS_FN_clAmdBlasSspr2 = 108, -// OPENCLAMDBLAS_FN_clAmdBlasSswap = 109, -// OPENCLAMDBLAS_FN_clAmdBlasSsymm = 110, -// OPENCLAMDBLAS_FN_clAmdBlasSsymv = 111, -// OPENCLAMDBLAS_FN_clAmdBlasSsymvEx = 112, -// OPENCLAMDBLAS_FN_clAmdBlasSsyr = 113, -// OPENCLAMDBLAS_FN_clAmdBlasSsyr2 = 114, -// OPENCLAMDBLAS_FN_clAmdBlasSsyr2k = 115, -// OPENCLAMDBLAS_FN_clAmdBlasSsyr2kEx = 116, -// OPENCLAMDBLAS_FN_clAmdBlasSsyrk = 117, -// OPENCLAMDBLAS_FN_clAmdBlasSsyrkEx = 118, -// OPENCLAMDBLAS_FN_clAmdBlasStbmv = 119, -// OPENCLAMDBLAS_FN_clAmdBlasStbsv = 120, -// OPENCLAMDBLAS_FN_clAmdBlasStpmv = 121, -// OPENCLAMDBLAS_FN_clAmdBlasStpsv = 122, -// OPENCLAMDBLAS_FN_clAmdBlasStrmm = 123, -// OPENCLAMDBLAS_FN_clAmdBlasStrmmEx = 124, -// OPENCLAMDBLAS_FN_clAmdBlasStrmv = 125, -// OPENCLAMDBLAS_FN_clAmdBlasStrsm = 126, -// OPENCLAMDBLAS_FN_clAmdBlasStrsmEx = 127, -// OPENCLAMDBLAS_FN_clAmdBlasStrsv = 128, - OPENCLAMDBLAS_FN_clAmdBlasTeardown = 129, -// OPENCLAMDBLAS_FN_clAmdBlasZaxpy = 130, -// OPENCLAMDBLAS_FN_clAmdBlasZcopy = 131, -// OPENCLAMDBLAS_FN_clAmdBlasZdotc = 132, -// OPENCLAMDBLAS_FN_clAmdBlasZdotu = 133, -// OPENCLAMDBLAS_FN_clAmdBlasZdrot = 134, -// OPENCLAMDBLAS_FN_clAmdBlasZdscal = 135, -// OPENCLAMDBLAS_FN_clAmdBlasZgbmv = 136, -// OPENCLAMDBLAS_FN_clAmdBlasZgemm = 137, - OPENCLAMDBLAS_FN_clAmdBlasZgemmEx = 138, -// OPENCLAMDBLAS_FN_clAmdBlasZgemv = 139, -// OPENCLAMDBLAS_FN_clAmdBlasZgemvEx = 140, -// OPENCLAMDBLAS_FN_clAmdBlasZgerc = 141, -// OPENCLAMDBLAS_FN_clAmdBlasZgeru = 142, -// OPENCLAMDBLAS_FN_clAmdBlasZhbmv = 143, -// OPENCLAMDBLAS_FN_clAmdBlasZhemm = 144, -// OPENCLAMDBLAS_FN_clAmdBlasZhemv = 145, -// OPENCLAMDBLAS_FN_clAmdBlasZher = 146, -// OPENCLAMDBLAS_FN_clAmdBlasZher2 = 147, -// OPENCLAMDBLAS_FN_clAmdBlasZher2k = 148, -// OPENCLAMDBLAS_FN_clAmdBlasZherk = 149, -// OPENCLAMDBLAS_FN_clAmdBlasZhpmv = 150, -// OPENCLAMDBLAS_FN_clAmdBlasZhpr = 151, -// OPENCLAMDBLAS_FN_clAmdBlasZhpr2 = 152, -// OPENCLAMDBLAS_FN_clAmdBlasZrotg = 153, -// OPENCLAMDBLAS_FN_clAmdBlasZscal = 154, -// OPENCLAMDBLAS_FN_clAmdBlasZswap = 155, -// OPENCLAMDBLAS_FN_clAmdBlasZsymm = 156, -// OPENCLAMDBLAS_FN_clAmdBlasZsyr2k = 157, -// OPENCLAMDBLAS_FN_clAmdBlasZsyr2kEx = 158, -// OPENCLAMDBLAS_FN_clAmdBlasZsyrk = 159, -// OPENCLAMDBLAS_FN_clAmdBlasZsyrkEx = 160, -// OPENCLAMDBLAS_FN_clAmdBlasZtbmv = 161, -// OPENCLAMDBLAS_FN_clAmdBlasZtbsv = 162, -// OPENCLAMDBLAS_FN_clAmdBlasZtpmv = 163, -// OPENCLAMDBLAS_FN_clAmdBlasZtpsv = 164, -// OPENCLAMDBLAS_FN_clAmdBlasZtrmm = 165, -// OPENCLAMDBLAS_FN_clAmdBlasZtrmmEx = 166, -// OPENCLAMDBLAS_FN_clAmdBlasZtrmv = 167, -// OPENCLAMDBLAS_FN_clAmdBlasZtrsm = 168, -// OPENCLAMDBLAS_FN_clAmdBlasZtrsmEx = 169, -// OPENCLAMDBLAS_FN_clAmdBlasZtrsv = 170, -// OPENCLAMDBLAS_FN_clAmdBlasiCamax = 171, -// OPENCLAMDBLAS_FN_clAmdBlasiDamax = 172, -// OPENCLAMDBLAS_FN_clAmdBlasiSamax = 173, -// OPENCLAMDBLAS_FN_clAmdBlasiZamax = 174, -}; - -namespace { -// generated by parser_clamdblas.py -#define openclamdblas_fn0(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(); } \ - -#define openclamdblas_fn1(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1); } \ - -#define openclamdblas_fn2(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2); } \ - -#define openclamdblas_fn3(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3); } \ - -#define openclamdblas_fn4(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4); } \ - -#define openclamdblas_fn5(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5); } \ - -#define openclamdblas_fn6(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6); } \ - -#define openclamdblas_fn7(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7); } \ - -#define openclamdblas_fn8(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8); } \ - -#define openclamdblas_fn9(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9); } \ - -#define openclamdblas_fn10(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); } \ - -#define openclamdblas_fn11(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); } \ - -#define openclamdblas_fn12(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); } \ - -#define openclamdblas_fn13(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); } \ - -#define openclamdblas_fn14(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); } \ - -#define openclamdblas_fn15(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); } \ - -#define openclamdblas_fn16(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); } \ - -#define openclamdblas_fn17(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17); } \ - -#define openclamdblas_fn18(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18); } \ - -#define openclamdblas_fn19(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19); } \ - -#define openclamdblas_fn20(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20); } \ - -#define openclamdblas_fn21(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21); } \ - -#define openclamdblas_fn22(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22); } \ - -} - -// generated by parser_clamdblas.py -//openclamdblas_fn4(OPENCLAMDBLAS_FN_clAmdBlasAddScratchImage, cl_ulong, (cl_context p1, size_t p2, size_t p3, clAmdBlasStatus* p4)) -//cl_ulong (*clAmdBlasAddScratchImage)(cl_context, size_t, size_t, clAmdBlasStatus*) = -// OPENCLAMDBLAS_FN_clAmdBlasAddScratchImage_switch_fn; -//static const struct DynamicFnEntry clAmdBlasAddScratchImage_definition = { "clAmdBlasAddScratchImage", (void**)&clAmdBlasAddScratchImage}; - -//openclamdblas_fn13(OPENCLAMDBLAS_FN_clAmdBlasCaxpy, clAmdBlasStatus, (size_t p1, cl_float2 p2, const cl_mem p3, size_t p4, int p5, cl_mem p6, size_t p7, int p8, cl_uint p9, cl_command_queue* p10, cl_uint p11, const cl_event* p12, cl_event* p13)) -//clAmdBlasStatus (*clAmdBlasCaxpy)(size_t, cl_float2, const cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCaxpy_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCaxpy_definition = { "clAmdBlasCaxpy", (void**)&clAmdBlasCaxpy}; - -//openclamdblas_fn12(OPENCLAMDBLAS_FN_clAmdBlasCcopy, clAmdBlasStatus, (size_t p1, const cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) -//clAmdBlasStatus (*clAmdBlasCcopy)(size_t, const cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCcopy_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCcopy_definition = { "clAmdBlasCcopy", (void**)&clAmdBlasCcopy}; - -//openclamdblas_fn15(OPENCLAMDBLAS_FN_clAmdBlasCdotc, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, const cl_mem p7, size_t p8, int p9, cl_mem p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) -//clAmdBlasStatus (*clAmdBlasCdotc)(size_t, cl_mem, size_t, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCdotc_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCdotc_definition = { "clAmdBlasCdotc", (void**)&clAmdBlasCdotc}; - -//openclamdblas_fn15(OPENCLAMDBLAS_FN_clAmdBlasCdotu, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, const cl_mem p7, size_t p8, int p9, cl_mem p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) -//clAmdBlasStatus (*clAmdBlasCdotu)(size_t, cl_mem, size_t, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCdotu_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCdotu_definition = { "clAmdBlasCdotu", (void**)&clAmdBlasCdotu}; - -//openclamdblas_fn22(OPENCLAMDBLAS_FN_clAmdBlasCgbmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasTranspose p2, size_t p3, size_t p4, size_t p5, size_t p6, cl_float2 p7, const cl_mem p8, size_t p9, size_t p10, const cl_mem p11, size_t p12, int p13, cl_float2 p14, cl_mem p15, size_t p16, int p17, cl_uint p18, cl_command_queue* p19, cl_uint p20, const cl_event* p21, cl_event* p22)) -//clAmdBlasStatus (*clAmdBlasCgbmv)(clAmdBlasOrder, clAmdBlasTranspose, size_t, size_t, size_t, size_t, cl_float2, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_float2, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCgbmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCgbmv_definition = { "clAmdBlasCgbmv", (void**)&clAmdBlasCgbmv}; - -//openclamdblas_fn19(OPENCLAMDBLAS_FN_clAmdBlasCgemm, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasTranspose p2, clAmdBlasTranspose p3, size_t p4, size_t p5, size_t p6, FloatComplex p7, const cl_mem p8, size_t p9, const cl_mem p10, size_t p11, FloatComplex p12, cl_mem p13, size_t p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) -//clAmdBlasStatus (*clAmdBlasCgemm)(clAmdBlasOrder, clAmdBlasTranspose, clAmdBlasTranspose, size_t, size_t, size_t, FloatComplex, const cl_mem, size_t, const cl_mem, size_t, FloatComplex, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCgemm_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCgemm_definition = { "clAmdBlasCgemm", (void**)&clAmdBlasCgemm}; - -openclamdblas_fn22(OPENCLAMDBLAS_FN_clAmdBlasCgemmEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasTranspose p2, clAmdBlasTranspose p3, size_t p4, size_t p5, size_t p6, FloatComplex p7, const cl_mem p8, size_t p9, size_t p10, const cl_mem p11, size_t p12, size_t p13, FloatComplex p14, cl_mem p15, size_t p16, size_t p17, cl_uint p18, cl_command_queue* p19, cl_uint p20, const cl_event* p21, cl_event* p22)) -clAmdBlasStatus (*clAmdBlasCgemmEx)(clAmdBlasOrder, clAmdBlasTranspose, clAmdBlasTranspose, size_t, size_t, size_t, FloatComplex, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, FloatComplex, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = - OPENCLAMDBLAS_FN_clAmdBlasCgemmEx_switch_fn; -static const struct DynamicFnEntry clAmdBlasCgemmEx_definition = { "clAmdBlasCgemmEx", (void**)&clAmdBlasCgemmEx}; - -//openclamdblas_fn19(OPENCLAMDBLAS_FN_clAmdBlasCgemv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasTranspose p2, size_t p3, size_t p4, FloatComplex p5, const cl_mem p6, size_t p7, const cl_mem p8, size_t p9, int p10, FloatComplex p11, cl_mem p12, size_t p13, int p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) -//clAmdBlasStatus (*clAmdBlasCgemv)(clAmdBlasOrder, clAmdBlasTranspose, size_t, size_t, FloatComplex, const cl_mem, size_t, const cl_mem, size_t, int, FloatComplex, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCgemv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCgemv_definition = { "clAmdBlasCgemv", (void**)&clAmdBlasCgemv}; - -//openclamdblas_fn20(OPENCLAMDBLAS_FN_clAmdBlasCgemvEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasTranspose p2, size_t p3, size_t p4, FloatComplex p5, const cl_mem p6, size_t p7, size_t p8, const cl_mem p9, size_t p10, int p11, FloatComplex p12, cl_mem p13, size_t p14, int p15, cl_uint p16, cl_command_queue* p17, cl_uint p18, const cl_event* p19, cl_event* p20)) -//clAmdBlasStatus (*clAmdBlasCgemvEx)(clAmdBlasOrder, clAmdBlasTranspose, size_t, size_t, FloatComplex, const cl_mem, size_t, size_t, const cl_mem, size_t, int, FloatComplex, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCgemvEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCgemvEx_definition = { "clAmdBlasCgemvEx", (void**)&clAmdBlasCgemvEx}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasCgerc, clAmdBlasStatus, (clAmdBlasOrder p1, size_t p2, size_t p3, cl_float2 p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasCgerc)(clAmdBlasOrder, size_t, size_t, cl_float2, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCgerc_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCgerc_definition = { "clAmdBlasCgerc", (void**)&clAmdBlasCgerc}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasCgeru, clAmdBlasStatus, (clAmdBlasOrder p1, size_t p2, size_t p3, cl_float2 p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasCgeru)(clAmdBlasOrder, size_t, size_t, cl_float2, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCgeru_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCgeru_definition = { "clAmdBlasCgeru", (void**)&clAmdBlasCgeru}; - -//openclamdblas_fn20(OPENCLAMDBLAS_FN_clAmdBlasChbmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, size_t p4, cl_float2 p5, const cl_mem p6, size_t p7, size_t p8, const cl_mem p9, size_t p10, int p11, cl_float2 p12, cl_mem p13, size_t p14, int p15, cl_uint p16, cl_command_queue* p17, cl_uint p18, const cl_event* p19, cl_event* p20)) -//clAmdBlasStatus (*clAmdBlasChbmv)(clAmdBlasOrder, clAmdBlasUplo, size_t, size_t, cl_float2, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_float2, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasChbmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasChbmv_definition = { "clAmdBlasChbmv", (void**)&clAmdBlasChbmv}; - -//openclamdblas_fn21(OPENCLAMDBLAS_FN_clAmdBlasChemm, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, size_t p4, size_t p5, cl_float2 p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, cl_float2 p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) -//clAmdBlasStatus (*clAmdBlasChemm)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, size_t, size_t, cl_float2, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_float2, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasChemm_switch_fn; -//static const struct DynamicFnEntry clAmdBlasChemm_definition = { "clAmdBlasChemm", (void**)&clAmdBlasChemm}; - -//openclamdblas_fn19(OPENCLAMDBLAS_FN_clAmdBlasChemv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, FloatComplex p4, const cl_mem p5, size_t p6, size_t p7, const cl_mem p8, size_t p9, int p10, FloatComplex p11, cl_mem p12, size_t p13, int p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) -//clAmdBlasStatus (*clAmdBlasChemv)(clAmdBlasOrder, clAmdBlasUplo, size_t, FloatComplex, const cl_mem, size_t, size_t, const cl_mem, size_t, int, FloatComplex, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasChemv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasChemv_definition = { "clAmdBlasChemv", (void**)&clAmdBlasChemv}; - -//openclamdblas_fn15(OPENCLAMDBLAS_FN_clAmdBlasCher, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_float p4, const cl_mem p5, size_t p6, int p7, cl_mem p8, size_t p9, size_t p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) -//clAmdBlasStatus (*clAmdBlasCher)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_float, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCher_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCher_definition = { "clAmdBlasCher", (void**)&clAmdBlasCher}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasCher2, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_float2 p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasCher2)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_float2, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCher2_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCher2_definition = { "clAmdBlasCher2", (void**)&clAmdBlasCher2}; - -//openclamdblas_fn21(OPENCLAMDBLAS_FN_clAmdBlasCher2k, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, size_t p4, size_t p5, FloatComplex p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, cl_float p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) -//clAmdBlasStatus (*clAmdBlasCher2k)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, size_t, size_t, FloatComplex, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_float, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCher2k_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCher2k_definition = { "clAmdBlasCher2k", (void**)&clAmdBlasCher2k}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasCherk, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, size_t p4, size_t p5, float p6, const cl_mem p7, size_t p8, size_t p9, float p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasCherk)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, size_t, size_t, float, const cl_mem, size_t, size_t, float, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCherk_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCherk_definition = { "clAmdBlasCherk", (void**)&clAmdBlasCherk}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasChpmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_float2 p4, const cl_mem p5, size_t p6, const cl_mem p7, size_t p8, int p9, cl_float2 p10, cl_mem p11, size_t p12, int p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasChpmv)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_float2, const cl_mem, size_t, const cl_mem, size_t, int, cl_float2, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasChpmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasChpmv_definition = { "clAmdBlasChpmv", (void**)&clAmdBlasChpmv}; - -//openclamdblas_fn14(OPENCLAMDBLAS_FN_clAmdBlasChpr, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_float p4, const cl_mem p5, size_t p6, int p7, cl_mem p8, size_t p9, cl_uint p10, cl_command_queue* p11, cl_uint p12, const cl_event* p13, cl_event* p14)) -//clAmdBlasStatus (*clAmdBlasChpr)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_float, const cl_mem, size_t, int, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasChpr_switch_fn; -//static const struct DynamicFnEntry clAmdBlasChpr_definition = { "clAmdBlasChpr", (void**)&clAmdBlasChpr}; - -//openclamdblas_fn17(OPENCLAMDBLAS_FN_clAmdBlasChpr2, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_float2 p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) -//clAmdBlasStatus (*clAmdBlasChpr2)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_float2, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasChpr2_switch_fn; -//static const struct DynamicFnEntry clAmdBlasChpr2_definition = { "clAmdBlasChpr2", (void**)&clAmdBlasChpr2}; - -//openclamdblas_fn13(OPENCLAMDBLAS_FN_clAmdBlasCrotg, clAmdBlasStatus, (cl_mem p1, size_t p2, cl_mem p3, size_t p4, cl_mem p5, size_t p6, cl_mem p7, size_t p8, cl_uint p9, cl_command_queue* p10, cl_uint p11, const cl_event* p12, cl_event* p13)) -//clAmdBlasStatus (*clAmdBlasCrotg)(cl_mem, size_t, cl_mem, size_t, cl_mem, size_t, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCrotg_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCrotg_definition = { "clAmdBlasCrotg", (void**)&clAmdBlasCrotg}; - -//openclamdblas_fn10(OPENCLAMDBLAS_FN_clAmdBlasCscal, clAmdBlasStatus, (size_t p1, cl_float2 p2, cl_mem p3, size_t p4, int p5, cl_uint p6, cl_command_queue* p7, cl_uint p8, const cl_event* p9, cl_event* p10)) -//clAmdBlasStatus (*clAmdBlasCscal)(size_t, cl_float2, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCscal_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCscal_definition = { "clAmdBlasCscal", (void**)&clAmdBlasCscal}; - -//openclamdblas_fn14(OPENCLAMDBLAS_FN_clAmdBlasCsrot, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_float p8, cl_float p9, cl_uint p10, cl_command_queue* p11, cl_uint p12, const cl_event* p13, cl_event* p14)) -//clAmdBlasStatus (*clAmdBlasCsrot)(size_t, cl_mem, size_t, int, cl_mem, size_t, int, cl_float, cl_float, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCsrot_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCsrot_definition = { "clAmdBlasCsrot", (void**)&clAmdBlasCsrot}; - -//openclamdblas_fn10(OPENCLAMDBLAS_FN_clAmdBlasCsscal, clAmdBlasStatus, (size_t p1, cl_float p2, cl_mem p3, size_t p4, int p5, cl_uint p6, cl_command_queue* p7, cl_uint p8, const cl_event* p9, cl_event* p10)) -//clAmdBlasStatus (*clAmdBlasCsscal)(size_t, cl_float, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCsscal_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCsscal_definition = { "clAmdBlasCsscal", (void**)&clAmdBlasCsscal}; - -//openclamdblas_fn12(OPENCLAMDBLAS_FN_clAmdBlasCswap, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) -//clAmdBlasStatus (*clAmdBlasCswap)(size_t, cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCswap_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCswap_definition = { "clAmdBlasCswap", (void**)&clAmdBlasCswap}; - -//openclamdblas_fn21(OPENCLAMDBLAS_FN_clAmdBlasCsymm, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, size_t p4, size_t p5, cl_float2 p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, cl_float2 p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) -//clAmdBlasStatus (*clAmdBlasCsymm)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, size_t, size_t, cl_float2, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_float2, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCsymm_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCsymm_definition = { "clAmdBlasCsymm", (void**)&clAmdBlasCsymm}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasCsyr2k, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, size_t p4, size_t p5, FloatComplex p6, const cl_mem p7, size_t p8, const cl_mem p9, size_t p10, FloatComplex p11, cl_mem p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasCsyr2k)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, size_t, size_t, FloatComplex, const cl_mem, size_t, const cl_mem, size_t, FloatComplex, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCsyr2k_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCsyr2k_definition = { "clAmdBlasCsyr2k", (void**)&clAmdBlasCsyr2k}; - -//openclamdblas_fn21(OPENCLAMDBLAS_FN_clAmdBlasCsyr2kEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, size_t p4, size_t p5, FloatComplex p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, FloatComplex p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) -//clAmdBlasStatus (*clAmdBlasCsyr2kEx)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, size_t, size_t, FloatComplex, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, FloatComplex, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCsyr2kEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCsyr2kEx_definition = { "clAmdBlasCsyr2kEx", (void**)&clAmdBlasCsyr2kEx}; - -//openclamdblas_fn16(OPENCLAMDBLAS_FN_clAmdBlasCsyrk, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, size_t p4, size_t p5, FloatComplex p6, const cl_mem p7, size_t p8, FloatComplex p9, cl_mem p10, size_t p11, cl_uint p12, cl_command_queue* p13, cl_uint p14, const cl_event* p15, cl_event* p16)) -//clAmdBlasStatus (*clAmdBlasCsyrk)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, size_t, size_t, FloatComplex, const cl_mem, size_t, FloatComplex, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCsyrk_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCsyrk_definition = { "clAmdBlasCsyrk", (void**)&clAmdBlasCsyrk}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasCsyrkEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, size_t p4, size_t p5, FloatComplex p6, const cl_mem p7, size_t p8, size_t p9, FloatComplex p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasCsyrkEx)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, size_t, size_t, FloatComplex, const cl_mem, size_t, size_t, FloatComplex, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCsyrkEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCsyrkEx_definition = { "clAmdBlasCsyrkEx", (void**)&clAmdBlasCsyrkEx}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasCtbmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, size_t p6, const cl_mem p7, size_t p8, size_t p9, cl_mem p10, size_t p11, int p12, cl_mem p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasCtbmv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCtbmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCtbmv_definition = { "clAmdBlasCtbmv", (void**)&clAmdBlasCtbmv}; - -//openclamdblas_fn17(OPENCLAMDBLAS_FN_clAmdBlasCtbsv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, size_t p6, const cl_mem p7, size_t p8, size_t p9, cl_mem p10, size_t p11, int p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) -//clAmdBlasStatus (*clAmdBlasCtbsv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCtbsv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCtbsv_definition = { "clAmdBlasCtbsv", (void**)&clAmdBlasCtbsv}; - -//openclamdblas_fn16(OPENCLAMDBLAS_FN_clAmdBlasCtpmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, const cl_mem p6, size_t p7, cl_mem p8, size_t p9, int p10, cl_mem p11, cl_uint p12, cl_command_queue* p13, cl_uint p14, const cl_event* p15, cl_event* p16)) -//clAmdBlasStatus (*clAmdBlasCtpmv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, const cl_mem, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCtpmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCtpmv_definition = { "clAmdBlasCtpmv", (void**)&clAmdBlasCtpmv}; - -//openclamdblas_fn15(OPENCLAMDBLAS_FN_clAmdBlasCtpsv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, const cl_mem p6, size_t p7, cl_mem p8, size_t p9, int p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) -//clAmdBlasStatus (*clAmdBlasCtpsv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, const cl_mem, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCtpsv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCtpsv_definition = { "clAmdBlasCtpsv", (void**)&clAmdBlasCtpsv}; - -//openclamdblas_fn17(OPENCLAMDBLAS_FN_clAmdBlasCtrmm, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, clAmdBlasTranspose p4, clAmdBlasDiag p5, size_t p6, size_t p7, FloatComplex p8, const cl_mem p9, size_t p10, cl_mem p11, size_t p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) -//clAmdBlasStatus (*clAmdBlasCtrmm)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, FloatComplex, const cl_mem, size_t, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCtrmm_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCtrmm_definition = { "clAmdBlasCtrmm", (void**)&clAmdBlasCtrmm}; - -//openclamdblas_fn19(OPENCLAMDBLAS_FN_clAmdBlasCtrmmEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, clAmdBlasTranspose p4, clAmdBlasDiag p5, size_t p6, size_t p7, FloatComplex p8, const cl_mem p9, size_t p10, size_t p11, cl_mem p12, size_t p13, size_t p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) -//clAmdBlasStatus (*clAmdBlasCtrmmEx)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, FloatComplex, const cl_mem, size_t, size_t, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCtrmmEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCtrmmEx_definition = { "clAmdBlasCtrmmEx", (void**)&clAmdBlasCtrmmEx}; - -//openclamdblas_fn17(OPENCLAMDBLAS_FN_clAmdBlasCtrmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, const cl_mem p6, size_t p7, size_t p8, cl_mem p9, size_t p10, int p11, cl_mem p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) -//clAmdBlasStatus (*clAmdBlasCtrmv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCtrmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCtrmv_definition = { "clAmdBlasCtrmv", (void**)&clAmdBlasCtrmv}; - -//openclamdblas_fn17(OPENCLAMDBLAS_FN_clAmdBlasCtrsm, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, clAmdBlasTranspose p4, clAmdBlasDiag p5, size_t p6, size_t p7, FloatComplex p8, const cl_mem p9, size_t p10, cl_mem p11, size_t p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) -//clAmdBlasStatus (*clAmdBlasCtrsm)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, FloatComplex, const cl_mem, size_t, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCtrsm_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCtrsm_definition = { "clAmdBlasCtrsm", (void**)&clAmdBlasCtrsm}; - -//openclamdblas_fn19(OPENCLAMDBLAS_FN_clAmdBlasCtrsmEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, clAmdBlasTranspose p4, clAmdBlasDiag p5, size_t p6, size_t p7, FloatComplex p8, const cl_mem p9, size_t p10, size_t p11, cl_mem p12, size_t p13, size_t p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) -//clAmdBlasStatus (*clAmdBlasCtrsmEx)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, FloatComplex, const cl_mem, size_t, size_t, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCtrsmEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCtrsmEx_definition = { "clAmdBlasCtrsmEx", (void**)&clAmdBlasCtrsmEx}; - -//openclamdblas_fn16(OPENCLAMDBLAS_FN_clAmdBlasCtrsv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, const cl_mem p6, size_t p7, size_t p8, cl_mem p9, size_t p10, int p11, cl_uint p12, cl_command_queue* p13, cl_uint p14, const cl_event* p15, cl_event* p16)) -//clAmdBlasStatus (*clAmdBlasCtrsv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasCtrsv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasCtrsv_definition = { "clAmdBlasCtrsv", (void**)&clAmdBlasCtrsv}; - -//openclamdblas_fn12(OPENCLAMDBLAS_FN_clAmdBlasDasum, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) -//clAmdBlasStatus (*clAmdBlasDasum)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDasum_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDasum_definition = { "clAmdBlasDasum", (void**)&clAmdBlasDasum}; - -//openclamdblas_fn13(OPENCLAMDBLAS_FN_clAmdBlasDaxpy, clAmdBlasStatus, (size_t p1, cl_double p2, const cl_mem p3, size_t p4, int p5, cl_mem p6, size_t p7, int p8, cl_uint p9, cl_command_queue* p10, cl_uint p11, const cl_event* p12, cl_event* p13)) -//clAmdBlasStatus (*clAmdBlasDaxpy)(size_t, cl_double, const cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDaxpy_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDaxpy_definition = { "clAmdBlasDaxpy", (void**)&clAmdBlasDaxpy}; - -//openclamdblas_fn12(OPENCLAMDBLAS_FN_clAmdBlasDcopy, clAmdBlasStatus, (size_t p1, const cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) -//clAmdBlasStatus (*clAmdBlasDcopy)(size_t, const cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDcopy_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDcopy_definition = { "clAmdBlasDcopy", (void**)&clAmdBlasDcopy}; - -//openclamdblas_fn15(OPENCLAMDBLAS_FN_clAmdBlasDdot, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, const cl_mem p7, size_t p8, int p9, cl_mem p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) -//clAmdBlasStatus (*clAmdBlasDdot)(size_t, cl_mem, size_t, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDdot_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDdot_definition = { "clAmdBlasDdot", (void**)&clAmdBlasDdot}; - -//openclamdblas_fn22(OPENCLAMDBLAS_FN_clAmdBlasDgbmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasTranspose p2, size_t p3, size_t p4, size_t p5, size_t p6, cl_double p7, const cl_mem p8, size_t p9, size_t p10, const cl_mem p11, size_t p12, int p13, cl_double p14, cl_mem p15, size_t p16, int p17, cl_uint p18, cl_command_queue* p19, cl_uint p20, const cl_event* p21, cl_event* p22)) -//clAmdBlasStatus (*clAmdBlasDgbmv)(clAmdBlasOrder, clAmdBlasTranspose, size_t, size_t, size_t, size_t, cl_double, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_double, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDgbmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDgbmv_definition = { "clAmdBlasDgbmv", (void**)&clAmdBlasDgbmv}; - -//openclamdblas_fn19(OPENCLAMDBLAS_FN_clAmdBlasDgemm, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasTranspose p2, clAmdBlasTranspose p3, size_t p4, size_t p5, size_t p6, cl_double p7, const cl_mem p8, size_t p9, const cl_mem p10, size_t p11, cl_double p12, cl_mem p13, size_t p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) -//clAmdBlasStatus (*clAmdBlasDgemm)(clAmdBlasOrder, clAmdBlasTranspose, clAmdBlasTranspose, size_t, size_t, size_t, cl_double, const cl_mem, size_t, const cl_mem, size_t, cl_double, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDgemm_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDgemm_definition = { "clAmdBlasDgemm", (void**)&clAmdBlasDgemm}; - -openclamdblas_fn22(OPENCLAMDBLAS_FN_clAmdBlasDgemmEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasTranspose p2, clAmdBlasTranspose p3, size_t p4, size_t p5, size_t p6, cl_double p7, const cl_mem p8, size_t p9, size_t p10, const cl_mem p11, size_t p12, size_t p13, cl_double p14, cl_mem p15, size_t p16, size_t p17, cl_uint p18, cl_command_queue* p19, cl_uint p20, const cl_event* p21, cl_event* p22)) -clAmdBlasStatus (*clAmdBlasDgemmEx)(clAmdBlasOrder, clAmdBlasTranspose, clAmdBlasTranspose, size_t, size_t, size_t, cl_double, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_double, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = - OPENCLAMDBLAS_FN_clAmdBlasDgemmEx_switch_fn; -static const struct DynamicFnEntry clAmdBlasDgemmEx_definition = { "clAmdBlasDgemmEx", (void**)&clAmdBlasDgemmEx}; - -//openclamdblas_fn19(OPENCLAMDBLAS_FN_clAmdBlasDgemv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasTranspose p2, size_t p3, size_t p4, cl_double p5, const cl_mem p6, size_t p7, const cl_mem p8, size_t p9, int p10, cl_double p11, cl_mem p12, size_t p13, int p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) -//clAmdBlasStatus (*clAmdBlasDgemv)(clAmdBlasOrder, clAmdBlasTranspose, size_t, size_t, cl_double, const cl_mem, size_t, const cl_mem, size_t, int, cl_double, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDgemv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDgemv_definition = { "clAmdBlasDgemv", (void**)&clAmdBlasDgemv}; - -//openclamdblas_fn20(OPENCLAMDBLAS_FN_clAmdBlasDgemvEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasTranspose p2, size_t p3, size_t p4, cl_double p5, const cl_mem p6, size_t p7, size_t p8, const cl_mem p9, size_t p10, int p11, cl_double p12, cl_mem p13, size_t p14, int p15, cl_uint p16, cl_command_queue* p17, cl_uint p18, const cl_event* p19, cl_event* p20)) -//clAmdBlasStatus (*clAmdBlasDgemvEx)(clAmdBlasOrder, clAmdBlasTranspose, size_t, size_t, cl_double, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_double, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDgemvEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDgemvEx_definition = { "clAmdBlasDgemvEx", (void**)&clAmdBlasDgemvEx}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasDger, clAmdBlasStatus, (clAmdBlasOrder p1, size_t p2, size_t p3, cl_double p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasDger)(clAmdBlasOrder, size_t, size_t, cl_double, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDger_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDger_definition = { "clAmdBlasDger", (void**)&clAmdBlasDger}; - -//openclamdblas_fn12(OPENCLAMDBLAS_FN_clAmdBlasDnrm2, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) -//clAmdBlasStatus (*clAmdBlasDnrm2)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDnrm2_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDnrm2_definition = { "clAmdBlasDnrm2", (void**)&clAmdBlasDnrm2}; - -//openclamdblas_fn14(OPENCLAMDBLAS_FN_clAmdBlasDrot, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_double p8, cl_double p9, cl_uint p10, cl_command_queue* p11, cl_uint p12, const cl_event* p13, cl_event* p14)) -//clAmdBlasStatus (*clAmdBlasDrot)(size_t, cl_mem, size_t, int, cl_mem, size_t, int, cl_double, cl_double, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDrot_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDrot_definition = { "clAmdBlasDrot", (void**)&clAmdBlasDrot}; - -//openclamdblas_fn13(OPENCLAMDBLAS_FN_clAmdBlasDrotg, clAmdBlasStatus, (cl_mem p1, size_t p2, cl_mem p3, size_t p4, cl_mem p5, size_t p6, cl_mem p7, size_t p8, cl_uint p9, cl_command_queue* p10, cl_uint p11, const cl_event* p12, cl_event* p13)) -//clAmdBlasStatus (*clAmdBlasDrotg)(cl_mem, size_t, cl_mem, size_t, cl_mem, size_t, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDrotg_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDrotg_definition = { "clAmdBlasDrotg", (void**)&clAmdBlasDrotg}; - -//openclamdblas_fn14(OPENCLAMDBLAS_FN_clAmdBlasDrotm, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, cl_uint p10, cl_command_queue* p11, cl_uint p12, const cl_event* p13, cl_event* p14)) -//clAmdBlasStatus (*clAmdBlasDrotm)(size_t, cl_mem, size_t, int, cl_mem, size_t, int, const cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDrotm_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDrotm_definition = { "clAmdBlasDrotm", (void**)&clAmdBlasDrotm}; - -//openclamdblas_fn15(OPENCLAMDBLAS_FN_clAmdBlasDrotmg, clAmdBlasStatus, (cl_mem p1, size_t p2, cl_mem p3, size_t p4, cl_mem p5, size_t p6, const cl_mem p7, size_t p8, cl_mem p9, size_t p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) -//clAmdBlasStatus (*clAmdBlasDrotmg)(cl_mem, size_t, cl_mem, size_t, cl_mem, size_t, const cl_mem, size_t, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDrotmg_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDrotmg_definition = { "clAmdBlasDrotmg", (void**)&clAmdBlasDrotmg}; - -//openclamdblas_fn20(OPENCLAMDBLAS_FN_clAmdBlasDsbmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, size_t p4, cl_double p5, const cl_mem p6, size_t p7, size_t p8, const cl_mem p9, size_t p10, int p11, cl_double p12, cl_mem p13, size_t p14, int p15, cl_uint p16, cl_command_queue* p17, cl_uint p18, const cl_event* p19, cl_event* p20)) -//clAmdBlasStatus (*clAmdBlasDsbmv)(clAmdBlasOrder, clAmdBlasUplo, size_t, size_t, cl_double, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_double, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDsbmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDsbmv_definition = { "clAmdBlasDsbmv", (void**)&clAmdBlasDsbmv}; - -//openclamdblas_fn10(OPENCLAMDBLAS_FN_clAmdBlasDscal, clAmdBlasStatus, (size_t p1, cl_double p2, cl_mem p3, size_t p4, int p5, cl_uint p6, cl_command_queue* p7, cl_uint p8, const cl_event* p9, cl_event* p10)) -//clAmdBlasStatus (*clAmdBlasDscal)(size_t, cl_double, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDscal_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDscal_definition = { "clAmdBlasDscal", (void**)&clAmdBlasDscal}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasDspmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_double p4, const cl_mem p5, size_t p6, const cl_mem p7, size_t p8, int p9, cl_double p10, cl_mem p11, size_t p12, int p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasDspmv)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_double, const cl_mem, size_t, const cl_mem, size_t, int, cl_double, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDspmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDspmv_definition = { "clAmdBlasDspmv", (void**)&clAmdBlasDspmv}; - -//openclamdblas_fn14(OPENCLAMDBLAS_FN_clAmdBlasDspr, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_double p4, const cl_mem p5, size_t p6, int p7, cl_mem p8, size_t p9, cl_uint p10, cl_command_queue* p11, cl_uint p12, const cl_event* p13, cl_event* p14)) -//clAmdBlasStatus (*clAmdBlasDspr)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_double, const cl_mem, size_t, int, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDspr_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDspr_definition = { "clAmdBlasDspr", (void**)&clAmdBlasDspr}; - -//openclamdblas_fn17(OPENCLAMDBLAS_FN_clAmdBlasDspr2, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_double p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) -//clAmdBlasStatus (*clAmdBlasDspr2)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_double, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDspr2_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDspr2_definition = { "clAmdBlasDspr2", (void**)&clAmdBlasDspr2}; - -//openclamdblas_fn12(OPENCLAMDBLAS_FN_clAmdBlasDswap, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) -//clAmdBlasStatus (*clAmdBlasDswap)(size_t, cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDswap_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDswap_definition = { "clAmdBlasDswap", (void**)&clAmdBlasDswap}; - -//openclamdblas_fn21(OPENCLAMDBLAS_FN_clAmdBlasDsymm, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, size_t p4, size_t p5, cl_double p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, cl_double p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) -//clAmdBlasStatus (*clAmdBlasDsymm)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, size_t, size_t, cl_double, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_double, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDsymm_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDsymm_definition = { "clAmdBlasDsymm", (void**)&clAmdBlasDsymm}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasDsymv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_double p4, const cl_mem p5, size_t p6, const cl_mem p7, size_t p8, int p9, cl_double p10, cl_mem p11, size_t p12, int p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasDsymv)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_double, const cl_mem, size_t, const cl_mem, size_t, int, cl_double, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDsymv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDsymv_definition = { "clAmdBlasDsymv", (void**)&clAmdBlasDsymv}; - -//openclamdblas_fn19(OPENCLAMDBLAS_FN_clAmdBlasDsymvEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_double p4, const cl_mem p5, size_t p6, size_t p7, const cl_mem p8, size_t p9, int p10, cl_double p11, cl_mem p12, size_t p13, int p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) -//clAmdBlasStatus (*clAmdBlasDsymvEx)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_double, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_double, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDsymvEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDsymvEx_definition = { "clAmdBlasDsymvEx", (void**)&clAmdBlasDsymvEx}; - -//openclamdblas_fn15(OPENCLAMDBLAS_FN_clAmdBlasDsyr, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_double p4, const cl_mem p5, size_t p6, int p7, cl_mem p8, size_t p9, size_t p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) -//clAmdBlasStatus (*clAmdBlasDsyr)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_double, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDsyr_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDsyr_definition = { "clAmdBlasDsyr", (void**)&clAmdBlasDsyr}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasDsyr2, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_double p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasDsyr2)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_double, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDsyr2_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDsyr2_definition = { "clAmdBlasDsyr2", (void**)&clAmdBlasDsyr2}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasDsyr2k, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, size_t p4, size_t p5, cl_double p6, const cl_mem p7, size_t p8, const cl_mem p9, size_t p10, cl_double p11, cl_mem p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasDsyr2k)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, size_t, size_t, cl_double, const cl_mem, size_t, const cl_mem, size_t, cl_double, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDsyr2k_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDsyr2k_definition = { "clAmdBlasDsyr2k", (void**)&clAmdBlasDsyr2k}; - -//openclamdblas_fn21(OPENCLAMDBLAS_FN_clAmdBlasDsyr2kEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, size_t p4, size_t p5, cl_double p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, cl_double p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) -//clAmdBlasStatus (*clAmdBlasDsyr2kEx)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, size_t, size_t, cl_double, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_double, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDsyr2kEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDsyr2kEx_definition = { "clAmdBlasDsyr2kEx", (void**)&clAmdBlasDsyr2kEx}; - -//openclamdblas_fn16(OPENCLAMDBLAS_FN_clAmdBlasDsyrk, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, size_t p4, size_t p5, cl_double p6, const cl_mem p7, size_t p8, cl_double p9, cl_mem p10, size_t p11, cl_uint p12, cl_command_queue* p13, cl_uint p14, const cl_event* p15, cl_event* p16)) -//clAmdBlasStatus (*clAmdBlasDsyrk)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, size_t, size_t, cl_double, const cl_mem, size_t, cl_double, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDsyrk_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDsyrk_definition = { "clAmdBlasDsyrk", (void**)&clAmdBlasDsyrk}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasDsyrkEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, size_t p4, size_t p5, cl_double p6, const cl_mem p7, size_t p8, size_t p9, cl_double p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasDsyrkEx)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, size_t, size_t, cl_double, const cl_mem, size_t, size_t, cl_double, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDsyrkEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDsyrkEx_definition = { "clAmdBlasDsyrkEx", (void**)&clAmdBlasDsyrkEx}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasDtbmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, size_t p6, const cl_mem p7, size_t p8, size_t p9, cl_mem p10, size_t p11, int p12, cl_mem p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasDtbmv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDtbmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDtbmv_definition = { "clAmdBlasDtbmv", (void**)&clAmdBlasDtbmv}; - -//openclamdblas_fn17(OPENCLAMDBLAS_FN_clAmdBlasDtbsv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, size_t p6, const cl_mem p7, size_t p8, size_t p9, cl_mem p10, size_t p11, int p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) -//clAmdBlasStatus (*clAmdBlasDtbsv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDtbsv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDtbsv_definition = { "clAmdBlasDtbsv", (void**)&clAmdBlasDtbsv}; - -//openclamdblas_fn16(OPENCLAMDBLAS_FN_clAmdBlasDtpmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, const cl_mem p6, size_t p7, cl_mem p8, size_t p9, int p10, cl_mem p11, cl_uint p12, cl_command_queue* p13, cl_uint p14, const cl_event* p15, cl_event* p16)) -//clAmdBlasStatus (*clAmdBlasDtpmv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, const cl_mem, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDtpmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDtpmv_definition = { "clAmdBlasDtpmv", (void**)&clAmdBlasDtpmv}; - -//openclamdblas_fn15(OPENCLAMDBLAS_FN_clAmdBlasDtpsv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, const cl_mem p6, size_t p7, cl_mem p8, size_t p9, int p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) -//clAmdBlasStatus (*clAmdBlasDtpsv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, const cl_mem, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDtpsv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDtpsv_definition = { "clAmdBlasDtpsv", (void**)&clAmdBlasDtpsv}; - -//openclamdblas_fn17(OPENCLAMDBLAS_FN_clAmdBlasDtrmm, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, clAmdBlasTranspose p4, clAmdBlasDiag p5, size_t p6, size_t p7, cl_double p8, const cl_mem p9, size_t p10, cl_mem p11, size_t p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) -//clAmdBlasStatus (*clAmdBlasDtrmm)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, cl_double, const cl_mem, size_t, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDtrmm_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDtrmm_definition = { "clAmdBlasDtrmm", (void**)&clAmdBlasDtrmm}; - -//openclamdblas_fn19(OPENCLAMDBLAS_FN_clAmdBlasDtrmmEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, clAmdBlasTranspose p4, clAmdBlasDiag p5, size_t p6, size_t p7, cl_double p8, const cl_mem p9, size_t p10, size_t p11, cl_mem p12, size_t p13, size_t p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) -//clAmdBlasStatus (*clAmdBlasDtrmmEx)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, cl_double, const cl_mem, size_t, size_t, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDtrmmEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDtrmmEx_definition = { "clAmdBlasDtrmmEx", (void**)&clAmdBlasDtrmmEx}; - -//openclamdblas_fn17(OPENCLAMDBLAS_FN_clAmdBlasDtrmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, const cl_mem p6, size_t p7, size_t p8, cl_mem p9, size_t p10, int p11, cl_mem p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) -//clAmdBlasStatus (*clAmdBlasDtrmv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDtrmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDtrmv_definition = { "clAmdBlasDtrmv", (void**)&clAmdBlasDtrmv}; - -//openclamdblas_fn17(OPENCLAMDBLAS_FN_clAmdBlasDtrsm, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, clAmdBlasTranspose p4, clAmdBlasDiag p5, size_t p6, size_t p7, cl_double p8, const cl_mem p9, size_t p10, cl_mem p11, size_t p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) -//clAmdBlasStatus (*clAmdBlasDtrsm)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, cl_double, const cl_mem, size_t, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDtrsm_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDtrsm_definition = { "clAmdBlasDtrsm", (void**)&clAmdBlasDtrsm}; - -//openclamdblas_fn19(OPENCLAMDBLAS_FN_clAmdBlasDtrsmEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, clAmdBlasTranspose p4, clAmdBlasDiag p5, size_t p6, size_t p7, cl_double p8, const cl_mem p9, size_t p10, size_t p11, cl_mem p12, size_t p13, size_t p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) -//clAmdBlasStatus (*clAmdBlasDtrsmEx)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, cl_double, const cl_mem, size_t, size_t, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDtrsmEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDtrsmEx_definition = { "clAmdBlasDtrsmEx", (void**)&clAmdBlasDtrsmEx}; - -//openclamdblas_fn16(OPENCLAMDBLAS_FN_clAmdBlasDtrsv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, const cl_mem p6, size_t p7, size_t p8, cl_mem p9, size_t p10, int p11, cl_uint p12, cl_command_queue* p13, cl_uint p14, const cl_event* p15, cl_event* p16)) -//clAmdBlasStatus (*clAmdBlasDtrsv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDtrsv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDtrsv_definition = { "clAmdBlasDtrsv", (void**)&clAmdBlasDtrsv}; - -//openclamdblas_fn12(OPENCLAMDBLAS_FN_clAmdBlasDzasum, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) -//clAmdBlasStatus (*clAmdBlasDzasum)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDzasum_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDzasum_definition = { "clAmdBlasDzasum", (void**)&clAmdBlasDzasum}; - -//openclamdblas_fn12(OPENCLAMDBLAS_FN_clAmdBlasDznrm2, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) -//clAmdBlasStatus (*clAmdBlasDznrm2)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasDznrm2_switch_fn; -//static const struct DynamicFnEntry clAmdBlasDznrm2_definition = { "clAmdBlasDznrm2", (void**)&clAmdBlasDznrm2}; - -//openclamdblas_fn3(OPENCLAMDBLAS_FN_clAmdBlasGetVersion, clAmdBlasStatus, (cl_uint* p1, cl_uint* p2, cl_uint* p3)) -//clAmdBlasStatus (*clAmdBlasGetVersion)(cl_uint*, cl_uint*, cl_uint*) = -// OPENCLAMDBLAS_FN_clAmdBlasGetVersion_switch_fn; -//static const struct DynamicFnEntry clAmdBlasGetVersion_definition = { "clAmdBlasGetVersion", (void**)&clAmdBlasGetVersion}; - -//openclamdblas_fn1(OPENCLAMDBLAS_FN_clAmdBlasRemoveScratchImage, clAmdBlasStatus, (cl_ulong p1)) -//clAmdBlasStatus (*clAmdBlasRemoveScratchImage)(cl_ulong) = -// OPENCLAMDBLAS_FN_clAmdBlasRemoveScratchImage_switch_fn; -//static const struct DynamicFnEntry clAmdBlasRemoveScratchImage_definition = { "clAmdBlasRemoveScratchImage", (void**)&clAmdBlasRemoveScratchImage}; - -//openclamdblas_fn12(OPENCLAMDBLAS_FN_clAmdBlasSasum, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) -//clAmdBlasStatus (*clAmdBlasSasum)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSasum_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSasum_definition = { "clAmdBlasSasum", (void**)&clAmdBlasSasum}; - -//openclamdblas_fn13(OPENCLAMDBLAS_FN_clAmdBlasSaxpy, clAmdBlasStatus, (size_t p1, cl_float p2, const cl_mem p3, size_t p4, int p5, cl_mem p6, size_t p7, int p8, cl_uint p9, cl_command_queue* p10, cl_uint p11, const cl_event* p12, cl_event* p13)) -//clAmdBlasStatus (*clAmdBlasSaxpy)(size_t, cl_float, const cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSaxpy_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSaxpy_definition = { "clAmdBlasSaxpy", (void**)&clAmdBlasSaxpy}; - -//openclamdblas_fn12(OPENCLAMDBLAS_FN_clAmdBlasScasum, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) -//clAmdBlasStatus (*clAmdBlasScasum)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasScasum_switch_fn; -//static const struct DynamicFnEntry clAmdBlasScasum_definition = { "clAmdBlasScasum", (void**)&clAmdBlasScasum}; - -//openclamdblas_fn12(OPENCLAMDBLAS_FN_clAmdBlasScnrm2, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) -//clAmdBlasStatus (*clAmdBlasScnrm2)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasScnrm2_switch_fn; -//static const struct DynamicFnEntry clAmdBlasScnrm2_definition = { "clAmdBlasScnrm2", (void**)&clAmdBlasScnrm2}; - -//openclamdblas_fn12(OPENCLAMDBLAS_FN_clAmdBlasScopy, clAmdBlasStatus, (size_t p1, const cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) -//clAmdBlasStatus (*clAmdBlasScopy)(size_t, const cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasScopy_switch_fn; -//static const struct DynamicFnEntry clAmdBlasScopy_definition = { "clAmdBlasScopy", (void**)&clAmdBlasScopy}; - -//openclamdblas_fn15(OPENCLAMDBLAS_FN_clAmdBlasSdot, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, const cl_mem p7, size_t p8, int p9, cl_mem p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) -//clAmdBlasStatus (*clAmdBlasSdot)(size_t, cl_mem, size_t, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSdot_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSdot_definition = { "clAmdBlasSdot", (void**)&clAmdBlasSdot}; - -openclamdblas_fn0(OPENCLAMDBLAS_FN_clAmdBlasSetup, clAmdBlasStatus, ()) -clAmdBlasStatus (*clAmdBlasSetup)() = - OPENCLAMDBLAS_FN_clAmdBlasSetup_switch_fn; -static const struct DynamicFnEntry clAmdBlasSetup_definition = { "clAmdBlasSetup", (void**)&clAmdBlasSetup}; - -//openclamdblas_fn22(OPENCLAMDBLAS_FN_clAmdBlasSgbmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasTranspose p2, size_t p3, size_t p4, size_t p5, size_t p6, cl_float p7, const cl_mem p8, size_t p9, size_t p10, const cl_mem p11, size_t p12, int p13, cl_float p14, cl_mem p15, size_t p16, int p17, cl_uint p18, cl_command_queue* p19, cl_uint p20, const cl_event* p21, cl_event* p22)) -//clAmdBlasStatus (*clAmdBlasSgbmv)(clAmdBlasOrder, clAmdBlasTranspose, size_t, size_t, size_t, size_t, cl_float, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_float, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSgbmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSgbmv_definition = { "clAmdBlasSgbmv", (void**)&clAmdBlasSgbmv}; - -//openclamdblas_fn19(OPENCLAMDBLAS_FN_clAmdBlasSgemm, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasTranspose p2, clAmdBlasTranspose p3, size_t p4, size_t p5, size_t p6, cl_float p7, const cl_mem p8, size_t p9, const cl_mem p10, size_t p11, cl_float p12, cl_mem p13, size_t p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) -//clAmdBlasStatus (*clAmdBlasSgemm)(clAmdBlasOrder, clAmdBlasTranspose, clAmdBlasTranspose, size_t, size_t, size_t, cl_float, const cl_mem, size_t, const cl_mem, size_t, cl_float, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSgemm_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSgemm_definition = { "clAmdBlasSgemm", (void**)&clAmdBlasSgemm}; - -openclamdblas_fn22(OPENCLAMDBLAS_FN_clAmdBlasSgemmEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasTranspose p2, clAmdBlasTranspose p3, size_t p4, size_t p5, size_t p6, cl_float p7, const cl_mem p8, size_t p9, size_t p10, const cl_mem p11, size_t p12, size_t p13, cl_float p14, cl_mem p15, size_t p16, size_t p17, cl_uint p18, cl_command_queue* p19, cl_uint p20, const cl_event* p21, cl_event* p22)) -clAmdBlasStatus (*clAmdBlasSgemmEx)(clAmdBlasOrder, clAmdBlasTranspose, clAmdBlasTranspose, size_t, size_t, size_t, cl_float, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_float, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = - OPENCLAMDBLAS_FN_clAmdBlasSgemmEx_switch_fn; -static const struct DynamicFnEntry clAmdBlasSgemmEx_definition = { "clAmdBlasSgemmEx", (void**)&clAmdBlasSgemmEx}; - -//openclamdblas_fn19(OPENCLAMDBLAS_FN_clAmdBlasSgemv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasTranspose p2, size_t p3, size_t p4, cl_float p5, const cl_mem p6, size_t p7, const cl_mem p8, size_t p9, int p10, cl_float p11, cl_mem p12, size_t p13, int p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) -//clAmdBlasStatus (*clAmdBlasSgemv)(clAmdBlasOrder, clAmdBlasTranspose, size_t, size_t, cl_float, const cl_mem, size_t, const cl_mem, size_t, int, cl_float, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSgemv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSgemv_definition = { "clAmdBlasSgemv", (void**)&clAmdBlasSgemv}; - -//openclamdblas_fn20(OPENCLAMDBLAS_FN_clAmdBlasSgemvEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasTranspose p2, size_t p3, size_t p4, cl_float p5, const cl_mem p6, size_t p7, size_t p8, const cl_mem p9, size_t p10, int p11, cl_float p12, cl_mem p13, size_t p14, int p15, cl_uint p16, cl_command_queue* p17, cl_uint p18, const cl_event* p19, cl_event* p20)) -//clAmdBlasStatus (*clAmdBlasSgemvEx)(clAmdBlasOrder, clAmdBlasTranspose, size_t, size_t, cl_float, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_float, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSgemvEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSgemvEx_definition = { "clAmdBlasSgemvEx", (void**)&clAmdBlasSgemvEx}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasSger, clAmdBlasStatus, (clAmdBlasOrder p1, size_t p2, size_t p3, cl_float p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasSger)(clAmdBlasOrder, size_t, size_t, cl_float, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSger_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSger_definition = { "clAmdBlasSger", (void**)&clAmdBlasSger}; - -//openclamdblas_fn12(OPENCLAMDBLAS_FN_clAmdBlasSnrm2, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) -//clAmdBlasStatus (*clAmdBlasSnrm2)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSnrm2_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSnrm2_definition = { "clAmdBlasSnrm2", (void**)&clAmdBlasSnrm2}; - -//openclamdblas_fn14(OPENCLAMDBLAS_FN_clAmdBlasSrot, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_float p8, cl_float p9, cl_uint p10, cl_command_queue* p11, cl_uint p12, const cl_event* p13, cl_event* p14)) -//clAmdBlasStatus (*clAmdBlasSrot)(size_t, cl_mem, size_t, int, cl_mem, size_t, int, cl_float, cl_float, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSrot_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSrot_definition = { "clAmdBlasSrot", (void**)&clAmdBlasSrot}; - -//openclamdblas_fn13(OPENCLAMDBLAS_FN_clAmdBlasSrotg, clAmdBlasStatus, (cl_mem p1, size_t p2, cl_mem p3, size_t p4, cl_mem p5, size_t p6, cl_mem p7, size_t p8, cl_uint p9, cl_command_queue* p10, cl_uint p11, const cl_event* p12, cl_event* p13)) -//clAmdBlasStatus (*clAmdBlasSrotg)(cl_mem, size_t, cl_mem, size_t, cl_mem, size_t, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSrotg_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSrotg_definition = { "clAmdBlasSrotg", (void**)&clAmdBlasSrotg}; - -//openclamdblas_fn14(OPENCLAMDBLAS_FN_clAmdBlasSrotm, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, cl_uint p10, cl_command_queue* p11, cl_uint p12, const cl_event* p13, cl_event* p14)) -//clAmdBlasStatus (*clAmdBlasSrotm)(size_t, cl_mem, size_t, int, cl_mem, size_t, int, const cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSrotm_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSrotm_definition = { "clAmdBlasSrotm", (void**)&clAmdBlasSrotm}; - -//openclamdblas_fn15(OPENCLAMDBLAS_FN_clAmdBlasSrotmg, clAmdBlasStatus, (cl_mem p1, size_t p2, cl_mem p3, size_t p4, cl_mem p5, size_t p6, const cl_mem p7, size_t p8, cl_mem p9, size_t p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) -//clAmdBlasStatus (*clAmdBlasSrotmg)(cl_mem, size_t, cl_mem, size_t, cl_mem, size_t, const cl_mem, size_t, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSrotmg_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSrotmg_definition = { "clAmdBlasSrotmg", (void**)&clAmdBlasSrotmg}; - -//openclamdblas_fn20(OPENCLAMDBLAS_FN_clAmdBlasSsbmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, size_t p4, cl_float p5, const cl_mem p6, size_t p7, size_t p8, const cl_mem p9, size_t p10, int p11, cl_float p12, cl_mem p13, size_t p14, int p15, cl_uint p16, cl_command_queue* p17, cl_uint p18, const cl_event* p19, cl_event* p20)) -//clAmdBlasStatus (*clAmdBlasSsbmv)(clAmdBlasOrder, clAmdBlasUplo, size_t, size_t, cl_float, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_float, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSsbmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSsbmv_definition = { "clAmdBlasSsbmv", (void**)&clAmdBlasSsbmv}; - -//openclamdblas_fn10(OPENCLAMDBLAS_FN_clAmdBlasSscal, clAmdBlasStatus, (size_t p1, cl_float p2, cl_mem p3, size_t p4, int p5, cl_uint p6, cl_command_queue* p7, cl_uint p8, const cl_event* p9, cl_event* p10)) -//clAmdBlasStatus (*clAmdBlasSscal)(size_t, cl_float, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSscal_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSscal_definition = { "clAmdBlasSscal", (void**)&clAmdBlasSscal}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasSspmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_float p4, const cl_mem p5, size_t p6, const cl_mem p7, size_t p8, int p9, cl_float p10, cl_mem p11, size_t p12, int p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasSspmv)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_float, const cl_mem, size_t, const cl_mem, size_t, int, cl_float, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSspmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSspmv_definition = { "clAmdBlasSspmv", (void**)&clAmdBlasSspmv}; - -//openclamdblas_fn14(OPENCLAMDBLAS_FN_clAmdBlasSspr, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_float p4, const cl_mem p5, size_t p6, int p7, cl_mem p8, size_t p9, cl_uint p10, cl_command_queue* p11, cl_uint p12, const cl_event* p13, cl_event* p14)) -//clAmdBlasStatus (*clAmdBlasSspr)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_float, const cl_mem, size_t, int, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSspr_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSspr_definition = { "clAmdBlasSspr", (void**)&clAmdBlasSspr}; - -//openclamdblas_fn17(OPENCLAMDBLAS_FN_clAmdBlasSspr2, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_float p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) -//clAmdBlasStatus (*clAmdBlasSspr2)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_float, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSspr2_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSspr2_definition = { "clAmdBlasSspr2", (void**)&clAmdBlasSspr2}; - -//openclamdblas_fn12(OPENCLAMDBLAS_FN_clAmdBlasSswap, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) -//clAmdBlasStatus (*clAmdBlasSswap)(size_t, cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSswap_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSswap_definition = { "clAmdBlasSswap", (void**)&clAmdBlasSswap}; - -//openclamdblas_fn21(OPENCLAMDBLAS_FN_clAmdBlasSsymm, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, size_t p4, size_t p5, cl_float p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, cl_float p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) -//clAmdBlasStatus (*clAmdBlasSsymm)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, size_t, size_t, cl_float, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_float, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSsymm_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSsymm_definition = { "clAmdBlasSsymm", (void**)&clAmdBlasSsymm}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasSsymv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_float p4, const cl_mem p5, size_t p6, const cl_mem p7, size_t p8, int p9, cl_float p10, cl_mem p11, size_t p12, int p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasSsymv)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_float, const cl_mem, size_t, const cl_mem, size_t, int, cl_float, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSsymv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSsymv_definition = { "clAmdBlasSsymv", (void**)&clAmdBlasSsymv}; - -//openclamdblas_fn19(OPENCLAMDBLAS_FN_clAmdBlasSsymvEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_float p4, const cl_mem p5, size_t p6, size_t p7, const cl_mem p8, size_t p9, int p10, cl_float p11, cl_mem p12, size_t p13, int p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) -//clAmdBlasStatus (*clAmdBlasSsymvEx)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_float, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_float, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSsymvEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSsymvEx_definition = { "clAmdBlasSsymvEx", (void**)&clAmdBlasSsymvEx}; - -//openclamdblas_fn15(OPENCLAMDBLAS_FN_clAmdBlasSsyr, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_float p4, const cl_mem p5, size_t p6, int p7, cl_mem p8, size_t p9, size_t p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) -//clAmdBlasStatus (*clAmdBlasSsyr)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_float, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSsyr_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSsyr_definition = { "clAmdBlasSsyr", (void**)&clAmdBlasSsyr}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasSsyr2, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_float p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasSsyr2)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_float, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSsyr2_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSsyr2_definition = { "clAmdBlasSsyr2", (void**)&clAmdBlasSsyr2}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasSsyr2k, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, size_t p4, size_t p5, cl_float p6, const cl_mem p7, size_t p8, const cl_mem p9, size_t p10, cl_float p11, cl_mem p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasSsyr2k)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, size_t, size_t, cl_float, const cl_mem, size_t, const cl_mem, size_t, cl_float, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSsyr2k_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSsyr2k_definition = { "clAmdBlasSsyr2k", (void**)&clAmdBlasSsyr2k}; - -//openclamdblas_fn21(OPENCLAMDBLAS_FN_clAmdBlasSsyr2kEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, size_t p4, size_t p5, cl_float p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, cl_float p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) -//clAmdBlasStatus (*clAmdBlasSsyr2kEx)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, size_t, size_t, cl_float, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_float, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSsyr2kEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSsyr2kEx_definition = { "clAmdBlasSsyr2kEx", (void**)&clAmdBlasSsyr2kEx}; - -//openclamdblas_fn16(OPENCLAMDBLAS_FN_clAmdBlasSsyrk, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, size_t p4, size_t p5, cl_float p6, const cl_mem p7, size_t p8, cl_float p9, cl_mem p10, size_t p11, cl_uint p12, cl_command_queue* p13, cl_uint p14, const cl_event* p15, cl_event* p16)) -//clAmdBlasStatus (*clAmdBlasSsyrk)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, size_t, size_t, cl_float, const cl_mem, size_t, cl_float, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSsyrk_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSsyrk_definition = { "clAmdBlasSsyrk", (void**)&clAmdBlasSsyrk}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasSsyrkEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, size_t p4, size_t p5, cl_float p6, const cl_mem p7, size_t p8, size_t p9, cl_float p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasSsyrkEx)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, size_t, size_t, cl_float, const cl_mem, size_t, size_t, cl_float, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasSsyrkEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasSsyrkEx_definition = { "clAmdBlasSsyrkEx", (void**)&clAmdBlasSsyrkEx}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasStbmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, size_t p6, const cl_mem p7, size_t p8, size_t p9, cl_mem p10, size_t p11, int p12, cl_mem p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasStbmv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasStbmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasStbmv_definition = { "clAmdBlasStbmv", (void**)&clAmdBlasStbmv}; - -//openclamdblas_fn17(OPENCLAMDBLAS_FN_clAmdBlasStbsv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, size_t p6, const cl_mem p7, size_t p8, size_t p9, cl_mem p10, size_t p11, int p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) -//clAmdBlasStatus (*clAmdBlasStbsv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasStbsv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasStbsv_definition = { "clAmdBlasStbsv", (void**)&clAmdBlasStbsv}; - -//openclamdblas_fn16(OPENCLAMDBLAS_FN_clAmdBlasStpmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, const cl_mem p6, size_t p7, cl_mem p8, size_t p9, int p10, cl_mem p11, cl_uint p12, cl_command_queue* p13, cl_uint p14, const cl_event* p15, cl_event* p16)) -//clAmdBlasStatus (*clAmdBlasStpmv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, const cl_mem, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasStpmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasStpmv_definition = { "clAmdBlasStpmv", (void**)&clAmdBlasStpmv}; - -//openclamdblas_fn15(OPENCLAMDBLAS_FN_clAmdBlasStpsv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, const cl_mem p6, size_t p7, cl_mem p8, size_t p9, int p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) -//clAmdBlasStatus (*clAmdBlasStpsv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, const cl_mem, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasStpsv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasStpsv_definition = { "clAmdBlasStpsv", (void**)&clAmdBlasStpsv}; - -//openclamdblas_fn17(OPENCLAMDBLAS_FN_clAmdBlasStrmm, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, clAmdBlasTranspose p4, clAmdBlasDiag p5, size_t p6, size_t p7, cl_float p8, const cl_mem p9, size_t p10, cl_mem p11, size_t p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) -//clAmdBlasStatus (*clAmdBlasStrmm)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, cl_float, const cl_mem, size_t, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasStrmm_switch_fn; -//static const struct DynamicFnEntry clAmdBlasStrmm_definition = { "clAmdBlasStrmm", (void**)&clAmdBlasStrmm}; - -//openclamdblas_fn19(OPENCLAMDBLAS_FN_clAmdBlasStrmmEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, clAmdBlasTranspose p4, clAmdBlasDiag p5, size_t p6, size_t p7, cl_float p8, const cl_mem p9, size_t p10, size_t p11, cl_mem p12, size_t p13, size_t p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) -//clAmdBlasStatus (*clAmdBlasStrmmEx)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, cl_float, const cl_mem, size_t, size_t, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasStrmmEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasStrmmEx_definition = { "clAmdBlasStrmmEx", (void**)&clAmdBlasStrmmEx}; - -//openclamdblas_fn17(OPENCLAMDBLAS_FN_clAmdBlasStrmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, const cl_mem p6, size_t p7, size_t p8, cl_mem p9, size_t p10, int p11, cl_mem p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) -//clAmdBlasStatus (*clAmdBlasStrmv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasStrmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasStrmv_definition = { "clAmdBlasStrmv", (void**)&clAmdBlasStrmv}; - -//openclamdblas_fn17(OPENCLAMDBLAS_FN_clAmdBlasStrsm, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, clAmdBlasTranspose p4, clAmdBlasDiag p5, size_t p6, size_t p7, cl_float p8, const cl_mem p9, size_t p10, cl_mem p11, size_t p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) -//clAmdBlasStatus (*clAmdBlasStrsm)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, cl_float, const cl_mem, size_t, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasStrsm_switch_fn; -//static const struct DynamicFnEntry clAmdBlasStrsm_definition = { "clAmdBlasStrsm", (void**)&clAmdBlasStrsm}; - -//openclamdblas_fn19(OPENCLAMDBLAS_FN_clAmdBlasStrsmEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, clAmdBlasTranspose p4, clAmdBlasDiag p5, size_t p6, size_t p7, cl_float p8, const cl_mem p9, size_t p10, size_t p11, cl_mem p12, size_t p13, size_t p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) -//clAmdBlasStatus (*clAmdBlasStrsmEx)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, cl_float, const cl_mem, size_t, size_t, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasStrsmEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasStrsmEx_definition = { "clAmdBlasStrsmEx", (void**)&clAmdBlasStrsmEx}; - -//openclamdblas_fn16(OPENCLAMDBLAS_FN_clAmdBlasStrsv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, const cl_mem p6, size_t p7, size_t p8, cl_mem p9, size_t p10, int p11, cl_uint p12, cl_command_queue* p13, cl_uint p14, const cl_event* p15, cl_event* p16)) -//clAmdBlasStatus (*clAmdBlasStrsv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasStrsv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasStrsv_definition = { "clAmdBlasStrsv", (void**)&clAmdBlasStrsv}; - -openclamdblas_fn0(OPENCLAMDBLAS_FN_clAmdBlasTeardown, void, ()) -void (*clAmdBlasTeardown)() = - OPENCLAMDBLAS_FN_clAmdBlasTeardown_switch_fn; -static const struct DynamicFnEntry clAmdBlasTeardown_definition = { "clAmdBlasTeardown", (void**)&clAmdBlasTeardown}; - -//openclamdblas_fn13(OPENCLAMDBLAS_FN_clAmdBlasZaxpy, clAmdBlasStatus, (size_t p1, cl_double2 p2, const cl_mem p3, size_t p4, int p5, cl_mem p6, size_t p7, int p8, cl_uint p9, cl_command_queue* p10, cl_uint p11, const cl_event* p12, cl_event* p13)) -//clAmdBlasStatus (*clAmdBlasZaxpy)(size_t, cl_double2, const cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZaxpy_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZaxpy_definition = { "clAmdBlasZaxpy", (void**)&clAmdBlasZaxpy}; - -//openclamdblas_fn12(OPENCLAMDBLAS_FN_clAmdBlasZcopy, clAmdBlasStatus, (size_t p1, const cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) -//clAmdBlasStatus (*clAmdBlasZcopy)(size_t, const cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZcopy_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZcopy_definition = { "clAmdBlasZcopy", (void**)&clAmdBlasZcopy}; - -//openclamdblas_fn15(OPENCLAMDBLAS_FN_clAmdBlasZdotc, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, const cl_mem p7, size_t p8, int p9, cl_mem p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) -//clAmdBlasStatus (*clAmdBlasZdotc)(size_t, cl_mem, size_t, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZdotc_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZdotc_definition = { "clAmdBlasZdotc", (void**)&clAmdBlasZdotc}; - -//openclamdblas_fn15(OPENCLAMDBLAS_FN_clAmdBlasZdotu, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, const cl_mem p7, size_t p8, int p9, cl_mem p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) -//clAmdBlasStatus (*clAmdBlasZdotu)(size_t, cl_mem, size_t, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZdotu_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZdotu_definition = { "clAmdBlasZdotu", (void**)&clAmdBlasZdotu}; - -//openclamdblas_fn14(OPENCLAMDBLAS_FN_clAmdBlasZdrot, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_double p8, cl_double p9, cl_uint p10, cl_command_queue* p11, cl_uint p12, const cl_event* p13, cl_event* p14)) -//clAmdBlasStatus (*clAmdBlasZdrot)(size_t, cl_mem, size_t, int, cl_mem, size_t, int, cl_double, cl_double, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZdrot_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZdrot_definition = { "clAmdBlasZdrot", (void**)&clAmdBlasZdrot}; - -//openclamdblas_fn10(OPENCLAMDBLAS_FN_clAmdBlasZdscal, clAmdBlasStatus, (size_t p1, cl_double p2, cl_mem p3, size_t p4, int p5, cl_uint p6, cl_command_queue* p7, cl_uint p8, const cl_event* p9, cl_event* p10)) -//clAmdBlasStatus (*clAmdBlasZdscal)(size_t, cl_double, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZdscal_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZdscal_definition = { "clAmdBlasZdscal", (void**)&clAmdBlasZdscal}; - -//openclamdblas_fn22(OPENCLAMDBLAS_FN_clAmdBlasZgbmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasTranspose p2, size_t p3, size_t p4, size_t p5, size_t p6, cl_double2 p7, const cl_mem p8, size_t p9, size_t p10, const cl_mem p11, size_t p12, int p13, cl_double2 p14, cl_mem p15, size_t p16, int p17, cl_uint p18, cl_command_queue* p19, cl_uint p20, const cl_event* p21, cl_event* p22)) -//clAmdBlasStatus (*clAmdBlasZgbmv)(clAmdBlasOrder, clAmdBlasTranspose, size_t, size_t, size_t, size_t, cl_double2, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_double2, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZgbmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZgbmv_definition = { "clAmdBlasZgbmv", (void**)&clAmdBlasZgbmv}; - -//openclamdblas_fn19(OPENCLAMDBLAS_FN_clAmdBlasZgemm, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasTranspose p2, clAmdBlasTranspose p3, size_t p4, size_t p5, size_t p6, DoubleComplex p7, const cl_mem p8, size_t p9, const cl_mem p10, size_t p11, DoubleComplex p12, cl_mem p13, size_t p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) -//clAmdBlasStatus (*clAmdBlasZgemm)(clAmdBlasOrder, clAmdBlasTranspose, clAmdBlasTranspose, size_t, size_t, size_t, DoubleComplex, const cl_mem, size_t, const cl_mem, size_t, DoubleComplex, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZgemm_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZgemm_definition = { "clAmdBlasZgemm", (void**)&clAmdBlasZgemm}; - -openclamdblas_fn22(OPENCLAMDBLAS_FN_clAmdBlasZgemmEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasTranspose p2, clAmdBlasTranspose p3, size_t p4, size_t p5, size_t p6, DoubleComplex p7, const cl_mem p8, size_t p9, size_t p10, const cl_mem p11, size_t p12, size_t p13, DoubleComplex p14, cl_mem p15, size_t p16, size_t p17, cl_uint p18, cl_command_queue* p19, cl_uint p20, const cl_event* p21, cl_event* p22)) -clAmdBlasStatus (*clAmdBlasZgemmEx)(clAmdBlasOrder, clAmdBlasTranspose, clAmdBlasTranspose, size_t, size_t, size_t, DoubleComplex, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, DoubleComplex, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = - OPENCLAMDBLAS_FN_clAmdBlasZgemmEx_switch_fn; -static const struct DynamicFnEntry clAmdBlasZgemmEx_definition = { "clAmdBlasZgemmEx", (void**)&clAmdBlasZgemmEx}; - -//openclamdblas_fn19(OPENCLAMDBLAS_FN_clAmdBlasZgemv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasTranspose p2, size_t p3, size_t p4, DoubleComplex p5, const cl_mem p6, size_t p7, const cl_mem p8, size_t p9, int p10, DoubleComplex p11, cl_mem p12, size_t p13, int p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) -//clAmdBlasStatus (*clAmdBlasZgemv)(clAmdBlasOrder, clAmdBlasTranspose, size_t, size_t, DoubleComplex, const cl_mem, size_t, const cl_mem, size_t, int, DoubleComplex, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZgemv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZgemv_definition = { "clAmdBlasZgemv", (void**)&clAmdBlasZgemv}; - -//openclamdblas_fn20(OPENCLAMDBLAS_FN_clAmdBlasZgemvEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasTranspose p2, size_t p3, size_t p4, DoubleComplex p5, const cl_mem p6, size_t p7, size_t p8, const cl_mem p9, size_t p10, int p11, DoubleComplex p12, cl_mem p13, size_t p14, int p15, cl_uint p16, cl_command_queue* p17, cl_uint p18, const cl_event* p19, cl_event* p20)) -//clAmdBlasStatus (*clAmdBlasZgemvEx)(clAmdBlasOrder, clAmdBlasTranspose, size_t, size_t, DoubleComplex, const cl_mem, size_t, size_t, const cl_mem, size_t, int, DoubleComplex, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZgemvEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZgemvEx_definition = { "clAmdBlasZgemvEx", (void**)&clAmdBlasZgemvEx}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasZgerc, clAmdBlasStatus, (clAmdBlasOrder p1, size_t p2, size_t p3, cl_double2 p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasZgerc)(clAmdBlasOrder, size_t, size_t, cl_double2, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZgerc_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZgerc_definition = { "clAmdBlasZgerc", (void**)&clAmdBlasZgerc}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasZgeru, clAmdBlasStatus, (clAmdBlasOrder p1, size_t p2, size_t p3, cl_double2 p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasZgeru)(clAmdBlasOrder, size_t, size_t, cl_double2, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZgeru_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZgeru_definition = { "clAmdBlasZgeru", (void**)&clAmdBlasZgeru}; - -//openclamdblas_fn20(OPENCLAMDBLAS_FN_clAmdBlasZhbmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, size_t p4, cl_double2 p5, const cl_mem p6, size_t p7, size_t p8, const cl_mem p9, size_t p10, int p11, cl_double2 p12, cl_mem p13, size_t p14, int p15, cl_uint p16, cl_command_queue* p17, cl_uint p18, const cl_event* p19, cl_event* p20)) -//clAmdBlasStatus (*clAmdBlasZhbmv)(clAmdBlasOrder, clAmdBlasUplo, size_t, size_t, cl_double2, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_double2, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZhbmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZhbmv_definition = { "clAmdBlasZhbmv", (void**)&clAmdBlasZhbmv}; - -//openclamdblas_fn21(OPENCLAMDBLAS_FN_clAmdBlasZhemm, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, size_t p4, size_t p5, cl_double2 p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, cl_double2 p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) -//clAmdBlasStatus (*clAmdBlasZhemm)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, size_t, size_t, cl_double2, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_double2, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZhemm_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZhemm_definition = { "clAmdBlasZhemm", (void**)&clAmdBlasZhemm}; - -//openclamdblas_fn19(OPENCLAMDBLAS_FN_clAmdBlasZhemv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, DoubleComplex p4, const cl_mem p5, size_t p6, size_t p7, const cl_mem p8, size_t p9, int p10, DoubleComplex p11, cl_mem p12, size_t p13, int p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) -//clAmdBlasStatus (*clAmdBlasZhemv)(clAmdBlasOrder, clAmdBlasUplo, size_t, DoubleComplex, const cl_mem, size_t, size_t, const cl_mem, size_t, int, DoubleComplex, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZhemv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZhemv_definition = { "clAmdBlasZhemv", (void**)&clAmdBlasZhemv}; - -//openclamdblas_fn15(OPENCLAMDBLAS_FN_clAmdBlasZher, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_double p4, const cl_mem p5, size_t p6, int p7, cl_mem p8, size_t p9, size_t p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) -//clAmdBlasStatus (*clAmdBlasZher)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_double, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZher_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZher_definition = { "clAmdBlasZher", (void**)&clAmdBlasZher}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasZher2, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_double2 p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasZher2)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_double2, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZher2_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZher2_definition = { "clAmdBlasZher2", (void**)&clAmdBlasZher2}; - -//openclamdblas_fn21(OPENCLAMDBLAS_FN_clAmdBlasZher2k, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, size_t p4, size_t p5, DoubleComplex p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, cl_double p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) -//clAmdBlasStatus (*clAmdBlasZher2k)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, size_t, size_t, DoubleComplex, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_double, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZher2k_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZher2k_definition = { "clAmdBlasZher2k", (void**)&clAmdBlasZher2k}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasZherk, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, size_t p4, size_t p5, double p6, const cl_mem p7, size_t p8, size_t p9, double p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasZherk)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, size_t, size_t, double, const cl_mem, size_t, size_t, double, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZherk_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZherk_definition = { "clAmdBlasZherk", (void**)&clAmdBlasZherk}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasZhpmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_double2 p4, const cl_mem p5, size_t p6, const cl_mem p7, size_t p8, int p9, cl_double2 p10, cl_mem p11, size_t p12, int p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasZhpmv)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_double2, const cl_mem, size_t, const cl_mem, size_t, int, cl_double2, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZhpmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZhpmv_definition = { "clAmdBlasZhpmv", (void**)&clAmdBlasZhpmv}; - -//openclamdblas_fn14(OPENCLAMDBLAS_FN_clAmdBlasZhpr, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_double p4, const cl_mem p5, size_t p6, int p7, cl_mem p8, size_t p9, cl_uint p10, cl_command_queue* p11, cl_uint p12, const cl_event* p13, cl_event* p14)) -//clAmdBlasStatus (*clAmdBlasZhpr)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_double, const cl_mem, size_t, int, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZhpr_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZhpr_definition = { "clAmdBlasZhpr", (void**)&clAmdBlasZhpr}; - -//openclamdblas_fn17(OPENCLAMDBLAS_FN_clAmdBlasZhpr2, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, size_t p3, cl_double2 p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) -//clAmdBlasStatus (*clAmdBlasZhpr2)(clAmdBlasOrder, clAmdBlasUplo, size_t, cl_double2, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZhpr2_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZhpr2_definition = { "clAmdBlasZhpr2", (void**)&clAmdBlasZhpr2}; - -//openclamdblas_fn13(OPENCLAMDBLAS_FN_clAmdBlasZrotg, clAmdBlasStatus, (cl_mem p1, size_t p2, cl_mem p3, size_t p4, cl_mem p5, size_t p6, cl_mem p7, size_t p8, cl_uint p9, cl_command_queue* p10, cl_uint p11, const cl_event* p12, cl_event* p13)) -//clAmdBlasStatus (*clAmdBlasZrotg)(cl_mem, size_t, cl_mem, size_t, cl_mem, size_t, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZrotg_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZrotg_definition = { "clAmdBlasZrotg", (void**)&clAmdBlasZrotg}; - -//openclamdblas_fn10(OPENCLAMDBLAS_FN_clAmdBlasZscal, clAmdBlasStatus, (size_t p1, cl_double2 p2, cl_mem p3, size_t p4, int p5, cl_uint p6, cl_command_queue* p7, cl_uint p8, const cl_event* p9, cl_event* p10)) -//clAmdBlasStatus (*clAmdBlasZscal)(size_t, cl_double2, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZscal_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZscal_definition = { "clAmdBlasZscal", (void**)&clAmdBlasZscal}; - -//openclamdblas_fn12(OPENCLAMDBLAS_FN_clAmdBlasZswap, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) -//clAmdBlasStatus (*clAmdBlasZswap)(size_t, cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZswap_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZswap_definition = { "clAmdBlasZswap", (void**)&clAmdBlasZswap}; - -//openclamdblas_fn21(OPENCLAMDBLAS_FN_clAmdBlasZsymm, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, size_t p4, size_t p5, cl_double2 p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, cl_double2 p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) -//clAmdBlasStatus (*clAmdBlasZsymm)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, size_t, size_t, cl_double2, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_double2, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZsymm_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZsymm_definition = { "clAmdBlasZsymm", (void**)&clAmdBlasZsymm}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasZsyr2k, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, size_t p4, size_t p5, DoubleComplex p6, const cl_mem p7, size_t p8, const cl_mem p9, size_t p10, DoubleComplex p11, cl_mem p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasZsyr2k)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, size_t, size_t, DoubleComplex, const cl_mem, size_t, const cl_mem, size_t, DoubleComplex, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZsyr2k_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZsyr2k_definition = { "clAmdBlasZsyr2k", (void**)&clAmdBlasZsyr2k}; - -//openclamdblas_fn21(OPENCLAMDBLAS_FN_clAmdBlasZsyr2kEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, size_t p4, size_t p5, DoubleComplex p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, DoubleComplex p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) -//clAmdBlasStatus (*clAmdBlasZsyr2kEx)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, size_t, size_t, DoubleComplex, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, DoubleComplex, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZsyr2kEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZsyr2kEx_definition = { "clAmdBlasZsyr2kEx", (void**)&clAmdBlasZsyr2kEx}; - -//openclamdblas_fn16(OPENCLAMDBLAS_FN_clAmdBlasZsyrk, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, size_t p4, size_t p5, DoubleComplex p6, const cl_mem p7, size_t p8, DoubleComplex p9, cl_mem p10, size_t p11, cl_uint p12, cl_command_queue* p13, cl_uint p14, const cl_event* p15, cl_event* p16)) -//clAmdBlasStatus (*clAmdBlasZsyrk)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, size_t, size_t, DoubleComplex, const cl_mem, size_t, DoubleComplex, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZsyrk_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZsyrk_definition = { "clAmdBlasZsyrk", (void**)&clAmdBlasZsyrk}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasZsyrkEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, size_t p4, size_t p5, DoubleComplex p6, const cl_mem p7, size_t p8, size_t p9, DoubleComplex p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasZsyrkEx)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, size_t, size_t, DoubleComplex, const cl_mem, size_t, size_t, DoubleComplex, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZsyrkEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZsyrkEx_definition = { "clAmdBlasZsyrkEx", (void**)&clAmdBlasZsyrkEx}; - -//openclamdblas_fn18(OPENCLAMDBLAS_FN_clAmdBlasZtbmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, size_t p6, const cl_mem p7, size_t p8, size_t p9, cl_mem p10, size_t p11, int p12, cl_mem p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) -//clAmdBlasStatus (*clAmdBlasZtbmv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZtbmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZtbmv_definition = { "clAmdBlasZtbmv", (void**)&clAmdBlasZtbmv}; - -//openclamdblas_fn17(OPENCLAMDBLAS_FN_clAmdBlasZtbsv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, size_t p6, const cl_mem p7, size_t p8, size_t p9, cl_mem p10, size_t p11, int p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) -//clAmdBlasStatus (*clAmdBlasZtbsv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZtbsv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZtbsv_definition = { "clAmdBlasZtbsv", (void**)&clAmdBlasZtbsv}; - -//openclamdblas_fn16(OPENCLAMDBLAS_FN_clAmdBlasZtpmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, const cl_mem p6, size_t p7, cl_mem p8, size_t p9, int p10, cl_mem p11, cl_uint p12, cl_command_queue* p13, cl_uint p14, const cl_event* p15, cl_event* p16)) -//clAmdBlasStatus (*clAmdBlasZtpmv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, const cl_mem, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZtpmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZtpmv_definition = { "clAmdBlasZtpmv", (void**)&clAmdBlasZtpmv}; - -//openclamdblas_fn15(OPENCLAMDBLAS_FN_clAmdBlasZtpsv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, const cl_mem p6, size_t p7, cl_mem p8, size_t p9, int p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) -//clAmdBlasStatus (*clAmdBlasZtpsv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, const cl_mem, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZtpsv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZtpsv_definition = { "clAmdBlasZtpsv", (void**)&clAmdBlasZtpsv}; - -//openclamdblas_fn17(OPENCLAMDBLAS_FN_clAmdBlasZtrmm, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, clAmdBlasTranspose p4, clAmdBlasDiag p5, size_t p6, size_t p7, DoubleComplex p8, const cl_mem p9, size_t p10, cl_mem p11, size_t p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) -//clAmdBlasStatus (*clAmdBlasZtrmm)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, DoubleComplex, const cl_mem, size_t, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZtrmm_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZtrmm_definition = { "clAmdBlasZtrmm", (void**)&clAmdBlasZtrmm}; - -//openclamdblas_fn19(OPENCLAMDBLAS_FN_clAmdBlasZtrmmEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, clAmdBlasTranspose p4, clAmdBlasDiag p5, size_t p6, size_t p7, DoubleComplex p8, const cl_mem p9, size_t p10, size_t p11, cl_mem p12, size_t p13, size_t p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) -//clAmdBlasStatus (*clAmdBlasZtrmmEx)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, DoubleComplex, const cl_mem, size_t, size_t, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZtrmmEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZtrmmEx_definition = { "clAmdBlasZtrmmEx", (void**)&clAmdBlasZtrmmEx}; - -//openclamdblas_fn17(OPENCLAMDBLAS_FN_clAmdBlasZtrmv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, const cl_mem p6, size_t p7, size_t p8, cl_mem p9, size_t p10, int p11, cl_mem p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) -//clAmdBlasStatus (*clAmdBlasZtrmv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZtrmv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZtrmv_definition = { "clAmdBlasZtrmv", (void**)&clAmdBlasZtrmv}; - -//openclamdblas_fn17(OPENCLAMDBLAS_FN_clAmdBlasZtrsm, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, clAmdBlasTranspose p4, clAmdBlasDiag p5, size_t p6, size_t p7, DoubleComplex p8, const cl_mem p9, size_t p10, cl_mem p11, size_t p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) -//clAmdBlasStatus (*clAmdBlasZtrsm)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, DoubleComplex, const cl_mem, size_t, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZtrsm_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZtrsm_definition = { "clAmdBlasZtrsm", (void**)&clAmdBlasZtrsm}; - -//openclamdblas_fn19(OPENCLAMDBLAS_FN_clAmdBlasZtrsmEx, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasSide p2, clAmdBlasUplo p3, clAmdBlasTranspose p4, clAmdBlasDiag p5, size_t p6, size_t p7, DoubleComplex p8, const cl_mem p9, size_t p10, size_t p11, cl_mem p12, size_t p13, size_t p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) -//clAmdBlasStatus (*clAmdBlasZtrsmEx)(clAmdBlasOrder, clAmdBlasSide, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, size_t, DoubleComplex, const cl_mem, size_t, size_t, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZtrsmEx_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZtrsmEx_definition = { "clAmdBlasZtrsmEx", (void**)&clAmdBlasZtrsmEx}; - -//openclamdblas_fn16(OPENCLAMDBLAS_FN_clAmdBlasZtrsv, clAmdBlasStatus, (clAmdBlasOrder p1, clAmdBlasUplo p2, clAmdBlasTranspose p3, clAmdBlasDiag p4, size_t p5, const cl_mem p6, size_t p7, size_t p8, cl_mem p9, size_t p10, int p11, cl_uint p12, cl_command_queue* p13, cl_uint p14, const cl_event* p15, cl_event* p16)) -//clAmdBlasStatus (*clAmdBlasZtrsv)(clAmdBlasOrder, clAmdBlasUplo, clAmdBlasTranspose, clAmdBlasDiag, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasZtrsv_switch_fn; -//static const struct DynamicFnEntry clAmdBlasZtrsv_definition = { "clAmdBlasZtrsv", (void**)&clAmdBlasZtrsv}; - -//openclamdblas_fn12(OPENCLAMDBLAS_FN_clAmdBlasiCamax, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) -//clAmdBlasStatus (*clAmdBlasiCamax)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasiCamax_switch_fn; -//static const struct DynamicFnEntry clAmdBlasiCamax_definition = { "clAmdBlasiCamax", (void**)&clAmdBlasiCamax}; - -//openclamdblas_fn12(OPENCLAMDBLAS_FN_clAmdBlasiDamax, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) -//clAmdBlasStatus (*clAmdBlasiDamax)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasiDamax_switch_fn; -//static const struct DynamicFnEntry clAmdBlasiDamax_definition = { "clAmdBlasiDamax", (void**)&clAmdBlasiDamax}; - -//openclamdblas_fn12(OPENCLAMDBLAS_FN_clAmdBlasiSamax, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) -//clAmdBlasStatus (*clAmdBlasiSamax)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasiSamax_switch_fn; -//static const struct DynamicFnEntry clAmdBlasiSamax_definition = { "clAmdBlasiSamax", (void**)&clAmdBlasiSamax}; - -//openclamdblas_fn12(OPENCLAMDBLAS_FN_clAmdBlasiZamax, clAmdBlasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) -//clAmdBlasStatus (*clAmdBlasiZamax)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = -// OPENCLAMDBLAS_FN_clAmdBlasiZamax_switch_fn; -//static const struct DynamicFnEntry clAmdBlasiZamax_definition = { "clAmdBlasiZamax", (void**)&clAmdBlasiZamax}; - - -// generated by parser_clamdblas.py -static const struct DynamicFnEntry* openclamdblas_fn[] = { - NULL/*&clAmdBlasAddScratchImage_definition*/, - NULL/*&clAmdBlasCaxpy_definition*/, - NULL/*&clAmdBlasCcopy_definition*/, - NULL/*&clAmdBlasCdotc_definition*/, - NULL/*&clAmdBlasCdotu_definition*/, - NULL/*&clAmdBlasCgbmv_definition*/, - NULL/*&clAmdBlasCgemm_definition*/, - &clAmdBlasCgemmEx_definition, - NULL/*&clAmdBlasCgemv_definition*/, - NULL/*&clAmdBlasCgemvEx_definition*/, - NULL/*&clAmdBlasCgerc_definition*/, - NULL/*&clAmdBlasCgeru_definition*/, - NULL/*&clAmdBlasChbmv_definition*/, - NULL/*&clAmdBlasChemm_definition*/, - NULL/*&clAmdBlasChemv_definition*/, - NULL/*&clAmdBlasCher_definition*/, - NULL/*&clAmdBlasCher2_definition*/, - NULL/*&clAmdBlasCher2k_definition*/, - NULL/*&clAmdBlasCherk_definition*/, - NULL/*&clAmdBlasChpmv_definition*/, - NULL/*&clAmdBlasChpr_definition*/, - NULL/*&clAmdBlasChpr2_definition*/, - NULL/*&clAmdBlasCrotg_definition*/, - NULL/*&clAmdBlasCscal_definition*/, - NULL/*&clAmdBlasCsrot_definition*/, - NULL/*&clAmdBlasCsscal_definition*/, - NULL/*&clAmdBlasCswap_definition*/, - NULL/*&clAmdBlasCsymm_definition*/, - NULL/*&clAmdBlasCsyr2k_definition*/, - NULL/*&clAmdBlasCsyr2kEx_definition*/, - NULL/*&clAmdBlasCsyrk_definition*/, - NULL/*&clAmdBlasCsyrkEx_definition*/, - NULL/*&clAmdBlasCtbmv_definition*/, - NULL/*&clAmdBlasCtbsv_definition*/, - NULL/*&clAmdBlasCtpmv_definition*/, - NULL/*&clAmdBlasCtpsv_definition*/, - NULL/*&clAmdBlasCtrmm_definition*/, - NULL/*&clAmdBlasCtrmmEx_definition*/, - NULL/*&clAmdBlasCtrmv_definition*/, - NULL/*&clAmdBlasCtrsm_definition*/, - NULL/*&clAmdBlasCtrsmEx_definition*/, - NULL/*&clAmdBlasCtrsv_definition*/, - NULL/*&clAmdBlasDasum_definition*/, - NULL/*&clAmdBlasDaxpy_definition*/, - NULL/*&clAmdBlasDcopy_definition*/, - NULL/*&clAmdBlasDdot_definition*/, - NULL/*&clAmdBlasDgbmv_definition*/, - NULL/*&clAmdBlasDgemm_definition*/, - &clAmdBlasDgemmEx_definition, - NULL/*&clAmdBlasDgemv_definition*/, - NULL/*&clAmdBlasDgemvEx_definition*/, - NULL/*&clAmdBlasDger_definition*/, - NULL/*&clAmdBlasDnrm2_definition*/, - NULL/*&clAmdBlasDrot_definition*/, - NULL/*&clAmdBlasDrotg_definition*/, - NULL/*&clAmdBlasDrotm_definition*/, - NULL/*&clAmdBlasDrotmg_definition*/, - NULL/*&clAmdBlasDsbmv_definition*/, - NULL/*&clAmdBlasDscal_definition*/, - NULL/*&clAmdBlasDspmv_definition*/, - NULL/*&clAmdBlasDspr_definition*/, - NULL/*&clAmdBlasDspr2_definition*/, - NULL/*&clAmdBlasDswap_definition*/, - NULL/*&clAmdBlasDsymm_definition*/, - NULL/*&clAmdBlasDsymv_definition*/, - NULL/*&clAmdBlasDsymvEx_definition*/, - NULL/*&clAmdBlasDsyr_definition*/, - NULL/*&clAmdBlasDsyr2_definition*/, - NULL/*&clAmdBlasDsyr2k_definition*/, - NULL/*&clAmdBlasDsyr2kEx_definition*/, - NULL/*&clAmdBlasDsyrk_definition*/, - NULL/*&clAmdBlasDsyrkEx_definition*/, - NULL/*&clAmdBlasDtbmv_definition*/, - NULL/*&clAmdBlasDtbsv_definition*/, - NULL/*&clAmdBlasDtpmv_definition*/, - NULL/*&clAmdBlasDtpsv_definition*/, - NULL/*&clAmdBlasDtrmm_definition*/, - NULL/*&clAmdBlasDtrmmEx_definition*/, - NULL/*&clAmdBlasDtrmv_definition*/, - NULL/*&clAmdBlasDtrsm_definition*/, - NULL/*&clAmdBlasDtrsmEx_definition*/, - NULL/*&clAmdBlasDtrsv_definition*/, - NULL/*&clAmdBlasDzasum_definition*/, - NULL/*&clAmdBlasDznrm2_definition*/, - NULL/*&clAmdBlasGetVersion_definition*/, - NULL/*&clAmdBlasRemoveScratchImage_definition*/, - NULL/*&clAmdBlasSasum_definition*/, - NULL/*&clAmdBlasSaxpy_definition*/, - NULL/*&clAmdBlasScasum_definition*/, - NULL/*&clAmdBlasScnrm2_definition*/, - NULL/*&clAmdBlasScopy_definition*/, - NULL/*&clAmdBlasSdot_definition*/, - &clAmdBlasSetup_definition, - NULL/*&clAmdBlasSgbmv_definition*/, - NULL/*&clAmdBlasSgemm_definition*/, - &clAmdBlasSgemmEx_definition, - NULL/*&clAmdBlasSgemv_definition*/, - NULL/*&clAmdBlasSgemvEx_definition*/, - NULL/*&clAmdBlasSger_definition*/, - NULL/*&clAmdBlasSnrm2_definition*/, - NULL/*&clAmdBlasSrot_definition*/, - NULL/*&clAmdBlasSrotg_definition*/, - NULL/*&clAmdBlasSrotm_definition*/, - NULL/*&clAmdBlasSrotmg_definition*/, - NULL/*&clAmdBlasSsbmv_definition*/, - NULL/*&clAmdBlasSscal_definition*/, - NULL/*&clAmdBlasSspmv_definition*/, - NULL/*&clAmdBlasSspr_definition*/, - NULL/*&clAmdBlasSspr2_definition*/, - NULL/*&clAmdBlasSswap_definition*/, - NULL/*&clAmdBlasSsymm_definition*/, - NULL/*&clAmdBlasSsymv_definition*/, - NULL/*&clAmdBlasSsymvEx_definition*/, - NULL/*&clAmdBlasSsyr_definition*/, - NULL/*&clAmdBlasSsyr2_definition*/, - NULL/*&clAmdBlasSsyr2k_definition*/, - NULL/*&clAmdBlasSsyr2kEx_definition*/, - NULL/*&clAmdBlasSsyrk_definition*/, - NULL/*&clAmdBlasSsyrkEx_definition*/, - NULL/*&clAmdBlasStbmv_definition*/, - NULL/*&clAmdBlasStbsv_definition*/, - NULL/*&clAmdBlasStpmv_definition*/, - NULL/*&clAmdBlasStpsv_definition*/, - NULL/*&clAmdBlasStrmm_definition*/, - NULL/*&clAmdBlasStrmmEx_definition*/, - NULL/*&clAmdBlasStrmv_definition*/, - NULL/*&clAmdBlasStrsm_definition*/, - NULL/*&clAmdBlasStrsmEx_definition*/, - NULL/*&clAmdBlasStrsv_definition*/, - &clAmdBlasTeardown_definition, - NULL/*&clAmdBlasZaxpy_definition*/, - NULL/*&clAmdBlasZcopy_definition*/, - NULL/*&clAmdBlasZdotc_definition*/, - NULL/*&clAmdBlasZdotu_definition*/, - NULL/*&clAmdBlasZdrot_definition*/, - NULL/*&clAmdBlasZdscal_definition*/, - NULL/*&clAmdBlasZgbmv_definition*/, - NULL/*&clAmdBlasZgemm_definition*/, - &clAmdBlasZgemmEx_definition, - NULL/*&clAmdBlasZgemv_definition*/, - NULL/*&clAmdBlasZgemvEx_definition*/, - NULL/*&clAmdBlasZgerc_definition*/, - NULL/*&clAmdBlasZgeru_definition*/, - NULL/*&clAmdBlasZhbmv_definition*/, - NULL/*&clAmdBlasZhemm_definition*/, - NULL/*&clAmdBlasZhemv_definition*/, - NULL/*&clAmdBlasZher_definition*/, - NULL/*&clAmdBlasZher2_definition*/, - NULL/*&clAmdBlasZher2k_definition*/, - NULL/*&clAmdBlasZherk_definition*/, - NULL/*&clAmdBlasZhpmv_definition*/, - NULL/*&clAmdBlasZhpr_definition*/, - NULL/*&clAmdBlasZhpr2_definition*/, - NULL/*&clAmdBlasZrotg_definition*/, - NULL/*&clAmdBlasZscal_definition*/, - NULL/*&clAmdBlasZswap_definition*/, - NULL/*&clAmdBlasZsymm_definition*/, - NULL/*&clAmdBlasZsyr2k_definition*/, - NULL/*&clAmdBlasZsyr2kEx_definition*/, - NULL/*&clAmdBlasZsyrk_definition*/, - NULL/*&clAmdBlasZsyrkEx_definition*/, - NULL/*&clAmdBlasZtbmv_definition*/, - NULL/*&clAmdBlasZtbsv_definition*/, - NULL/*&clAmdBlasZtpmv_definition*/, - NULL/*&clAmdBlasZtpsv_definition*/, - NULL/*&clAmdBlasZtrmm_definition*/, - NULL/*&clAmdBlasZtrmmEx_definition*/, - NULL/*&clAmdBlasZtrmv_definition*/, - NULL/*&clAmdBlasZtrsm_definition*/, - NULL/*&clAmdBlasZtrsmEx_definition*/, - NULL/*&clAmdBlasZtrsv_definition*/, - NULL/*&clAmdBlasiCamax_definition*/, - NULL/*&clAmdBlasiDamax_definition*/, - NULL/*&clAmdBlasiSamax_definition*/, - NULL/*&clAmdBlasiZamax_definition*/, -}; - -// number of enabled functions: 6 diff --git a/modules/core/src/opencl/runtime/autogenerated/opencl_clamdfft_impl.hpp b/modules/core/src/opencl/runtime/autogenerated/opencl_clamdfft_impl.hpp deleted file mode 100644 index 66532101c6..0000000000 --- a/modules/core/src/opencl/runtime/autogenerated/opencl_clamdfft_impl.hpp +++ /dev/null @@ -1,357 +0,0 @@ -// -// AUTOGENERATED, DO NOT EDIT -// -// generated by parser_clamdfft.py -enum OPENCLAMDFFT_FN_ID { - OPENCLAMDFFT_FN_clAmdFftBakePlan = 0, -// OPENCLAMDFFT_FN_clAmdFftCopyPlan = 1, - OPENCLAMDFFT_FN_clAmdFftCreateDefaultPlan = 2, - OPENCLAMDFFT_FN_clAmdFftDestroyPlan = 3, - OPENCLAMDFFT_FN_clAmdFftEnqueueTransform = 4, -// OPENCLAMDFFT_FN_clAmdFftGetLayout = 5, -// OPENCLAMDFFT_FN_clAmdFftGetPlanBatchSize = 6, -// OPENCLAMDFFT_FN_clAmdFftGetPlanContext = 7, -// OPENCLAMDFFT_FN_clAmdFftGetPlanDim = 8, -// OPENCLAMDFFT_FN_clAmdFftGetPlanDistance = 9, -// OPENCLAMDFFT_FN_clAmdFftGetPlanInStride = 10, -// OPENCLAMDFFT_FN_clAmdFftGetPlanLength = 11, -// OPENCLAMDFFT_FN_clAmdFftGetPlanOutStride = 12, -// OPENCLAMDFFT_FN_clAmdFftGetPlanPrecision = 13, -// OPENCLAMDFFT_FN_clAmdFftGetPlanScale = 14, -// OPENCLAMDFFT_FN_clAmdFftGetPlanTransposeResult = 15, -// OPENCLAMDFFT_FN_clAmdFftGetResultLocation = 16, - OPENCLAMDFFT_FN_clAmdFftGetTmpBufSize = 17, - OPENCLAMDFFT_FN_clAmdFftGetVersion = 18, - OPENCLAMDFFT_FN_clAmdFftSetLayout = 19, - OPENCLAMDFFT_FN_clAmdFftSetPlanBatchSize = 20, -// OPENCLAMDFFT_FN_clAmdFftSetPlanDim = 21, - OPENCLAMDFFT_FN_clAmdFftSetPlanDistance = 22, - OPENCLAMDFFT_FN_clAmdFftSetPlanInStride = 23, -// OPENCLAMDFFT_FN_clAmdFftSetPlanLength = 24, - OPENCLAMDFFT_FN_clAmdFftSetPlanOutStride = 25, - OPENCLAMDFFT_FN_clAmdFftSetPlanPrecision = 26, - OPENCLAMDFFT_FN_clAmdFftSetPlanScale = 27, -// OPENCLAMDFFT_FN_clAmdFftSetPlanTransposeResult = 28, - OPENCLAMDFFT_FN_clAmdFftSetResultLocation = 29, - OPENCLAMDFFT_FN_clAmdFftSetup = 30, - OPENCLAMDFFT_FN_clAmdFftTeardown = 31, -}; - -namespace { -// generated by parser_clamdfft.py -#define openclamdfft_fn0(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(); } \ - -#define openclamdfft_fn1(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1); } \ - -#define openclamdfft_fn2(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2); } \ - -#define openclamdfft_fn3(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3); } \ - -#define openclamdfft_fn4(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4); } \ - -#define openclamdfft_fn5(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5); } \ - -#define openclamdfft_fn6(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6); } \ - -#define openclamdfft_fn7(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7); } \ - -#define openclamdfft_fn8(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8); } \ - -#define openclamdfft_fn9(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9); } \ - -#define openclamdfft_fn10(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); } \ - -#define openclamdfft_fn11(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); } \ - -#define openclamdfft_fn12(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); } \ - -#define openclamdfft_fn13(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); } \ - -#define openclamdfft_fn14(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); } \ - -#define openclamdfft_fn15(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); } \ - -#define openclamdfft_fn16(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); } \ - -#define openclamdfft_fn17(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17); } \ - -#define openclamdfft_fn18(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18); } \ - -#define openclamdfft_fn19(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19); } \ - -#define openclamdfft_fn20(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20); } \ - -#define openclamdfft_fn21(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21); } \ - -#define openclamdfft_fn22(ID, _R, decl_args) \ - typedef _R (*ID##FN)decl_args; \ - static _R ID##_switch_fn decl_args \ - { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22); } \ - -} - -// generated by parser_clamdfft.py -openclamdfft_fn5(OPENCLAMDFFT_FN_clAmdFftBakePlan, clAmdFftStatus, (clAmdFftPlanHandle p1, cl_uint p2, cl_command_queue* p3, void (CL_CALLBACK*p4) (clAmdFftPlanHandle plHandle, void* user_data), void* p5)) -clAmdFftStatus (*clAmdFftBakePlan)(clAmdFftPlanHandle, cl_uint, cl_command_queue*, void (CL_CALLBACK*) (clAmdFftPlanHandle plHandle, void* user_data), void*) = - OPENCLAMDFFT_FN_clAmdFftBakePlan_switch_fn; -static const struct DynamicFnEntry clAmdFftBakePlan_definition = { "clAmdFftBakePlan", (void**)&clAmdFftBakePlan}; - -//openclamdfft_fn3(OPENCLAMDFFT_FN_clAmdFftCopyPlan, clAmdFftStatus, (clAmdFftPlanHandle* p1, cl_context p2, clAmdFftPlanHandle p3)) -//clAmdFftStatus (*clAmdFftCopyPlan)(clAmdFftPlanHandle*, cl_context, clAmdFftPlanHandle) = -// OPENCLAMDFFT_FN_clAmdFftCopyPlan_switch_fn; -//static const struct DynamicFnEntry clAmdFftCopyPlan_definition = { "clAmdFftCopyPlan", (void**)&clAmdFftCopyPlan}; - -openclamdfft_fn4(OPENCLAMDFFT_FN_clAmdFftCreateDefaultPlan, clAmdFftStatus, (clAmdFftPlanHandle* p1, cl_context p2, const clAmdFftDim p3, const size_t* p4)) -clAmdFftStatus (*clAmdFftCreateDefaultPlan)(clAmdFftPlanHandle*, cl_context, const clAmdFftDim, const size_t*) = - OPENCLAMDFFT_FN_clAmdFftCreateDefaultPlan_switch_fn; -static const struct DynamicFnEntry clAmdFftCreateDefaultPlan_definition = { "clAmdFftCreateDefaultPlan", (void**)&clAmdFftCreateDefaultPlan}; - -openclamdfft_fn1(OPENCLAMDFFT_FN_clAmdFftDestroyPlan, clAmdFftStatus, (clAmdFftPlanHandle* p1)) -clAmdFftStatus (*clAmdFftDestroyPlan)(clAmdFftPlanHandle*) = - OPENCLAMDFFT_FN_clAmdFftDestroyPlan_switch_fn; -static const struct DynamicFnEntry clAmdFftDestroyPlan_definition = { "clAmdFftDestroyPlan", (void**)&clAmdFftDestroyPlan}; - -openclamdfft_fn10(OPENCLAMDFFT_FN_clAmdFftEnqueueTransform, clAmdFftStatus, (clAmdFftPlanHandle p1, clAmdFftDirection p2, cl_uint p3, cl_command_queue* p4, cl_uint p5, const cl_event* p6, cl_event* p7, cl_mem* p8, cl_mem* p9, cl_mem p10)) -clAmdFftStatus (*clAmdFftEnqueueTransform)(clAmdFftPlanHandle, clAmdFftDirection, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*, cl_mem*, cl_mem*, cl_mem) = - OPENCLAMDFFT_FN_clAmdFftEnqueueTransform_switch_fn; -static const struct DynamicFnEntry clAmdFftEnqueueTransform_definition = { "clAmdFftEnqueueTransform", (void**)&clAmdFftEnqueueTransform}; - -//openclamdfft_fn3(OPENCLAMDFFT_FN_clAmdFftGetLayout, clAmdFftStatus, (const clAmdFftPlanHandle p1, clAmdFftLayout* p2, clAmdFftLayout* p3)) -//clAmdFftStatus (*clAmdFftGetLayout)(const clAmdFftPlanHandle, clAmdFftLayout*, clAmdFftLayout*) = -// OPENCLAMDFFT_FN_clAmdFftGetLayout_switch_fn; -//static const struct DynamicFnEntry clAmdFftGetLayout_definition = { "clAmdFftGetLayout", (void**)&clAmdFftGetLayout}; - -//openclamdfft_fn2(OPENCLAMDFFT_FN_clAmdFftGetPlanBatchSize, clAmdFftStatus, (const clAmdFftPlanHandle p1, size_t* p2)) -//clAmdFftStatus (*clAmdFftGetPlanBatchSize)(const clAmdFftPlanHandle, size_t*) = -// OPENCLAMDFFT_FN_clAmdFftGetPlanBatchSize_switch_fn; -//static const struct DynamicFnEntry clAmdFftGetPlanBatchSize_definition = { "clAmdFftGetPlanBatchSize", (void**)&clAmdFftGetPlanBatchSize}; - -//openclamdfft_fn2(OPENCLAMDFFT_FN_clAmdFftGetPlanContext, clAmdFftStatus, (const clAmdFftPlanHandle p1, cl_context* p2)) -//clAmdFftStatus (*clAmdFftGetPlanContext)(const clAmdFftPlanHandle, cl_context*) = -// OPENCLAMDFFT_FN_clAmdFftGetPlanContext_switch_fn; -//static const struct DynamicFnEntry clAmdFftGetPlanContext_definition = { "clAmdFftGetPlanContext", (void**)&clAmdFftGetPlanContext}; - -//openclamdfft_fn3(OPENCLAMDFFT_FN_clAmdFftGetPlanDim, clAmdFftStatus, (const clAmdFftPlanHandle p1, clAmdFftDim* p2, cl_uint* p3)) -//clAmdFftStatus (*clAmdFftGetPlanDim)(const clAmdFftPlanHandle, clAmdFftDim*, cl_uint*) = -// OPENCLAMDFFT_FN_clAmdFftGetPlanDim_switch_fn; -//static const struct DynamicFnEntry clAmdFftGetPlanDim_definition = { "clAmdFftGetPlanDim", (void**)&clAmdFftGetPlanDim}; - -//openclamdfft_fn3(OPENCLAMDFFT_FN_clAmdFftGetPlanDistance, clAmdFftStatus, (const clAmdFftPlanHandle p1, size_t* p2, size_t* p3)) -//clAmdFftStatus (*clAmdFftGetPlanDistance)(const clAmdFftPlanHandle, size_t*, size_t*) = -// OPENCLAMDFFT_FN_clAmdFftGetPlanDistance_switch_fn; -//static const struct DynamicFnEntry clAmdFftGetPlanDistance_definition = { "clAmdFftGetPlanDistance", (void**)&clAmdFftGetPlanDistance}; - -//openclamdfft_fn3(OPENCLAMDFFT_FN_clAmdFftGetPlanInStride, clAmdFftStatus, (const clAmdFftPlanHandle p1, const clAmdFftDim p2, size_t* p3)) -//clAmdFftStatus (*clAmdFftGetPlanInStride)(const clAmdFftPlanHandle, const clAmdFftDim, size_t*) = -// OPENCLAMDFFT_FN_clAmdFftGetPlanInStride_switch_fn; -//static const struct DynamicFnEntry clAmdFftGetPlanInStride_definition = { "clAmdFftGetPlanInStride", (void**)&clAmdFftGetPlanInStride}; - -//openclamdfft_fn3(OPENCLAMDFFT_FN_clAmdFftGetPlanLength, clAmdFftStatus, (const clAmdFftPlanHandle p1, const clAmdFftDim p2, size_t* p3)) -//clAmdFftStatus (*clAmdFftGetPlanLength)(const clAmdFftPlanHandle, const clAmdFftDim, size_t*) = -// OPENCLAMDFFT_FN_clAmdFftGetPlanLength_switch_fn; -//static const struct DynamicFnEntry clAmdFftGetPlanLength_definition = { "clAmdFftGetPlanLength", (void**)&clAmdFftGetPlanLength}; - -//openclamdfft_fn3(OPENCLAMDFFT_FN_clAmdFftGetPlanOutStride, clAmdFftStatus, (const clAmdFftPlanHandle p1, const clAmdFftDim p2, size_t* p3)) -//clAmdFftStatus (*clAmdFftGetPlanOutStride)(const clAmdFftPlanHandle, const clAmdFftDim, size_t*) = -// OPENCLAMDFFT_FN_clAmdFftGetPlanOutStride_switch_fn; -//static const struct DynamicFnEntry clAmdFftGetPlanOutStride_definition = { "clAmdFftGetPlanOutStride", (void**)&clAmdFftGetPlanOutStride}; - -//openclamdfft_fn2(OPENCLAMDFFT_FN_clAmdFftGetPlanPrecision, clAmdFftStatus, (const clAmdFftPlanHandle p1, clAmdFftPrecision* p2)) -//clAmdFftStatus (*clAmdFftGetPlanPrecision)(const clAmdFftPlanHandle, clAmdFftPrecision*) = -// OPENCLAMDFFT_FN_clAmdFftGetPlanPrecision_switch_fn; -//static const struct DynamicFnEntry clAmdFftGetPlanPrecision_definition = { "clAmdFftGetPlanPrecision", (void**)&clAmdFftGetPlanPrecision}; - -//openclamdfft_fn3(OPENCLAMDFFT_FN_clAmdFftGetPlanScale, clAmdFftStatus, (const clAmdFftPlanHandle p1, clAmdFftDirection p2, cl_float* p3)) -//clAmdFftStatus (*clAmdFftGetPlanScale)(const clAmdFftPlanHandle, clAmdFftDirection, cl_float*) = -// OPENCLAMDFFT_FN_clAmdFftGetPlanScale_switch_fn; -//static const struct DynamicFnEntry clAmdFftGetPlanScale_definition = { "clAmdFftGetPlanScale", (void**)&clAmdFftGetPlanScale}; - -//openclamdfft_fn2(OPENCLAMDFFT_FN_clAmdFftGetPlanTransposeResult, clAmdFftStatus, (const clAmdFftPlanHandle p1, clAmdFftResultTransposed* p2)) -//clAmdFftStatus (*clAmdFftGetPlanTransposeResult)(const clAmdFftPlanHandle, clAmdFftResultTransposed*) = -// OPENCLAMDFFT_FN_clAmdFftGetPlanTransposeResult_switch_fn; -//static const struct DynamicFnEntry clAmdFftGetPlanTransposeResult_definition = { "clAmdFftGetPlanTransposeResult", (void**)&clAmdFftGetPlanTransposeResult}; - -//openclamdfft_fn2(OPENCLAMDFFT_FN_clAmdFftGetResultLocation, clAmdFftStatus, (const clAmdFftPlanHandle p1, clAmdFftResultLocation* p2)) -//clAmdFftStatus (*clAmdFftGetResultLocation)(const clAmdFftPlanHandle, clAmdFftResultLocation*) = -// OPENCLAMDFFT_FN_clAmdFftGetResultLocation_switch_fn; -//static const struct DynamicFnEntry clAmdFftGetResultLocation_definition = { "clAmdFftGetResultLocation", (void**)&clAmdFftGetResultLocation}; - -openclamdfft_fn2(OPENCLAMDFFT_FN_clAmdFftGetTmpBufSize, clAmdFftStatus, (const clAmdFftPlanHandle p1, size_t* p2)) -clAmdFftStatus (*clAmdFftGetTmpBufSize)(const clAmdFftPlanHandle, size_t*) = - OPENCLAMDFFT_FN_clAmdFftGetTmpBufSize_switch_fn; -static const struct DynamicFnEntry clAmdFftGetTmpBufSize_definition = { "clAmdFftGetTmpBufSize", (void**)&clAmdFftGetTmpBufSize}; - -openclamdfft_fn3(OPENCLAMDFFT_FN_clAmdFftGetVersion, clAmdFftStatus, (cl_uint* p1, cl_uint* p2, cl_uint* p3)) -clAmdFftStatus (*clAmdFftGetVersion)(cl_uint*, cl_uint*, cl_uint*) = - OPENCLAMDFFT_FN_clAmdFftGetVersion_switch_fn; -static const struct DynamicFnEntry clAmdFftGetVersion_definition = { "clAmdFftGetVersion", (void**)&clAmdFftGetVersion}; - -openclamdfft_fn3(OPENCLAMDFFT_FN_clAmdFftSetLayout, clAmdFftStatus, (clAmdFftPlanHandle p1, clAmdFftLayout p2, clAmdFftLayout p3)) -clAmdFftStatus (*clAmdFftSetLayout)(clAmdFftPlanHandle, clAmdFftLayout, clAmdFftLayout) = - OPENCLAMDFFT_FN_clAmdFftSetLayout_switch_fn; -static const struct DynamicFnEntry clAmdFftSetLayout_definition = { "clAmdFftSetLayout", (void**)&clAmdFftSetLayout}; - -openclamdfft_fn2(OPENCLAMDFFT_FN_clAmdFftSetPlanBatchSize, clAmdFftStatus, (clAmdFftPlanHandle p1, size_t p2)) -clAmdFftStatus (*clAmdFftSetPlanBatchSize)(clAmdFftPlanHandle, size_t) = - OPENCLAMDFFT_FN_clAmdFftSetPlanBatchSize_switch_fn; -static const struct DynamicFnEntry clAmdFftSetPlanBatchSize_definition = { "clAmdFftSetPlanBatchSize", (void**)&clAmdFftSetPlanBatchSize}; - -//openclamdfft_fn2(OPENCLAMDFFT_FN_clAmdFftSetPlanDim, clAmdFftStatus, (clAmdFftPlanHandle p1, const clAmdFftDim p2)) -//clAmdFftStatus (*clAmdFftSetPlanDim)(clAmdFftPlanHandle, const clAmdFftDim) = -// OPENCLAMDFFT_FN_clAmdFftSetPlanDim_switch_fn; -//static const struct DynamicFnEntry clAmdFftSetPlanDim_definition = { "clAmdFftSetPlanDim", (void**)&clAmdFftSetPlanDim}; - -openclamdfft_fn3(OPENCLAMDFFT_FN_clAmdFftSetPlanDistance, clAmdFftStatus, (clAmdFftPlanHandle p1, size_t p2, size_t p3)) -clAmdFftStatus (*clAmdFftSetPlanDistance)(clAmdFftPlanHandle, size_t, size_t) = - OPENCLAMDFFT_FN_clAmdFftSetPlanDistance_switch_fn; -static const struct DynamicFnEntry clAmdFftSetPlanDistance_definition = { "clAmdFftSetPlanDistance", (void**)&clAmdFftSetPlanDistance}; - -openclamdfft_fn3(OPENCLAMDFFT_FN_clAmdFftSetPlanInStride, clAmdFftStatus, (clAmdFftPlanHandle p1, const clAmdFftDim p2, size_t* p3)) -clAmdFftStatus (*clAmdFftSetPlanInStride)(clAmdFftPlanHandle, const clAmdFftDim, size_t*) = - OPENCLAMDFFT_FN_clAmdFftSetPlanInStride_switch_fn; -static const struct DynamicFnEntry clAmdFftSetPlanInStride_definition = { "clAmdFftSetPlanInStride", (void**)&clAmdFftSetPlanInStride}; - -//openclamdfft_fn3(OPENCLAMDFFT_FN_clAmdFftSetPlanLength, clAmdFftStatus, (clAmdFftPlanHandle p1, const clAmdFftDim p2, const size_t* p3)) -//clAmdFftStatus (*clAmdFftSetPlanLength)(clAmdFftPlanHandle, const clAmdFftDim, const size_t*) = -// OPENCLAMDFFT_FN_clAmdFftSetPlanLength_switch_fn; -//static const struct DynamicFnEntry clAmdFftSetPlanLength_definition = { "clAmdFftSetPlanLength", (void**)&clAmdFftSetPlanLength}; - -openclamdfft_fn3(OPENCLAMDFFT_FN_clAmdFftSetPlanOutStride, clAmdFftStatus, (clAmdFftPlanHandle p1, const clAmdFftDim p2, size_t* p3)) -clAmdFftStatus (*clAmdFftSetPlanOutStride)(clAmdFftPlanHandle, const clAmdFftDim, size_t*) = - OPENCLAMDFFT_FN_clAmdFftSetPlanOutStride_switch_fn; -static const struct DynamicFnEntry clAmdFftSetPlanOutStride_definition = { "clAmdFftSetPlanOutStride", (void**)&clAmdFftSetPlanOutStride}; - -openclamdfft_fn2(OPENCLAMDFFT_FN_clAmdFftSetPlanPrecision, clAmdFftStatus, (clAmdFftPlanHandle p1, clAmdFftPrecision p2)) -clAmdFftStatus (*clAmdFftSetPlanPrecision)(clAmdFftPlanHandle, clAmdFftPrecision) = - OPENCLAMDFFT_FN_clAmdFftSetPlanPrecision_switch_fn; -static const struct DynamicFnEntry clAmdFftSetPlanPrecision_definition = { "clAmdFftSetPlanPrecision", (void**)&clAmdFftSetPlanPrecision}; - -openclamdfft_fn3(OPENCLAMDFFT_FN_clAmdFftSetPlanScale, clAmdFftStatus, (clAmdFftPlanHandle p1, clAmdFftDirection p2, cl_float p3)) -clAmdFftStatus (*clAmdFftSetPlanScale)(clAmdFftPlanHandle, clAmdFftDirection, cl_float) = - OPENCLAMDFFT_FN_clAmdFftSetPlanScale_switch_fn; -static const struct DynamicFnEntry clAmdFftSetPlanScale_definition = { "clAmdFftSetPlanScale", (void**)&clAmdFftSetPlanScale}; - -//openclamdfft_fn2(OPENCLAMDFFT_FN_clAmdFftSetPlanTransposeResult, clAmdFftStatus, (clAmdFftPlanHandle p1, clAmdFftResultTransposed p2)) -//clAmdFftStatus (*clAmdFftSetPlanTransposeResult)(clAmdFftPlanHandle, clAmdFftResultTransposed) = -// OPENCLAMDFFT_FN_clAmdFftSetPlanTransposeResult_switch_fn; -//static const struct DynamicFnEntry clAmdFftSetPlanTransposeResult_definition = { "clAmdFftSetPlanTransposeResult", (void**)&clAmdFftSetPlanTransposeResult}; - -openclamdfft_fn2(OPENCLAMDFFT_FN_clAmdFftSetResultLocation, clAmdFftStatus, (clAmdFftPlanHandle p1, clAmdFftResultLocation p2)) -clAmdFftStatus (*clAmdFftSetResultLocation)(clAmdFftPlanHandle, clAmdFftResultLocation) = - OPENCLAMDFFT_FN_clAmdFftSetResultLocation_switch_fn; -static const struct DynamicFnEntry clAmdFftSetResultLocation_definition = { "clAmdFftSetResultLocation", (void**)&clAmdFftSetResultLocation}; - -openclamdfft_fn1(OPENCLAMDFFT_FN_clAmdFftSetup, clAmdFftStatus, (const clAmdFftSetupData* p1)) -clAmdFftStatus (*clAmdFftSetup)(const clAmdFftSetupData*) = - OPENCLAMDFFT_FN_clAmdFftSetup_switch_fn; -static const struct DynamicFnEntry clAmdFftSetup_definition = { "clAmdFftSetup", (void**)&clAmdFftSetup}; - -openclamdfft_fn0(OPENCLAMDFFT_FN_clAmdFftTeardown, clAmdFftStatus, ()) -clAmdFftStatus (*clAmdFftTeardown)() = - OPENCLAMDFFT_FN_clAmdFftTeardown_switch_fn; -static const struct DynamicFnEntry clAmdFftTeardown_definition = { "clAmdFftTeardown", (void**)&clAmdFftTeardown}; - - -// generated by parser_clamdfft.py -static const struct DynamicFnEntry* openclamdfft_fn[] = { - &clAmdFftBakePlan_definition, - NULL/*&clAmdFftCopyPlan_definition*/, - &clAmdFftCreateDefaultPlan_definition, - &clAmdFftDestroyPlan_definition, - &clAmdFftEnqueueTransform_definition, - NULL/*&clAmdFftGetLayout_definition*/, - NULL/*&clAmdFftGetPlanBatchSize_definition*/, - NULL/*&clAmdFftGetPlanContext_definition*/, - NULL/*&clAmdFftGetPlanDim_definition*/, - NULL/*&clAmdFftGetPlanDistance_definition*/, - NULL/*&clAmdFftGetPlanInStride_definition*/, - NULL/*&clAmdFftGetPlanLength_definition*/, - NULL/*&clAmdFftGetPlanOutStride_definition*/, - NULL/*&clAmdFftGetPlanPrecision_definition*/, - NULL/*&clAmdFftGetPlanScale_definition*/, - NULL/*&clAmdFftGetPlanTransposeResult_definition*/, - NULL/*&clAmdFftGetResultLocation_definition*/, - &clAmdFftGetTmpBufSize_definition, - &clAmdFftGetVersion_definition, - &clAmdFftSetLayout_definition, - &clAmdFftSetPlanBatchSize_definition, - NULL/*&clAmdFftSetPlanDim_definition*/, - &clAmdFftSetPlanDistance_definition, - &clAmdFftSetPlanInStride_definition, - NULL/*&clAmdFftSetPlanLength_definition*/, - &clAmdFftSetPlanOutStride_definition, - &clAmdFftSetPlanPrecision_definition, - &clAmdFftSetPlanScale_definition, - NULL/*&clAmdFftSetPlanTransposeResult_definition*/, - &clAmdFftSetResultLocation_definition, - &clAmdFftSetup_definition, - &clAmdFftTeardown_definition, -}; - -// number of enabled functions: 16 diff --git a/modules/core/src/opencl/runtime/autogenerated/opencl_clblas_impl.hpp b/modules/core/src/opencl/runtime/autogenerated/opencl_clblas_impl.hpp new file mode 100644 index 0000000000..57b52fcf07 --- /dev/null +++ b/modules/core/src/opencl/runtime/autogenerated/opencl_clblas_impl.hpp @@ -0,0 +1,1162 @@ +// +// AUTOGENERATED, DO NOT EDIT +// +// generated by parser_clblas.py +enum OPENCLAMDBLAS_FN_ID { +// OPENCLAMDBLAS_FN_clblasCaxpy = 0, +// OPENCLAMDBLAS_FN_clblasCcopy = 1, +// OPENCLAMDBLAS_FN_clblasCdotc = 2, +// OPENCLAMDBLAS_FN_clblasCdotu = 3, +// OPENCLAMDBLAS_FN_clblasCgbmv = 4, + OPENCLAMDBLAS_FN_clblasCgemm = 5, +// OPENCLAMDBLAS_FN_clblasCgemv = 6, +// OPENCLAMDBLAS_FN_clblasCgerc = 7, +// OPENCLAMDBLAS_FN_clblasCgeru = 8, +// OPENCLAMDBLAS_FN_clblasChbmv = 9, +// OPENCLAMDBLAS_FN_clblasChemm = 10, +// OPENCLAMDBLAS_FN_clblasChemv = 11, +// OPENCLAMDBLAS_FN_clblasCher = 12, +// OPENCLAMDBLAS_FN_clblasCher2 = 13, +// OPENCLAMDBLAS_FN_clblasCher2k = 14, +// OPENCLAMDBLAS_FN_clblasCherk = 15, +// OPENCLAMDBLAS_FN_clblasChpmv = 16, +// OPENCLAMDBLAS_FN_clblasChpr = 17, +// OPENCLAMDBLAS_FN_clblasChpr2 = 18, +// OPENCLAMDBLAS_FN_clblasCrotg = 19, +// OPENCLAMDBLAS_FN_clblasCscal = 20, +// OPENCLAMDBLAS_FN_clblasCsrot = 21, +// OPENCLAMDBLAS_FN_clblasCsscal = 22, +// OPENCLAMDBLAS_FN_clblasCswap = 23, +// OPENCLAMDBLAS_FN_clblasCsymm = 24, +// OPENCLAMDBLAS_FN_clblasCsyr2k = 25, +// OPENCLAMDBLAS_FN_clblasCsyrk = 26, +// OPENCLAMDBLAS_FN_clblasCtbmv = 27, +// OPENCLAMDBLAS_FN_clblasCtbsv = 28, +// OPENCLAMDBLAS_FN_clblasCtpmv = 29, +// OPENCLAMDBLAS_FN_clblasCtpsv = 30, +// OPENCLAMDBLAS_FN_clblasCtrmm = 31, +// OPENCLAMDBLAS_FN_clblasCtrmv = 32, +// OPENCLAMDBLAS_FN_clblasCtrsm = 33, +// OPENCLAMDBLAS_FN_clblasCtrsv = 34, +// OPENCLAMDBLAS_FN_clblasDasum = 35, +// OPENCLAMDBLAS_FN_clblasDaxpy = 36, +// OPENCLAMDBLAS_FN_clblasDcopy = 37, +// OPENCLAMDBLAS_FN_clblasDdot = 38, +// OPENCLAMDBLAS_FN_clblasDgbmv = 39, + OPENCLAMDBLAS_FN_clblasDgemm = 40, +// OPENCLAMDBLAS_FN_clblasDgemv = 41, +// OPENCLAMDBLAS_FN_clblasDger = 42, +// OPENCLAMDBLAS_FN_clblasDnrm2 = 43, +// OPENCLAMDBLAS_FN_clblasDrot = 44, +// OPENCLAMDBLAS_FN_clblasDrotg = 45, +// OPENCLAMDBLAS_FN_clblasDrotm = 46, +// OPENCLAMDBLAS_FN_clblasDrotmg = 47, +// OPENCLAMDBLAS_FN_clblasDsbmv = 48, +// OPENCLAMDBLAS_FN_clblasDscal = 49, +// OPENCLAMDBLAS_FN_clblasDspmv = 50, +// OPENCLAMDBLAS_FN_clblasDspr = 51, +// OPENCLAMDBLAS_FN_clblasDspr2 = 52, +// OPENCLAMDBLAS_FN_clblasDswap = 53, +// OPENCLAMDBLAS_FN_clblasDsymm = 54, +// OPENCLAMDBLAS_FN_clblasDsymv = 55, +// OPENCLAMDBLAS_FN_clblasDsyr = 56, +// OPENCLAMDBLAS_FN_clblasDsyr2 = 57, +// OPENCLAMDBLAS_FN_clblasDsyr2k = 58, +// OPENCLAMDBLAS_FN_clblasDsyrk = 59, +// OPENCLAMDBLAS_FN_clblasDtbmv = 60, +// OPENCLAMDBLAS_FN_clblasDtbsv = 61, +// OPENCLAMDBLAS_FN_clblasDtpmv = 62, +// OPENCLAMDBLAS_FN_clblasDtpsv = 63, +// OPENCLAMDBLAS_FN_clblasDtrmm = 64, +// OPENCLAMDBLAS_FN_clblasDtrmv = 65, +// OPENCLAMDBLAS_FN_clblasDtrsm = 66, +// OPENCLAMDBLAS_FN_clblasDtrsv = 67, +// OPENCLAMDBLAS_FN_clblasDzasum = 68, +// OPENCLAMDBLAS_FN_clblasDznrm2 = 69, +// OPENCLAMDBLAS_FN_clblasGetVersion = 70, +// OPENCLAMDBLAS_FN_clblasSasum = 71, +// OPENCLAMDBLAS_FN_clblasSaxpy = 72, +// OPENCLAMDBLAS_FN_clblasScasum = 73, +// OPENCLAMDBLAS_FN_clblasScnrm2 = 74, +// OPENCLAMDBLAS_FN_clblasScopy = 75, +// OPENCLAMDBLAS_FN_clblasSdot = 76, + OPENCLAMDBLAS_FN_clblasSetup = 77, +// OPENCLAMDBLAS_FN_clblasSgbmv = 78, + OPENCLAMDBLAS_FN_clblasSgemm = 79, +// OPENCLAMDBLAS_FN_clblasSgemv = 80, +// OPENCLAMDBLAS_FN_clblasSger = 81, +// OPENCLAMDBLAS_FN_clblasSnrm2 = 82, +// OPENCLAMDBLAS_FN_clblasSrot = 83, +// OPENCLAMDBLAS_FN_clblasSrotg = 84, +// OPENCLAMDBLAS_FN_clblasSrotm = 85, +// OPENCLAMDBLAS_FN_clblasSrotmg = 86, +// OPENCLAMDBLAS_FN_clblasSsbmv = 87, +// OPENCLAMDBLAS_FN_clblasSscal = 88, +// OPENCLAMDBLAS_FN_clblasSspmv = 89, +// OPENCLAMDBLAS_FN_clblasSspr = 90, +// OPENCLAMDBLAS_FN_clblasSspr2 = 91, +// OPENCLAMDBLAS_FN_clblasSswap = 92, +// OPENCLAMDBLAS_FN_clblasSsymm = 93, +// OPENCLAMDBLAS_FN_clblasSsymv = 94, +// OPENCLAMDBLAS_FN_clblasSsyr = 95, +// OPENCLAMDBLAS_FN_clblasSsyr2 = 96, +// OPENCLAMDBLAS_FN_clblasSsyr2k = 97, +// OPENCLAMDBLAS_FN_clblasSsyrk = 98, +// OPENCLAMDBLAS_FN_clblasStbmv = 99, +// OPENCLAMDBLAS_FN_clblasStbsv = 100, +// OPENCLAMDBLAS_FN_clblasStpmv = 101, +// OPENCLAMDBLAS_FN_clblasStpsv = 102, +// OPENCLAMDBLAS_FN_clblasStrmm = 103, +// OPENCLAMDBLAS_FN_clblasStrmv = 104, +// OPENCLAMDBLAS_FN_clblasStrsm = 105, +// OPENCLAMDBLAS_FN_clblasStrsv = 106, + OPENCLAMDBLAS_FN_clblasTeardown = 107, +// OPENCLAMDBLAS_FN_clblasZaxpy = 108, +// OPENCLAMDBLAS_FN_clblasZcopy = 109, +// OPENCLAMDBLAS_FN_clblasZdotc = 110, +// OPENCLAMDBLAS_FN_clblasZdotu = 111, +// OPENCLAMDBLAS_FN_clblasZdrot = 112, +// OPENCLAMDBLAS_FN_clblasZdscal = 113, +// OPENCLAMDBLAS_FN_clblasZgbmv = 114, + OPENCLAMDBLAS_FN_clblasZgemm = 115, +// OPENCLAMDBLAS_FN_clblasZgemv = 116, +// OPENCLAMDBLAS_FN_clblasZgerc = 117, +// OPENCLAMDBLAS_FN_clblasZgeru = 118, +// OPENCLAMDBLAS_FN_clblasZhbmv = 119, +// OPENCLAMDBLAS_FN_clblasZhemm = 120, +// OPENCLAMDBLAS_FN_clblasZhemv = 121, +// OPENCLAMDBLAS_FN_clblasZher = 122, +// OPENCLAMDBLAS_FN_clblasZher2 = 123, +// OPENCLAMDBLAS_FN_clblasZher2k = 124, +// OPENCLAMDBLAS_FN_clblasZherk = 125, +// OPENCLAMDBLAS_FN_clblasZhpmv = 126, +// OPENCLAMDBLAS_FN_clblasZhpr = 127, +// OPENCLAMDBLAS_FN_clblasZhpr2 = 128, +// OPENCLAMDBLAS_FN_clblasZrotg = 129, +// OPENCLAMDBLAS_FN_clblasZscal = 130, +// OPENCLAMDBLAS_FN_clblasZswap = 131, +// OPENCLAMDBLAS_FN_clblasZsymm = 132, +// OPENCLAMDBLAS_FN_clblasZsyr2k = 133, +// OPENCLAMDBLAS_FN_clblasZsyrk = 134, +// OPENCLAMDBLAS_FN_clblasZtbmv = 135, +// OPENCLAMDBLAS_FN_clblasZtbsv = 136, +// OPENCLAMDBLAS_FN_clblasZtpmv = 137, +// OPENCLAMDBLAS_FN_clblasZtpsv = 138, +// OPENCLAMDBLAS_FN_clblasZtrmm = 139, +// OPENCLAMDBLAS_FN_clblasZtrmv = 140, +// OPENCLAMDBLAS_FN_clblasZtrsm = 141, +// OPENCLAMDBLAS_FN_clblasZtrsv = 142, +// OPENCLAMDBLAS_FN_clblasiCamax = 143, +// OPENCLAMDBLAS_FN_clblasiDamax = 144, +// OPENCLAMDBLAS_FN_clblasiSamax = 145, +// OPENCLAMDBLAS_FN_clblasiZamax = 146, +}; + +namespace { +// generated by parser_clblas.py +#define openclamdblas_fn0(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(); } \ + +#define openclamdblas_fn1(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1); } \ + +#define openclamdblas_fn2(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2); } \ + +#define openclamdblas_fn3(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3); } \ + +#define openclamdblas_fn4(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4); } \ + +#define openclamdblas_fn5(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5); } \ + +#define openclamdblas_fn6(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6); } \ + +#define openclamdblas_fn7(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7); } \ + +#define openclamdblas_fn8(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8); } \ + +#define openclamdblas_fn9(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9); } \ + +#define openclamdblas_fn10(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); } \ + +#define openclamdblas_fn11(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); } \ + +#define openclamdblas_fn12(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); } \ + +#define openclamdblas_fn13(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); } \ + +#define openclamdblas_fn14(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); } \ + +#define openclamdblas_fn15(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); } \ + +#define openclamdblas_fn16(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); } \ + +#define openclamdblas_fn17(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17); } \ + +#define openclamdblas_fn18(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18); } \ + +#define openclamdblas_fn19(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19); } \ + +#define openclamdblas_fn20(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20); } \ + +#define openclamdblas_fn21(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21); } \ + +#define openclamdblas_fn22(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdblas_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22); } \ + +} + +// generated by parser_clblas.py +//openclamdblas_fn13(OPENCLAMDBLAS_FN_clblasCaxpy, clblasStatus, (size_t p1, cl_float2 p2, const cl_mem p3, size_t p4, int p5, cl_mem p6, size_t p7, int p8, cl_uint p9, cl_command_queue* p10, cl_uint p11, const cl_event* p12, cl_event* p13)) +//clblasStatus (*clblasCaxpy)(size_t, cl_float2, const cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCaxpy_switch_fn; +//static const struct DynamicFnEntry clblasCaxpy_definition = { "clblasCaxpy", (void**)&clblasCaxpy}; + +//openclamdblas_fn12(OPENCLAMDBLAS_FN_clblasCcopy, clblasStatus, (size_t p1, const cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) +//clblasStatus (*clblasCcopy)(size_t, const cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCcopy_switch_fn; +//static const struct DynamicFnEntry clblasCcopy_definition = { "clblasCcopy", (void**)&clblasCcopy}; + +//openclamdblas_fn15(OPENCLAMDBLAS_FN_clblasCdotc, clblasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, const cl_mem p7, size_t p8, int p9, cl_mem p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) +//clblasStatus (*clblasCdotc)(size_t, cl_mem, size_t, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCdotc_switch_fn; +//static const struct DynamicFnEntry clblasCdotc_definition = { "clblasCdotc", (void**)&clblasCdotc}; + +//openclamdblas_fn15(OPENCLAMDBLAS_FN_clblasCdotu, clblasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, const cl_mem p7, size_t p8, int p9, cl_mem p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) +//clblasStatus (*clblasCdotu)(size_t, cl_mem, size_t, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCdotu_switch_fn; +//static const struct DynamicFnEntry clblasCdotu_definition = { "clblasCdotu", (void**)&clblasCdotu}; + +//openclamdblas_fn22(OPENCLAMDBLAS_FN_clblasCgbmv, clblasStatus, (clblasOrder p1, clblasTranspose p2, size_t p3, size_t p4, size_t p5, size_t p6, cl_float2 p7, const cl_mem p8, size_t p9, size_t p10, const cl_mem p11, size_t p12, int p13, cl_float2 p14, cl_mem p15, size_t p16, int p17, cl_uint p18, cl_command_queue* p19, cl_uint p20, const cl_event* p21, cl_event* p22)) +//clblasStatus (*clblasCgbmv)(clblasOrder, clblasTranspose, size_t, size_t, size_t, size_t, cl_float2, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_float2, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCgbmv_switch_fn; +//static const struct DynamicFnEntry clblasCgbmv_definition = { "clblasCgbmv", (void**)&clblasCgbmv}; + +openclamdblas_fn22(OPENCLAMDBLAS_FN_clblasCgemm, clblasStatus, (clblasOrder p1, clblasTranspose p2, clblasTranspose p3, size_t p4, size_t p5, size_t p6, FloatComplex p7, const cl_mem p8, size_t p9, size_t p10, const cl_mem p11, size_t p12, size_t p13, FloatComplex p14, cl_mem p15, size_t p16, size_t p17, cl_uint p18, cl_command_queue* p19, cl_uint p20, const cl_event* p21, cl_event* p22)) +clblasStatus (*clblasCgemm)(clblasOrder, clblasTranspose, clblasTranspose, size_t, size_t, size_t, FloatComplex, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, FloatComplex, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = + OPENCLAMDBLAS_FN_clblasCgemm_switch_fn; +static const struct DynamicFnEntry clblasCgemm_definition = { "clblasCgemm", (void**)&clblasCgemm}; + +//openclamdblas_fn20(OPENCLAMDBLAS_FN_clblasCgemv, clblasStatus, (clblasOrder p1, clblasTranspose p2, size_t p3, size_t p4, FloatComplex p5, const cl_mem p6, size_t p7, size_t p8, const cl_mem p9, size_t p10, int p11, FloatComplex p12, cl_mem p13, size_t p14, int p15, cl_uint p16, cl_command_queue* p17, cl_uint p18, const cl_event* p19, cl_event* p20)) +//clblasStatus (*clblasCgemv)(clblasOrder, clblasTranspose, size_t, size_t, FloatComplex, const cl_mem, size_t, size_t, const cl_mem, size_t, int, FloatComplex, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCgemv_switch_fn; +//static const struct DynamicFnEntry clblasCgemv_definition = { "clblasCgemv", (void**)&clblasCgemv}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasCgerc, clblasStatus, (clblasOrder p1, size_t p2, size_t p3, cl_float2 p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasCgerc)(clblasOrder, size_t, size_t, cl_float2, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCgerc_switch_fn; +//static const struct DynamicFnEntry clblasCgerc_definition = { "clblasCgerc", (void**)&clblasCgerc}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasCgeru, clblasStatus, (clblasOrder p1, size_t p2, size_t p3, cl_float2 p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasCgeru)(clblasOrder, size_t, size_t, cl_float2, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCgeru_switch_fn; +//static const struct DynamicFnEntry clblasCgeru_definition = { "clblasCgeru", (void**)&clblasCgeru}; + +//openclamdblas_fn20(OPENCLAMDBLAS_FN_clblasChbmv, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, size_t p4, cl_float2 p5, const cl_mem p6, size_t p7, size_t p8, const cl_mem p9, size_t p10, int p11, cl_float2 p12, cl_mem p13, size_t p14, int p15, cl_uint p16, cl_command_queue* p17, cl_uint p18, const cl_event* p19, cl_event* p20)) +//clblasStatus (*clblasChbmv)(clblasOrder, clblasUplo, size_t, size_t, cl_float2, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_float2, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasChbmv_switch_fn; +//static const struct DynamicFnEntry clblasChbmv_definition = { "clblasChbmv", (void**)&clblasChbmv}; + +//openclamdblas_fn21(OPENCLAMDBLAS_FN_clblasChemm, clblasStatus, (clblasOrder p1, clblasSide p2, clblasUplo p3, size_t p4, size_t p5, cl_float2 p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, cl_float2 p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) +//clblasStatus (*clblasChemm)(clblasOrder, clblasSide, clblasUplo, size_t, size_t, cl_float2, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_float2, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasChemm_switch_fn; +//static const struct DynamicFnEntry clblasChemm_definition = { "clblasChemm", (void**)&clblasChemm}; + +//openclamdblas_fn19(OPENCLAMDBLAS_FN_clblasChemv, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, FloatComplex p4, const cl_mem p5, size_t p6, size_t p7, const cl_mem p8, size_t p9, int p10, FloatComplex p11, cl_mem p12, size_t p13, int p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) +//clblasStatus (*clblasChemv)(clblasOrder, clblasUplo, size_t, FloatComplex, const cl_mem, size_t, size_t, const cl_mem, size_t, int, FloatComplex, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasChemv_switch_fn; +//static const struct DynamicFnEntry clblasChemv_definition = { "clblasChemv", (void**)&clblasChemv}; + +//openclamdblas_fn15(OPENCLAMDBLAS_FN_clblasCher, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_float p4, const cl_mem p5, size_t p6, int p7, cl_mem p8, size_t p9, size_t p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) +//clblasStatus (*clblasCher)(clblasOrder, clblasUplo, size_t, cl_float, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCher_switch_fn; +//static const struct DynamicFnEntry clblasCher_definition = { "clblasCher", (void**)&clblasCher}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasCher2, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_float2 p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasCher2)(clblasOrder, clblasUplo, size_t, cl_float2, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCher2_switch_fn; +//static const struct DynamicFnEntry clblasCher2_definition = { "clblasCher2", (void**)&clblasCher2}; + +//openclamdblas_fn21(OPENCLAMDBLAS_FN_clblasCher2k, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, size_t p4, size_t p5, FloatComplex p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, cl_float p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) +//clblasStatus (*clblasCher2k)(clblasOrder, clblasUplo, clblasTranspose, size_t, size_t, FloatComplex, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_float, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCher2k_switch_fn; +//static const struct DynamicFnEntry clblasCher2k_definition = { "clblasCher2k", (void**)&clblasCher2k}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasCherk, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, size_t p4, size_t p5, float p6, const cl_mem p7, size_t p8, size_t p9, float p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasCherk)(clblasOrder, clblasUplo, clblasTranspose, size_t, size_t, float, const cl_mem, size_t, size_t, float, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCherk_switch_fn; +//static const struct DynamicFnEntry clblasCherk_definition = { "clblasCherk", (void**)&clblasCherk}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasChpmv, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_float2 p4, const cl_mem p5, size_t p6, const cl_mem p7, size_t p8, int p9, cl_float2 p10, cl_mem p11, size_t p12, int p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasChpmv)(clblasOrder, clblasUplo, size_t, cl_float2, const cl_mem, size_t, const cl_mem, size_t, int, cl_float2, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasChpmv_switch_fn; +//static const struct DynamicFnEntry clblasChpmv_definition = { "clblasChpmv", (void**)&clblasChpmv}; + +//openclamdblas_fn14(OPENCLAMDBLAS_FN_clblasChpr, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_float p4, const cl_mem p5, size_t p6, int p7, cl_mem p8, size_t p9, cl_uint p10, cl_command_queue* p11, cl_uint p12, const cl_event* p13, cl_event* p14)) +//clblasStatus (*clblasChpr)(clblasOrder, clblasUplo, size_t, cl_float, const cl_mem, size_t, int, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasChpr_switch_fn; +//static const struct DynamicFnEntry clblasChpr_definition = { "clblasChpr", (void**)&clblasChpr}; + +//openclamdblas_fn17(OPENCLAMDBLAS_FN_clblasChpr2, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_float2 p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) +//clblasStatus (*clblasChpr2)(clblasOrder, clblasUplo, size_t, cl_float2, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasChpr2_switch_fn; +//static const struct DynamicFnEntry clblasChpr2_definition = { "clblasChpr2", (void**)&clblasChpr2}; + +//openclamdblas_fn13(OPENCLAMDBLAS_FN_clblasCrotg, clblasStatus, (cl_mem p1, size_t p2, cl_mem p3, size_t p4, cl_mem p5, size_t p6, cl_mem p7, size_t p8, cl_uint p9, cl_command_queue* p10, cl_uint p11, const cl_event* p12, cl_event* p13)) +//clblasStatus (*clblasCrotg)(cl_mem, size_t, cl_mem, size_t, cl_mem, size_t, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCrotg_switch_fn; +//static const struct DynamicFnEntry clblasCrotg_definition = { "clblasCrotg", (void**)&clblasCrotg}; + +//openclamdblas_fn10(OPENCLAMDBLAS_FN_clblasCscal, clblasStatus, (size_t p1, cl_float2 p2, cl_mem p3, size_t p4, int p5, cl_uint p6, cl_command_queue* p7, cl_uint p8, const cl_event* p9, cl_event* p10)) +//clblasStatus (*clblasCscal)(size_t, cl_float2, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCscal_switch_fn; +//static const struct DynamicFnEntry clblasCscal_definition = { "clblasCscal", (void**)&clblasCscal}; + +//openclamdblas_fn14(OPENCLAMDBLAS_FN_clblasCsrot, clblasStatus, (size_t p1, cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_float p8, cl_float p9, cl_uint p10, cl_command_queue* p11, cl_uint p12, const cl_event* p13, cl_event* p14)) +//clblasStatus (*clblasCsrot)(size_t, cl_mem, size_t, int, cl_mem, size_t, int, cl_float, cl_float, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCsrot_switch_fn; +//static const struct DynamicFnEntry clblasCsrot_definition = { "clblasCsrot", (void**)&clblasCsrot}; + +//openclamdblas_fn10(OPENCLAMDBLAS_FN_clblasCsscal, clblasStatus, (size_t p1, cl_float p2, cl_mem p3, size_t p4, int p5, cl_uint p6, cl_command_queue* p7, cl_uint p8, const cl_event* p9, cl_event* p10)) +//clblasStatus (*clblasCsscal)(size_t, cl_float, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCsscal_switch_fn; +//static const struct DynamicFnEntry clblasCsscal_definition = { "clblasCsscal", (void**)&clblasCsscal}; + +//openclamdblas_fn12(OPENCLAMDBLAS_FN_clblasCswap, clblasStatus, (size_t p1, cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) +//clblasStatus (*clblasCswap)(size_t, cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCswap_switch_fn; +//static const struct DynamicFnEntry clblasCswap_definition = { "clblasCswap", (void**)&clblasCswap}; + +//openclamdblas_fn21(OPENCLAMDBLAS_FN_clblasCsymm, clblasStatus, (clblasOrder p1, clblasSide p2, clblasUplo p3, size_t p4, size_t p5, cl_float2 p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, cl_float2 p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) +//clblasStatus (*clblasCsymm)(clblasOrder, clblasSide, clblasUplo, size_t, size_t, cl_float2, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_float2, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCsymm_switch_fn; +//static const struct DynamicFnEntry clblasCsymm_definition = { "clblasCsymm", (void**)&clblasCsymm}; + +//openclamdblas_fn21(OPENCLAMDBLAS_FN_clblasCsyr2k, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, size_t p4, size_t p5, FloatComplex p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, FloatComplex p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) +//clblasStatus (*clblasCsyr2k)(clblasOrder, clblasUplo, clblasTranspose, size_t, size_t, FloatComplex, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, FloatComplex, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCsyr2k_switch_fn; +//static const struct DynamicFnEntry clblasCsyr2k_definition = { "clblasCsyr2k", (void**)&clblasCsyr2k}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasCsyrk, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, size_t p4, size_t p5, FloatComplex p6, const cl_mem p7, size_t p8, size_t p9, FloatComplex p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasCsyrk)(clblasOrder, clblasUplo, clblasTranspose, size_t, size_t, FloatComplex, const cl_mem, size_t, size_t, FloatComplex, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCsyrk_switch_fn; +//static const struct DynamicFnEntry clblasCsyrk_definition = { "clblasCsyrk", (void**)&clblasCsyrk}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasCtbmv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, size_t p6, const cl_mem p7, size_t p8, size_t p9, cl_mem p10, size_t p11, int p12, cl_mem p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasCtbmv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCtbmv_switch_fn; +//static const struct DynamicFnEntry clblasCtbmv_definition = { "clblasCtbmv", (void**)&clblasCtbmv}; + +//openclamdblas_fn17(OPENCLAMDBLAS_FN_clblasCtbsv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, size_t p6, const cl_mem p7, size_t p8, size_t p9, cl_mem p10, size_t p11, int p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) +//clblasStatus (*clblasCtbsv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCtbsv_switch_fn; +//static const struct DynamicFnEntry clblasCtbsv_definition = { "clblasCtbsv", (void**)&clblasCtbsv}; + +//openclamdblas_fn16(OPENCLAMDBLAS_FN_clblasCtpmv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, const cl_mem p6, size_t p7, cl_mem p8, size_t p9, int p10, cl_mem p11, cl_uint p12, cl_command_queue* p13, cl_uint p14, const cl_event* p15, cl_event* p16)) +//clblasStatus (*clblasCtpmv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, const cl_mem, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCtpmv_switch_fn; +//static const struct DynamicFnEntry clblasCtpmv_definition = { "clblasCtpmv", (void**)&clblasCtpmv}; + +//openclamdblas_fn15(OPENCLAMDBLAS_FN_clblasCtpsv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, const cl_mem p6, size_t p7, cl_mem p8, size_t p9, int p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) +//clblasStatus (*clblasCtpsv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, const cl_mem, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCtpsv_switch_fn; +//static const struct DynamicFnEntry clblasCtpsv_definition = { "clblasCtpsv", (void**)&clblasCtpsv}; + +//openclamdblas_fn19(OPENCLAMDBLAS_FN_clblasCtrmm, clblasStatus, (clblasOrder p1, clblasSide p2, clblasUplo p3, clblasTranspose p4, clblasDiag p5, size_t p6, size_t p7, FloatComplex p8, const cl_mem p9, size_t p10, size_t p11, cl_mem p12, size_t p13, size_t p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) +//clblasStatus (*clblasCtrmm)(clblasOrder, clblasSide, clblasUplo, clblasTranspose, clblasDiag, size_t, size_t, FloatComplex, const cl_mem, size_t, size_t, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCtrmm_switch_fn; +//static const struct DynamicFnEntry clblasCtrmm_definition = { "clblasCtrmm", (void**)&clblasCtrmm}; + +//openclamdblas_fn17(OPENCLAMDBLAS_FN_clblasCtrmv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, const cl_mem p6, size_t p7, size_t p8, cl_mem p9, size_t p10, int p11, cl_mem p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) +//clblasStatus (*clblasCtrmv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCtrmv_switch_fn; +//static const struct DynamicFnEntry clblasCtrmv_definition = { "clblasCtrmv", (void**)&clblasCtrmv}; + +//openclamdblas_fn19(OPENCLAMDBLAS_FN_clblasCtrsm, clblasStatus, (clblasOrder p1, clblasSide p2, clblasUplo p3, clblasTranspose p4, clblasDiag p5, size_t p6, size_t p7, FloatComplex p8, const cl_mem p9, size_t p10, size_t p11, cl_mem p12, size_t p13, size_t p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) +//clblasStatus (*clblasCtrsm)(clblasOrder, clblasSide, clblasUplo, clblasTranspose, clblasDiag, size_t, size_t, FloatComplex, const cl_mem, size_t, size_t, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCtrsm_switch_fn; +//static const struct DynamicFnEntry clblasCtrsm_definition = { "clblasCtrsm", (void**)&clblasCtrsm}; + +//openclamdblas_fn16(OPENCLAMDBLAS_FN_clblasCtrsv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, const cl_mem p6, size_t p7, size_t p8, cl_mem p9, size_t p10, int p11, cl_uint p12, cl_command_queue* p13, cl_uint p14, const cl_event* p15, cl_event* p16)) +//clblasStatus (*clblasCtrsv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasCtrsv_switch_fn; +//static const struct DynamicFnEntry clblasCtrsv_definition = { "clblasCtrsv", (void**)&clblasCtrsv}; + +//openclamdblas_fn12(OPENCLAMDBLAS_FN_clblasDasum, clblasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) +//clblasStatus (*clblasDasum)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDasum_switch_fn; +//static const struct DynamicFnEntry clblasDasum_definition = { "clblasDasum", (void**)&clblasDasum}; + +//openclamdblas_fn13(OPENCLAMDBLAS_FN_clblasDaxpy, clblasStatus, (size_t p1, cl_double p2, const cl_mem p3, size_t p4, int p5, cl_mem p6, size_t p7, int p8, cl_uint p9, cl_command_queue* p10, cl_uint p11, const cl_event* p12, cl_event* p13)) +//clblasStatus (*clblasDaxpy)(size_t, cl_double, const cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDaxpy_switch_fn; +//static const struct DynamicFnEntry clblasDaxpy_definition = { "clblasDaxpy", (void**)&clblasDaxpy}; + +//openclamdblas_fn12(OPENCLAMDBLAS_FN_clblasDcopy, clblasStatus, (size_t p1, const cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) +//clblasStatus (*clblasDcopy)(size_t, const cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDcopy_switch_fn; +//static const struct DynamicFnEntry clblasDcopy_definition = { "clblasDcopy", (void**)&clblasDcopy}; + +//openclamdblas_fn15(OPENCLAMDBLAS_FN_clblasDdot, clblasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, const cl_mem p7, size_t p8, int p9, cl_mem p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) +//clblasStatus (*clblasDdot)(size_t, cl_mem, size_t, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDdot_switch_fn; +//static const struct DynamicFnEntry clblasDdot_definition = { "clblasDdot", (void**)&clblasDdot}; + +//openclamdblas_fn22(OPENCLAMDBLAS_FN_clblasDgbmv, clblasStatus, (clblasOrder p1, clblasTranspose p2, size_t p3, size_t p4, size_t p5, size_t p6, cl_double p7, const cl_mem p8, size_t p9, size_t p10, const cl_mem p11, size_t p12, int p13, cl_double p14, cl_mem p15, size_t p16, int p17, cl_uint p18, cl_command_queue* p19, cl_uint p20, const cl_event* p21, cl_event* p22)) +//clblasStatus (*clblasDgbmv)(clblasOrder, clblasTranspose, size_t, size_t, size_t, size_t, cl_double, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_double, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDgbmv_switch_fn; +//static const struct DynamicFnEntry clblasDgbmv_definition = { "clblasDgbmv", (void**)&clblasDgbmv}; + +openclamdblas_fn22(OPENCLAMDBLAS_FN_clblasDgemm, clblasStatus, (clblasOrder p1, clblasTranspose p2, clblasTranspose p3, size_t p4, size_t p5, size_t p6, cl_double p7, const cl_mem p8, size_t p9, size_t p10, const cl_mem p11, size_t p12, size_t p13, cl_double p14, cl_mem p15, size_t p16, size_t p17, cl_uint p18, cl_command_queue* p19, cl_uint p20, const cl_event* p21, cl_event* p22)) +clblasStatus (*clblasDgemm)(clblasOrder, clblasTranspose, clblasTranspose, size_t, size_t, size_t, cl_double, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_double, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = + OPENCLAMDBLAS_FN_clblasDgemm_switch_fn; +static const struct DynamicFnEntry clblasDgemm_definition = { "clblasDgemm", (void**)&clblasDgemm}; + +//openclamdblas_fn20(OPENCLAMDBLAS_FN_clblasDgemv, clblasStatus, (clblasOrder p1, clblasTranspose p2, size_t p3, size_t p4, cl_double p5, const cl_mem p6, size_t p7, size_t p8, const cl_mem p9, size_t p10, int p11, cl_double p12, cl_mem p13, size_t p14, int p15, cl_uint p16, cl_command_queue* p17, cl_uint p18, const cl_event* p19, cl_event* p20)) +//clblasStatus (*clblasDgemv)(clblasOrder, clblasTranspose, size_t, size_t, cl_double, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_double, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDgemv_switch_fn; +//static const struct DynamicFnEntry clblasDgemv_definition = { "clblasDgemv", (void**)&clblasDgemv}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasDger, clblasStatus, (clblasOrder p1, size_t p2, size_t p3, cl_double p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasDger)(clblasOrder, size_t, size_t, cl_double, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDger_switch_fn; +//static const struct DynamicFnEntry clblasDger_definition = { "clblasDger", (void**)&clblasDger}; + +//openclamdblas_fn12(OPENCLAMDBLAS_FN_clblasDnrm2, clblasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) +//clblasStatus (*clblasDnrm2)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDnrm2_switch_fn; +//static const struct DynamicFnEntry clblasDnrm2_definition = { "clblasDnrm2", (void**)&clblasDnrm2}; + +//openclamdblas_fn14(OPENCLAMDBLAS_FN_clblasDrot, clblasStatus, (size_t p1, cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_double p8, cl_double p9, cl_uint p10, cl_command_queue* p11, cl_uint p12, const cl_event* p13, cl_event* p14)) +//clblasStatus (*clblasDrot)(size_t, cl_mem, size_t, int, cl_mem, size_t, int, cl_double, cl_double, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDrot_switch_fn; +//static const struct DynamicFnEntry clblasDrot_definition = { "clblasDrot", (void**)&clblasDrot}; + +//openclamdblas_fn13(OPENCLAMDBLAS_FN_clblasDrotg, clblasStatus, (cl_mem p1, size_t p2, cl_mem p3, size_t p4, cl_mem p5, size_t p6, cl_mem p7, size_t p8, cl_uint p9, cl_command_queue* p10, cl_uint p11, const cl_event* p12, cl_event* p13)) +//clblasStatus (*clblasDrotg)(cl_mem, size_t, cl_mem, size_t, cl_mem, size_t, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDrotg_switch_fn; +//static const struct DynamicFnEntry clblasDrotg_definition = { "clblasDrotg", (void**)&clblasDrotg}; + +//openclamdblas_fn14(OPENCLAMDBLAS_FN_clblasDrotm, clblasStatus, (size_t p1, cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, cl_uint p10, cl_command_queue* p11, cl_uint p12, const cl_event* p13, cl_event* p14)) +//clblasStatus (*clblasDrotm)(size_t, cl_mem, size_t, int, cl_mem, size_t, int, const cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDrotm_switch_fn; +//static const struct DynamicFnEntry clblasDrotm_definition = { "clblasDrotm", (void**)&clblasDrotm}; + +//openclamdblas_fn15(OPENCLAMDBLAS_FN_clblasDrotmg, clblasStatus, (cl_mem p1, size_t p2, cl_mem p3, size_t p4, cl_mem p5, size_t p6, const cl_mem p7, size_t p8, cl_mem p9, size_t p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) +//clblasStatus (*clblasDrotmg)(cl_mem, size_t, cl_mem, size_t, cl_mem, size_t, const cl_mem, size_t, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDrotmg_switch_fn; +//static const struct DynamicFnEntry clblasDrotmg_definition = { "clblasDrotmg", (void**)&clblasDrotmg}; + +//openclamdblas_fn20(OPENCLAMDBLAS_FN_clblasDsbmv, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, size_t p4, cl_double p5, const cl_mem p6, size_t p7, size_t p8, const cl_mem p9, size_t p10, int p11, cl_double p12, cl_mem p13, size_t p14, int p15, cl_uint p16, cl_command_queue* p17, cl_uint p18, const cl_event* p19, cl_event* p20)) +//clblasStatus (*clblasDsbmv)(clblasOrder, clblasUplo, size_t, size_t, cl_double, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_double, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDsbmv_switch_fn; +//static const struct DynamicFnEntry clblasDsbmv_definition = { "clblasDsbmv", (void**)&clblasDsbmv}; + +//openclamdblas_fn10(OPENCLAMDBLAS_FN_clblasDscal, clblasStatus, (size_t p1, cl_double p2, cl_mem p3, size_t p4, int p5, cl_uint p6, cl_command_queue* p7, cl_uint p8, const cl_event* p9, cl_event* p10)) +//clblasStatus (*clblasDscal)(size_t, cl_double, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDscal_switch_fn; +//static const struct DynamicFnEntry clblasDscal_definition = { "clblasDscal", (void**)&clblasDscal}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasDspmv, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_double p4, const cl_mem p5, size_t p6, const cl_mem p7, size_t p8, int p9, cl_double p10, cl_mem p11, size_t p12, int p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasDspmv)(clblasOrder, clblasUplo, size_t, cl_double, const cl_mem, size_t, const cl_mem, size_t, int, cl_double, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDspmv_switch_fn; +//static const struct DynamicFnEntry clblasDspmv_definition = { "clblasDspmv", (void**)&clblasDspmv}; + +//openclamdblas_fn14(OPENCLAMDBLAS_FN_clblasDspr, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_double p4, const cl_mem p5, size_t p6, int p7, cl_mem p8, size_t p9, cl_uint p10, cl_command_queue* p11, cl_uint p12, const cl_event* p13, cl_event* p14)) +//clblasStatus (*clblasDspr)(clblasOrder, clblasUplo, size_t, cl_double, const cl_mem, size_t, int, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDspr_switch_fn; +//static const struct DynamicFnEntry clblasDspr_definition = { "clblasDspr", (void**)&clblasDspr}; + +//openclamdblas_fn17(OPENCLAMDBLAS_FN_clblasDspr2, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_double p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) +//clblasStatus (*clblasDspr2)(clblasOrder, clblasUplo, size_t, cl_double, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDspr2_switch_fn; +//static const struct DynamicFnEntry clblasDspr2_definition = { "clblasDspr2", (void**)&clblasDspr2}; + +//openclamdblas_fn12(OPENCLAMDBLAS_FN_clblasDswap, clblasStatus, (size_t p1, cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) +//clblasStatus (*clblasDswap)(size_t, cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDswap_switch_fn; +//static const struct DynamicFnEntry clblasDswap_definition = { "clblasDswap", (void**)&clblasDswap}; + +//openclamdblas_fn21(OPENCLAMDBLAS_FN_clblasDsymm, clblasStatus, (clblasOrder p1, clblasSide p2, clblasUplo p3, size_t p4, size_t p5, cl_double p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, cl_double p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) +//clblasStatus (*clblasDsymm)(clblasOrder, clblasSide, clblasUplo, size_t, size_t, cl_double, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_double, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDsymm_switch_fn; +//static const struct DynamicFnEntry clblasDsymm_definition = { "clblasDsymm", (void**)&clblasDsymm}; + +//openclamdblas_fn19(OPENCLAMDBLAS_FN_clblasDsymv, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_double p4, const cl_mem p5, size_t p6, size_t p7, const cl_mem p8, size_t p9, int p10, cl_double p11, cl_mem p12, size_t p13, int p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) +//clblasStatus (*clblasDsymv)(clblasOrder, clblasUplo, size_t, cl_double, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_double, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDsymv_switch_fn; +//static const struct DynamicFnEntry clblasDsymv_definition = { "clblasDsymv", (void**)&clblasDsymv}; + +//openclamdblas_fn15(OPENCLAMDBLAS_FN_clblasDsyr, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_double p4, const cl_mem p5, size_t p6, int p7, cl_mem p8, size_t p9, size_t p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) +//clblasStatus (*clblasDsyr)(clblasOrder, clblasUplo, size_t, cl_double, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDsyr_switch_fn; +//static const struct DynamicFnEntry clblasDsyr_definition = { "clblasDsyr", (void**)&clblasDsyr}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasDsyr2, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_double p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasDsyr2)(clblasOrder, clblasUplo, size_t, cl_double, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDsyr2_switch_fn; +//static const struct DynamicFnEntry clblasDsyr2_definition = { "clblasDsyr2", (void**)&clblasDsyr2}; + +//openclamdblas_fn21(OPENCLAMDBLAS_FN_clblasDsyr2k, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, size_t p4, size_t p5, cl_double p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, cl_double p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) +//clblasStatus (*clblasDsyr2k)(clblasOrder, clblasUplo, clblasTranspose, size_t, size_t, cl_double, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_double, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDsyr2k_switch_fn; +//static const struct DynamicFnEntry clblasDsyr2k_definition = { "clblasDsyr2k", (void**)&clblasDsyr2k}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasDsyrk, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, size_t p4, size_t p5, cl_double p6, const cl_mem p7, size_t p8, size_t p9, cl_double p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasDsyrk)(clblasOrder, clblasUplo, clblasTranspose, size_t, size_t, cl_double, const cl_mem, size_t, size_t, cl_double, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDsyrk_switch_fn; +//static const struct DynamicFnEntry clblasDsyrk_definition = { "clblasDsyrk", (void**)&clblasDsyrk}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasDtbmv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, size_t p6, const cl_mem p7, size_t p8, size_t p9, cl_mem p10, size_t p11, int p12, cl_mem p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasDtbmv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDtbmv_switch_fn; +//static const struct DynamicFnEntry clblasDtbmv_definition = { "clblasDtbmv", (void**)&clblasDtbmv}; + +//openclamdblas_fn17(OPENCLAMDBLAS_FN_clblasDtbsv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, size_t p6, const cl_mem p7, size_t p8, size_t p9, cl_mem p10, size_t p11, int p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) +//clblasStatus (*clblasDtbsv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDtbsv_switch_fn; +//static const struct DynamicFnEntry clblasDtbsv_definition = { "clblasDtbsv", (void**)&clblasDtbsv}; + +//openclamdblas_fn16(OPENCLAMDBLAS_FN_clblasDtpmv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, const cl_mem p6, size_t p7, cl_mem p8, size_t p9, int p10, cl_mem p11, cl_uint p12, cl_command_queue* p13, cl_uint p14, const cl_event* p15, cl_event* p16)) +//clblasStatus (*clblasDtpmv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, const cl_mem, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDtpmv_switch_fn; +//static const struct DynamicFnEntry clblasDtpmv_definition = { "clblasDtpmv", (void**)&clblasDtpmv}; + +//openclamdblas_fn15(OPENCLAMDBLAS_FN_clblasDtpsv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, const cl_mem p6, size_t p7, cl_mem p8, size_t p9, int p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) +//clblasStatus (*clblasDtpsv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, const cl_mem, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDtpsv_switch_fn; +//static const struct DynamicFnEntry clblasDtpsv_definition = { "clblasDtpsv", (void**)&clblasDtpsv}; + +//openclamdblas_fn19(OPENCLAMDBLAS_FN_clblasDtrmm, clblasStatus, (clblasOrder p1, clblasSide p2, clblasUplo p3, clblasTranspose p4, clblasDiag p5, size_t p6, size_t p7, cl_double p8, const cl_mem p9, size_t p10, size_t p11, cl_mem p12, size_t p13, size_t p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) +//clblasStatus (*clblasDtrmm)(clblasOrder, clblasSide, clblasUplo, clblasTranspose, clblasDiag, size_t, size_t, cl_double, const cl_mem, size_t, size_t, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDtrmm_switch_fn; +//static const struct DynamicFnEntry clblasDtrmm_definition = { "clblasDtrmm", (void**)&clblasDtrmm}; + +//openclamdblas_fn17(OPENCLAMDBLAS_FN_clblasDtrmv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, const cl_mem p6, size_t p7, size_t p8, cl_mem p9, size_t p10, int p11, cl_mem p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) +//clblasStatus (*clblasDtrmv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDtrmv_switch_fn; +//static const struct DynamicFnEntry clblasDtrmv_definition = { "clblasDtrmv", (void**)&clblasDtrmv}; + +//openclamdblas_fn19(OPENCLAMDBLAS_FN_clblasDtrsm, clblasStatus, (clblasOrder p1, clblasSide p2, clblasUplo p3, clblasTranspose p4, clblasDiag p5, size_t p6, size_t p7, cl_double p8, const cl_mem p9, size_t p10, size_t p11, cl_mem p12, size_t p13, size_t p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) +//clblasStatus (*clblasDtrsm)(clblasOrder, clblasSide, clblasUplo, clblasTranspose, clblasDiag, size_t, size_t, cl_double, const cl_mem, size_t, size_t, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDtrsm_switch_fn; +//static const struct DynamicFnEntry clblasDtrsm_definition = { "clblasDtrsm", (void**)&clblasDtrsm}; + +//openclamdblas_fn16(OPENCLAMDBLAS_FN_clblasDtrsv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, const cl_mem p6, size_t p7, size_t p8, cl_mem p9, size_t p10, int p11, cl_uint p12, cl_command_queue* p13, cl_uint p14, const cl_event* p15, cl_event* p16)) +//clblasStatus (*clblasDtrsv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDtrsv_switch_fn; +//static const struct DynamicFnEntry clblasDtrsv_definition = { "clblasDtrsv", (void**)&clblasDtrsv}; + +//openclamdblas_fn12(OPENCLAMDBLAS_FN_clblasDzasum, clblasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) +//clblasStatus (*clblasDzasum)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDzasum_switch_fn; +//static const struct DynamicFnEntry clblasDzasum_definition = { "clblasDzasum", (void**)&clblasDzasum}; + +//openclamdblas_fn12(OPENCLAMDBLAS_FN_clblasDznrm2, clblasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) +//clblasStatus (*clblasDznrm2)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasDznrm2_switch_fn; +//static const struct DynamicFnEntry clblasDznrm2_definition = { "clblasDznrm2", (void**)&clblasDznrm2}; + +//openclamdblas_fn3(OPENCLAMDBLAS_FN_clblasGetVersion, clblasStatus, (cl_uint* p1, cl_uint* p2, cl_uint* p3)) +//clblasStatus (*clblasGetVersion)(cl_uint*, cl_uint*, cl_uint*) = +// OPENCLAMDBLAS_FN_clblasGetVersion_switch_fn; +//static const struct DynamicFnEntry clblasGetVersion_definition = { "clblasGetVersion", (void**)&clblasGetVersion}; + +//openclamdblas_fn12(OPENCLAMDBLAS_FN_clblasSasum, clblasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) +//clblasStatus (*clblasSasum)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSasum_switch_fn; +//static const struct DynamicFnEntry clblasSasum_definition = { "clblasSasum", (void**)&clblasSasum}; + +//openclamdblas_fn13(OPENCLAMDBLAS_FN_clblasSaxpy, clblasStatus, (size_t p1, cl_float p2, const cl_mem p3, size_t p4, int p5, cl_mem p6, size_t p7, int p8, cl_uint p9, cl_command_queue* p10, cl_uint p11, const cl_event* p12, cl_event* p13)) +//clblasStatus (*clblasSaxpy)(size_t, cl_float, const cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSaxpy_switch_fn; +//static const struct DynamicFnEntry clblasSaxpy_definition = { "clblasSaxpy", (void**)&clblasSaxpy}; + +//openclamdblas_fn12(OPENCLAMDBLAS_FN_clblasScasum, clblasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) +//clblasStatus (*clblasScasum)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasScasum_switch_fn; +//static const struct DynamicFnEntry clblasScasum_definition = { "clblasScasum", (void**)&clblasScasum}; + +//openclamdblas_fn12(OPENCLAMDBLAS_FN_clblasScnrm2, clblasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) +//clblasStatus (*clblasScnrm2)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasScnrm2_switch_fn; +//static const struct DynamicFnEntry clblasScnrm2_definition = { "clblasScnrm2", (void**)&clblasScnrm2}; + +//openclamdblas_fn12(OPENCLAMDBLAS_FN_clblasScopy, clblasStatus, (size_t p1, const cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) +//clblasStatus (*clblasScopy)(size_t, const cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasScopy_switch_fn; +//static const struct DynamicFnEntry clblasScopy_definition = { "clblasScopy", (void**)&clblasScopy}; + +//openclamdblas_fn15(OPENCLAMDBLAS_FN_clblasSdot, clblasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, const cl_mem p7, size_t p8, int p9, cl_mem p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) +//clblasStatus (*clblasSdot)(size_t, cl_mem, size_t, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSdot_switch_fn; +//static const struct DynamicFnEntry clblasSdot_definition = { "clblasSdot", (void**)&clblasSdot}; + +openclamdblas_fn0(OPENCLAMDBLAS_FN_clblasSetup, clblasStatus, ()) +clblasStatus (*clblasSetup)() = + OPENCLAMDBLAS_FN_clblasSetup_switch_fn; +static const struct DynamicFnEntry clblasSetup_definition = { "clblasSetup", (void**)&clblasSetup}; + +//openclamdblas_fn22(OPENCLAMDBLAS_FN_clblasSgbmv, clblasStatus, (clblasOrder p1, clblasTranspose p2, size_t p3, size_t p4, size_t p5, size_t p6, cl_float p7, const cl_mem p8, size_t p9, size_t p10, const cl_mem p11, size_t p12, int p13, cl_float p14, cl_mem p15, size_t p16, int p17, cl_uint p18, cl_command_queue* p19, cl_uint p20, const cl_event* p21, cl_event* p22)) +//clblasStatus (*clblasSgbmv)(clblasOrder, clblasTranspose, size_t, size_t, size_t, size_t, cl_float, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_float, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSgbmv_switch_fn; +//static const struct DynamicFnEntry clblasSgbmv_definition = { "clblasSgbmv", (void**)&clblasSgbmv}; + +openclamdblas_fn22(OPENCLAMDBLAS_FN_clblasSgemm, clblasStatus, (clblasOrder p1, clblasTranspose p2, clblasTranspose p3, size_t p4, size_t p5, size_t p6, cl_float p7, const cl_mem p8, size_t p9, size_t p10, const cl_mem p11, size_t p12, size_t p13, cl_float p14, cl_mem p15, size_t p16, size_t p17, cl_uint p18, cl_command_queue* p19, cl_uint p20, const cl_event* p21, cl_event* p22)) +clblasStatus (*clblasSgemm)(clblasOrder, clblasTranspose, clblasTranspose, size_t, size_t, size_t, cl_float, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_float, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = + OPENCLAMDBLAS_FN_clblasSgemm_switch_fn; +static const struct DynamicFnEntry clblasSgemm_definition = { "clblasSgemm", (void**)&clblasSgemm}; + +//openclamdblas_fn20(OPENCLAMDBLAS_FN_clblasSgemv, clblasStatus, (clblasOrder p1, clblasTranspose p2, size_t p3, size_t p4, cl_float p5, const cl_mem p6, size_t p7, size_t p8, const cl_mem p9, size_t p10, int p11, cl_float p12, cl_mem p13, size_t p14, int p15, cl_uint p16, cl_command_queue* p17, cl_uint p18, const cl_event* p19, cl_event* p20)) +//clblasStatus (*clblasSgemv)(clblasOrder, clblasTranspose, size_t, size_t, cl_float, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_float, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSgemv_switch_fn; +//static const struct DynamicFnEntry clblasSgemv_definition = { "clblasSgemv", (void**)&clblasSgemv}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasSger, clblasStatus, (clblasOrder p1, size_t p2, size_t p3, cl_float p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasSger)(clblasOrder, size_t, size_t, cl_float, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSger_switch_fn; +//static const struct DynamicFnEntry clblasSger_definition = { "clblasSger", (void**)&clblasSger}; + +//openclamdblas_fn12(OPENCLAMDBLAS_FN_clblasSnrm2, clblasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) +//clblasStatus (*clblasSnrm2)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSnrm2_switch_fn; +//static const struct DynamicFnEntry clblasSnrm2_definition = { "clblasSnrm2", (void**)&clblasSnrm2}; + +//openclamdblas_fn14(OPENCLAMDBLAS_FN_clblasSrot, clblasStatus, (size_t p1, cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_float p8, cl_float p9, cl_uint p10, cl_command_queue* p11, cl_uint p12, const cl_event* p13, cl_event* p14)) +//clblasStatus (*clblasSrot)(size_t, cl_mem, size_t, int, cl_mem, size_t, int, cl_float, cl_float, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSrot_switch_fn; +//static const struct DynamicFnEntry clblasSrot_definition = { "clblasSrot", (void**)&clblasSrot}; + +//openclamdblas_fn13(OPENCLAMDBLAS_FN_clblasSrotg, clblasStatus, (cl_mem p1, size_t p2, cl_mem p3, size_t p4, cl_mem p5, size_t p6, cl_mem p7, size_t p8, cl_uint p9, cl_command_queue* p10, cl_uint p11, const cl_event* p12, cl_event* p13)) +//clblasStatus (*clblasSrotg)(cl_mem, size_t, cl_mem, size_t, cl_mem, size_t, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSrotg_switch_fn; +//static const struct DynamicFnEntry clblasSrotg_definition = { "clblasSrotg", (void**)&clblasSrotg}; + +//openclamdblas_fn14(OPENCLAMDBLAS_FN_clblasSrotm, clblasStatus, (size_t p1, cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, cl_uint p10, cl_command_queue* p11, cl_uint p12, const cl_event* p13, cl_event* p14)) +//clblasStatus (*clblasSrotm)(size_t, cl_mem, size_t, int, cl_mem, size_t, int, const cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSrotm_switch_fn; +//static const struct DynamicFnEntry clblasSrotm_definition = { "clblasSrotm", (void**)&clblasSrotm}; + +//openclamdblas_fn15(OPENCLAMDBLAS_FN_clblasSrotmg, clblasStatus, (cl_mem p1, size_t p2, cl_mem p3, size_t p4, cl_mem p5, size_t p6, const cl_mem p7, size_t p8, cl_mem p9, size_t p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) +//clblasStatus (*clblasSrotmg)(cl_mem, size_t, cl_mem, size_t, cl_mem, size_t, const cl_mem, size_t, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSrotmg_switch_fn; +//static const struct DynamicFnEntry clblasSrotmg_definition = { "clblasSrotmg", (void**)&clblasSrotmg}; + +//openclamdblas_fn20(OPENCLAMDBLAS_FN_clblasSsbmv, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, size_t p4, cl_float p5, const cl_mem p6, size_t p7, size_t p8, const cl_mem p9, size_t p10, int p11, cl_float p12, cl_mem p13, size_t p14, int p15, cl_uint p16, cl_command_queue* p17, cl_uint p18, const cl_event* p19, cl_event* p20)) +//clblasStatus (*clblasSsbmv)(clblasOrder, clblasUplo, size_t, size_t, cl_float, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_float, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSsbmv_switch_fn; +//static const struct DynamicFnEntry clblasSsbmv_definition = { "clblasSsbmv", (void**)&clblasSsbmv}; + +//openclamdblas_fn10(OPENCLAMDBLAS_FN_clblasSscal, clblasStatus, (size_t p1, cl_float p2, cl_mem p3, size_t p4, int p5, cl_uint p6, cl_command_queue* p7, cl_uint p8, const cl_event* p9, cl_event* p10)) +//clblasStatus (*clblasSscal)(size_t, cl_float, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSscal_switch_fn; +//static const struct DynamicFnEntry clblasSscal_definition = { "clblasSscal", (void**)&clblasSscal}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasSspmv, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_float p4, const cl_mem p5, size_t p6, const cl_mem p7, size_t p8, int p9, cl_float p10, cl_mem p11, size_t p12, int p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasSspmv)(clblasOrder, clblasUplo, size_t, cl_float, const cl_mem, size_t, const cl_mem, size_t, int, cl_float, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSspmv_switch_fn; +//static const struct DynamicFnEntry clblasSspmv_definition = { "clblasSspmv", (void**)&clblasSspmv}; + +//openclamdblas_fn14(OPENCLAMDBLAS_FN_clblasSspr, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_float p4, const cl_mem p5, size_t p6, int p7, cl_mem p8, size_t p9, cl_uint p10, cl_command_queue* p11, cl_uint p12, const cl_event* p13, cl_event* p14)) +//clblasStatus (*clblasSspr)(clblasOrder, clblasUplo, size_t, cl_float, const cl_mem, size_t, int, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSspr_switch_fn; +//static const struct DynamicFnEntry clblasSspr_definition = { "clblasSspr", (void**)&clblasSspr}; + +//openclamdblas_fn17(OPENCLAMDBLAS_FN_clblasSspr2, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_float p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) +//clblasStatus (*clblasSspr2)(clblasOrder, clblasUplo, size_t, cl_float, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSspr2_switch_fn; +//static const struct DynamicFnEntry clblasSspr2_definition = { "clblasSspr2", (void**)&clblasSspr2}; + +//openclamdblas_fn12(OPENCLAMDBLAS_FN_clblasSswap, clblasStatus, (size_t p1, cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) +//clblasStatus (*clblasSswap)(size_t, cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSswap_switch_fn; +//static const struct DynamicFnEntry clblasSswap_definition = { "clblasSswap", (void**)&clblasSswap}; + +//openclamdblas_fn21(OPENCLAMDBLAS_FN_clblasSsymm, clblasStatus, (clblasOrder p1, clblasSide p2, clblasUplo p3, size_t p4, size_t p5, cl_float p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, cl_float p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) +//clblasStatus (*clblasSsymm)(clblasOrder, clblasSide, clblasUplo, size_t, size_t, cl_float, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_float, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSsymm_switch_fn; +//static const struct DynamicFnEntry clblasSsymm_definition = { "clblasSsymm", (void**)&clblasSsymm}; + +//openclamdblas_fn19(OPENCLAMDBLAS_FN_clblasSsymv, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_float p4, const cl_mem p5, size_t p6, size_t p7, const cl_mem p8, size_t p9, int p10, cl_float p11, cl_mem p12, size_t p13, int p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) +//clblasStatus (*clblasSsymv)(clblasOrder, clblasUplo, size_t, cl_float, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_float, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSsymv_switch_fn; +//static const struct DynamicFnEntry clblasSsymv_definition = { "clblasSsymv", (void**)&clblasSsymv}; + +//openclamdblas_fn15(OPENCLAMDBLAS_FN_clblasSsyr, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_float p4, const cl_mem p5, size_t p6, int p7, cl_mem p8, size_t p9, size_t p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) +//clblasStatus (*clblasSsyr)(clblasOrder, clblasUplo, size_t, cl_float, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSsyr_switch_fn; +//static const struct DynamicFnEntry clblasSsyr_definition = { "clblasSsyr", (void**)&clblasSsyr}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasSsyr2, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_float p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasSsyr2)(clblasOrder, clblasUplo, size_t, cl_float, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSsyr2_switch_fn; +//static const struct DynamicFnEntry clblasSsyr2_definition = { "clblasSsyr2", (void**)&clblasSsyr2}; + +//openclamdblas_fn21(OPENCLAMDBLAS_FN_clblasSsyr2k, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, size_t p4, size_t p5, cl_float p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, cl_float p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) +//clblasStatus (*clblasSsyr2k)(clblasOrder, clblasUplo, clblasTranspose, size_t, size_t, cl_float, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_float, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSsyr2k_switch_fn; +//static const struct DynamicFnEntry clblasSsyr2k_definition = { "clblasSsyr2k", (void**)&clblasSsyr2k}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasSsyrk, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, size_t p4, size_t p5, cl_float p6, const cl_mem p7, size_t p8, size_t p9, cl_float p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasSsyrk)(clblasOrder, clblasUplo, clblasTranspose, size_t, size_t, cl_float, const cl_mem, size_t, size_t, cl_float, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasSsyrk_switch_fn; +//static const struct DynamicFnEntry clblasSsyrk_definition = { "clblasSsyrk", (void**)&clblasSsyrk}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasStbmv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, size_t p6, const cl_mem p7, size_t p8, size_t p9, cl_mem p10, size_t p11, int p12, cl_mem p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasStbmv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasStbmv_switch_fn; +//static const struct DynamicFnEntry clblasStbmv_definition = { "clblasStbmv", (void**)&clblasStbmv}; + +//openclamdblas_fn17(OPENCLAMDBLAS_FN_clblasStbsv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, size_t p6, const cl_mem p7, size_t p8, size_t p9, cl_mem p10, size_t p11, int p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) +//clblasStatus (*clblasStbsv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasStbsv_switch_fn; +//static const struct DynamicFnEntry clblasStbsv_definition = { "clblasStbsv", (void**)&clblasStbsv}; + +//openclamdblas_fn16(OPENCLAMDBLAS_FN_clblasStpmv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, const cl_mem p6, size_t p7, cl_mem p8, size_t p9, int p10, cl_mem p11, cl_uint p12, cl_command_queue* p13, cl_uint p14, const cl_event* p15, cl_event* p16)) +//clblasStatus (*clblasStpmv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, const cl_mem, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasStpmv_switch_fn; +//static const struct DynamicFnEntry clblasStpmv_definition = { "clblasStpmv", (void**)&clblasStpmv}; + +//openclamdblas_fn15(OPENCLAMDBLAS_FN_clblasStpsv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, const cl_mem p6, size_t p7, cl_mem p8, size_t p9, int p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) +//clblasStatus (*clblasStpsv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, const cl_mem, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasStpsv_switch_fn; +//static const struct DynamicFnEntry clblasStpsv_definition = { "clblasStpsv", (void**)&clblasStpsv}; + +//openclamdblas_fn19(OPENCLAMDBLAS_FN_clblasStrmm, clblasStatus, (clblasOrder p1, clblasSide p2, clblasUplo p3, clblasTranspose p4, clblasDiag p5, size_t p6, size_t p7, cl_float p8, const cl_mem p9, size_t p10, size_t p11, cl_mem p12, size_t p13, size_t p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) +//clblasStatus (*clblasStrmm)(clblasOrder, clblasSide, clblasUplo, clblasTranspose, clblasDiag, size_t, size_t, cl_float, const cl_mem, size_t, size_t, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasStrmm_switch_fn; +//static const struct DynamicFnEntry clblasStrmm_definition = { "clblasStrmm", (void**)&clblasStrmm}; + +//openclamdblas_fn17(OPENCLAMDBLAS_FN_clblasStrmv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, const cl_mem p6, size_t p7, size_t p8, cl_mem p9, size_t p10, int p11, cl_mem p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) +//clblasStatus (*clblasStrmv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasStrmv_switch_fn; +//static const struct DynamicFnEntry clblasStrmv_definition = { "clblasStrmv", (void**)&clblasStrmv}; + +//openclamdblas_fn19(OPENCLAMDBLAS_FN_clblasStrsm, clblasStatus, (clblasOrder p1, clblasSide p2, clblasUplo p3, clblasTranspose p4, clblasDiag p5, size_t p6, size_t p7, cl_float p8, const cl_mem p9, size_t p10, size_t p11, cl_mem p12, size_t p13, size_t p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) +//clblasStatus (*clblasStrsm)(clblasOrder, clblasSide, clblasUplo, clblasTranspose, clblasDiag, size_t, size_t, cl_float, const cl_mem, size_t, size_t, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasStrsm_switch_fn; +//static const struct DynamicFnEntry clblasStrsm_definition = { "clblasStrsm", (void**)&clblasStrsm}; + +//openclamdblas_fn16(OPENCLAMDBLAS_FN_clblasStrsv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, const cl_mem p6, size_t p7, size_t p8, cl_mem p9, size_t p10, int p11, cl_uint p12, cl_command_queue* p13, cl_uint p14, const cl_event* p15, cl_event* p16)) +//clblasStatus (*clblasStrsv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasStrsv_switch_fn; +//static const struct DynamicFnEntry clblasStrsv_definition = { "clblasStrsv", (void**)&clblasStrsv}; + +openclamdblas_fn0(OPENCLAMDBLAS_FN_clblasTeardown, void, ()) +void (*clblasTeardown)() = + OPENCLAMDBLAS_FN_clblasTeardown_switch_fn; +static const struct DynamicFnEntry clblasTeardown_definition = { "clblasTeardown", (void**)&clblasTeardown}; + +//openclamdblas_fn13(OPENCLAMDBLAS_FN_clblasZaxpy, clblasStatus, (size_t p1, cl_double2 p2, const cl_mem p3, size_t p4, int p5, cl_mem p6, size_t p7, int p8, cl_uint p9, cl_command_queue* p10, cl_uint p11, const cl_event* p12, cl_event* p13)) +//clblasStatus (*clblasZaxpy)(size_t, cl_double2, const cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZaxpy_switch_fn; +//static const struct DynamicFnEntry clblasZaxpy_definition = { "clblasZaxpy", (void**)&clblasZaxpy}; + +//openclamdblas_fn12(OPENCLAMDBLAS_FN_clblasZcopy, clblasStatus, (size_t p1, const cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) +//clblasStatus (*clblasZcopy)(size_t, const cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZcopy_switch_fn; +//static const struct DynamicFnEntry clblasZcopy_definition = { "clblasZcopy", (void**)&clblasZcopy}; + +//openclamdblas_fn15(OPENCLAMDBLAS_FN_clblasZdotc, clblasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, const cl_mem p7, size_t p8, int p9, cl_mem p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) +//clblasStatus (*clblasZdotc)(size_t, cl_mem, size_t, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZdotc_switch_fn; +//static const struct DynamicFnEntry clblasZdotc_definition = { "clblasZdotc", (void**)&clblasZdotc}; + +//openclamdblas_fn15(OPENCLAMDBLAS_FN_clblasZdotu, clblasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, const cl_mem p7, size_t p8, int p9, cl_mem p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) +//clblasStatus (*clblasZdotu)(size_t, cl_mem, size_t, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZdotu_switch_fn; +//static const struct DynamicFnEntry clblasZdotu_definition = { "clblasZdotu", (void**)&clblasZdotu}; + +//openclamdblas_fn14(OPENCLAMDBLAS_FN_clblasZdrot, clblasStatus, (size_t p1, cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_double p8, cl_double p9, cl_uint p10, cl_command_queue* p11, cl_uint p12, const cl_event* p13, cl_event* p14)) +//clblasStatus (*clblasZdrot)(size_t, cl_mem, size_t, int, cl_mem, size_t, int, cl_double, cl_double, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZdrot_switch_fn; +//static const struct DynamicFnEntry clblasZdrot_definition = { "clblasZdrot", (void**)&clblasZdrot}; + +//openclamdblas_fn10(OPENCLAMDBLAS_FN_clblasZdscal, clblasStatus, (size_t p1, cl_double p2, cl_mem p3, size_t p4, int p5, cl_uint p6, cl_command_queue* p7, cl_uint p8, const cl_event* p9, cl_event* p10)) +//clblasStatus (*clblasZdscal)(size_t, cl_double, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZdscal_switch_fn; +//static const struct DynamicFnEntry clblasZdscal_definition = { "clblasZdscal", (void**)&clblasZdscal}; + +//openclamdblas_fn22(OPENCLAMDBLAS_FN_clblasZgbmv, clblasStatus, (clblasOrder p1, clblasTranspose p2, size_t p3, size_t p4, size_t p5, size_t p6, cl_double2 p7, const cl_mem p8, size_t p9, size_t p10, const cl_mem p11, size_t p12, int p13, cl_double2 p14, cl_mem p15, size_t p16, int p17, cl_uint p18, cl_command_queue* p19, cl_uint p20, const cl_event* p21, cl_event* p22)) +//clblasStatus (*clblasZgbmv)(clblasOrder, clblasTranspose, size_t, size_t, size_t, size_t, cl_double2, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_double2, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZgbmv_switch_fn; +//static const struct DynamicFnEntry clblasZgbmv_definition = { "clblasZgbmv", (void**)&clblasZgbmv}; + +openclamdblas_fn22(OPENCLAMDBLAS_FN_clblasZgemm, clblasStatus, (clblasOrder p1, clblasTranspose p2, clblasTranspose p3, size_t p4, size_t p5, size_t p6, DoubleComplex p7, const cl_mem p8, size_t p9, size_t p10, const cl_mem p11, size_t p12, size_t p13, DoubleComplex p14, cl_mem p15, size_t p16, size_t p17, cl_uint p18, cl_command_queue* p19, cl_uint p20, const cl_event* p21, cl_event* p22)) +clblasStatus (*clblasZgemm)(clblasOrder, clblasTranspose, clblasTranspose, size_t, size_t, size_t, DoubleComplex, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, DoubleComplex, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = + OPENCLAMDBLAS_FN_clblasZgemm_switch_fn; +static const struct DynamicFnEntry clblasZgemm_definition = { "clblasZgemm", (void**)&clblasZgemm}; + +//openclamdblas_fn20(OPENCLAMDBLAS_FN_clblasZgemv, clblasStatus, (clblasOrder p1, clblasTranspose p2, size_t p3, size_t p4, DoubleComplex p5, const cl_mem p6, size_t p7, size_t p8, const cl_mem p9, size_t p10, int p11, DoubleComplex p12, cl_mem p13, size_t p14, int p15, cl_uint p16, cl_command_queue* p17, cl_uint p18, const cl_event* p19, cl_event* p20)) +//clblasStatus (*clblasZgemv)(clblasOrder, clblasTranspose, size_t, size_t, DoubleComplex, const cl_mem, size_t, size_t, const cl_mem, size_t, int, DoubleComplex, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZgemv_switch_fn; +//static const struct DynamicFnEntry clblasZgemv_definition = { "clblasZgemv", (void**)&clblasZgemv}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasZgerc, clblasStatus, (clblasOrder p1, size_t p2, size_t p3, cl_double2 p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasZgerc)(clblasOrder, size_t, size_t, cl_double2, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZgerc_switch_fn; +//static const struct DynamicFnEntry clblasZgerc_definition = { "clblasZgerc", (void**)&clblasZgerc}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasZgeru, clblasStatus, (clblasOrder p1, size_t p2, size_t p3, cl_double2 p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasZgeru)(clblasOrder, size_t, size_t, cl_double2, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZgeru_switch_fn; +//static const struct DynamicFnEntry clblasZgeru_definition = { "clblasZgeru", (void**)&clblasZgeru}; + +//openclamdblas_fn20(OPENCLAMDBLAS_FN_clblasZhbmv, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, size_t p4, cl_double2 p5, const cl_mem p6, size_t p7, size_t p8, const cl_mem p9, size_t p10, int p11, cl_double2 p12, cl_mem p13, size_t p14, int p15, cl_uint p16, cl_command_queue* p17, cl_uint p18, const cl_event* p19, cl_event* p20)) +//clblasStatus (*clblasZhbmv)(clblasOrder, clblasUplo, size_t, size_t, cl_double2, const cl_mem, size_t, size_t, const cl_mem, size_t, int, cl_double2, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZhbmv_switch_fn; +//static const struct DynamicFnEntry clblasZhbmv_definition = { "clblasZhbmv", (void**)&clblasZhbmv}; + +//openclamdblas_fn21(OPENCLAMDBLAS_FN_clblasZhemm, clblasStatus, (clblasOrder p1, clblasSide p2, clblasUplo p3, size_t p4, size_t p5, cl_double2 p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, cl_double2 p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) +//clblasStatus (*clblasZhemm)(clblasOrder, clblasSide, clblasUplo, size_t, size_t, cl_double2, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_double2, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZhemm_switch_fn; +//static const struct DynamicFnEntry clblasZhemm_definition = { "clblasZhemm", (void**)&clblasZhemm}; + +//openclamdblas_fn19(OPENCLAMDBLAS_FN_clblasZhemv, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, DoubleComplex p4, const cl_mem p5, size_t p6, size_t p7, const cl_mem p8, size_t p9, int p10, DoubleComplex p11, cl_mem p12, size_t p13, int p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) +//clblasStatus (*clblasZhemv)(clblasOrder, clblasUplo, size_t, DoubleComplex, const cl_mem, size_t, size_t, const cl_mem, size_t, int, DoubleComplex, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZhemv_switch_fn; +//static const struct DynamicFnEntry clblasZhemv_definition = { "clblasZhemv", (void**)&clblasZhemv}; + +//openclamdblas_fn15(OPENCLAMDBLAS_FN_clblasZher, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_double p4, const cl_mem p5, size_t p6, int p7, cl_mem p8, size_t p9, size_t p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) +//clblasStatus (*clblasZher)(clblasOrder, clblasUplo, size_t, cl_double, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZher_switch_fn; +//static const struct DynamicFnEntry clblasZher_definition = { "clblasZher", (void**)&clblasZher}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasZher2, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_double2 p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasZher2)(clblasOrder, clblasUplo, size_t, cl_double2, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZher2_switch_fn; +//static const struct DynamicFnEntry clblasZher2_definition = { "clblasZher2", (void**)&clblasZher2}; + +//openclamdblas_fn21(OPENCLAMDBLAS_FN_clblasZher2k, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, size_t p4, size_t p5, DoubleComplex p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, cl_double p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) +//clblasStatus (*clblasZher2k)(clblasOrder, clblasUplo, clblasTranspose, size_t, size_t, DoubleComplex, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_double, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZher2k_switch_fn; +//static const struct DynamicFnEntry clblasZher2k_definition = { "clblasZher2k", (void**)&clblasZher2k}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasZherk, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, size_t p4, size_t p5, double p6, const cl_mem p7, size_t p8, size_t p9, double p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasZherk)(clblasOrder, clblasUplo, clblasTranspose, size_t, size_t, double, const cl_mem, size_t, size_t, double, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZherk_switch_fn; +//static const struct DynamicFnEntry clblasZherk_definition = { "clblasZherk", (void**)&clblasZherk}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasZhpmv, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_double2 p4, const cl_mem p5, size_t p6, const cl_mem p7, size_t p8, int p9, cl_double2 p10, cl_mem p11, size_t p12, int p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasZhpmv)(clblasOrder, clblasUplo, size_t, cl_double2, const cl_mem, size_t, const cl_mem, size_t, int, cl_double2, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZhpmv_switch_fn; +//static const struct DynamicFnEntry clblasZhpmv_definition = { "clblasZhpmv", (void**)&clblasZhpmv}; + +//openclamdblas_fn14(OPENCLAMDBLAS_FN_clblasZhpr, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_double p4, const cl_mem p5, size_t p6, int p7, cl_mem p8, size_t p9, cl_uint p10, cl_command_queue* p11, cl_uint p12, const cl_event* p13, cl_event* p14)) +//clblasStatus (*clblasZhpr)(clblasOrder, clblasUplo, size_t, cl_double, const cl_mem, size_t, int, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZhpr_switch_fn; +//static const struct DynamicFnEntry clblasZhpr_definition = { "clblasZhpr", (void**)&clblasZhpr}; + +//openclamdblas_fn17(OPENCLAMDBLAS_FN_clblasZhpr2, clblasStatus, (clblasOrder p1, clblasUplo p2, size_t p3, cl_double2 p4, const cl_mem p5, size_t p6, int p7, const cl_mem p8, size_t p9, int p10, cl_mem p11, size_t p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) +//clblasStatus (*clblasZhpr2)(clblasOrder, clblasUplo, size_t, cl_double2, const cl_mem, size_t, int, const cl_mem, size_t, int, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZhpr2_switch_fn; +//static const struct DynamicFnEntry clblasZhpr2_definition = { "clblasZhpr2", (void**)&clblasZhpr2}; + +//openclamdblas_fn13(OPENCLAMDBLAS_FN_clblasZrotg, clblasStatus, (cl_mem p1, size_t p2, cl_mem p3, size_t p4, cl_mem p5, size_t p6, cl_mem p7, size_t p8, cl_uint p9, cl_command_queue* p10, cl_uint p11, const cl_event* p12, cl_event* p13)) +//clblasStatus (*clblasZrotg)(cl_mem, size_t, cl_mem, size_t, cl_mem, size_t, cl_mem, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZrotg_switch_fn; +//static const struct DynamicFnEntry clblasZrotg_definition = { "clblasZrotg", (void**)&clblasZrotg}; + +//openclamdblas_fn10(OPENCLAMDBLAS_FN_clblasZscal, clblasStatus, (size_t p1, cl_double2 p2, cl_mem p3, size_t p4, int p5, cl_uint p6, cl_command_queue* p7, cl_uint p8, const cl_event* p9, cl_event* p10)) +//clblasStatus (*clblasZscal)(size_t, cl_double2, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZscal_switch_fn; +//static const struct DynamicFnEntry clblasZscal_definition = { "clblasZscal", (void**)&clblasZscal}; + +//openclamdblas_fn12(OPENCLAMDBLAS_FN_clblasZswap, clblasStatus, (size_t p1, cl_mem p2, size_t p3, int p4, cl_mem p5, size_t p6, int p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) +//clblasStatus (*clblasZswap)(size_t, cl_mem, size_t, int, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZswap_switch_fn; +//static const struct DynamicFnEntry clblasZswap_definition = { "clblasZswap", (void**)&clblasZswap}; + +//openclamdblas_fn21(OPENCLAMDBLAS_FN_clblasZsymm, clblasStatus, (clblasOrder p1, clblasSide p2, clblasUplo p3, size_t p4, size_t p5, cl_double2 p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, cl_double2 p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) +//clblasStatus (*clblasZsymm)(clblasOrder, clblasSide, clblasUplo, size_t, size_t, cl_double2, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, cl_double2, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZsymm_switch_fn; +//static const struct DynamicFnEntry clblasZsymm_definition = { "clblasZsymm", (void**)&clblasZsymm}; + +//openclamdblas_fn21(OPENCLAMDBLAS_FN_clblasZsyr2k, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, size_t p4, size_t p5, DoubleComplex p6, const cl_mem p7, size_t p8, size_t p9, const cl_mem p10, size_t p11, size_t p12, DoubleComplex p13, cl_mem p14, size_t p15, size_t p16, cl_uint p17, cl_command_queue* p18, cl_uint p19, const cl_event* p20, cl_event* p21)) +//clblasStatus (*clblasZsyr2k)(clblasOrder, clblasUplo, clblasTranspose, size_t, size_t, DoubleComplex, const cl_mem, size_t, size_t, const cl_mem, size_t, size_t, DoubleComplex, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZsyr2k_switch_fn; +//static const struct DynamicFnEntry clblasZsyr2k_definition = { "clblasZsyr2k", (void**)&clblasZsyr2k}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasZsyrk, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, size_t p4, size_t p5, DoubleComplex p6, const cl_mem p7, size_t p8, size_t p9, DoubleComplex p10, cl_mem p11, size_t p12, size_t p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasZsyrk)(clblasOrder, clblasUplo, clblasTranspose, size_t, size_t, DoubleComplex, const cl_mem, size_t, size_t, DoubleComplex, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZsyrk_switch_fn; +//static const struct DynamicFnEntry clblasZsyrk_definition = { "clblasZsyrk", (void**)&clblasZsyrk}; + +//openclamdblas_fn18(OPENCLAMDBLAS_FN_clblasZtbmv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, size_t p6, const cl_mem p7, size_t p8, size_t p9, cl_mem p10, size_t p11, int p12, cl_mem p13, cl_uint p14, cl_command_queue* p15, cl_uint p16, const cl_event* p17, cl_event* p18)) +//clblasStatus (*clblasZtbmv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZtbmv_switch_fn; +//static const struct DynamicFnEntry clblasZtbmv_definition = { "clblasZtbmv", (void**)&clblasZtbmv}; + +//openclamdblas_fn17(OPENCLAMDBLAS_FN_clblasZtbsv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, size_t p6, const cl_mem p7, size_t p8, size_t p9, cl_mem p10, size_t p11, int p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) +//clblasStatus (*clblasZtbsv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZtbsv_switch_fn; +//static const struct DynamicFnEntry clblasZtbsv_definition = { "clblasZtbsv", (void**)&clblasZtbsv}; + +//openclamdblas_fn16(OPENCLAMDBLAS_FN_clblasZtpmv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, const cl_mem p6, size_t p7, cl_mem p8, size_t p9, int p10, cl_mem p11, cl_uint p12, cl_command_queue* p13, cl_uint p14, const cl_event* p15, cl_event* p16)) +//clblasStatus (*clblasZtpmv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, const cl_mem, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZtpmv_switch_fn; +//static const struct DynamicFnEntry clblasZtpmv_definition = { "clblasZtpmv", (void**)&clblasZtpmv}; + +//openclamdblas_fn15(OPENCLAMDBLAS_FN_clblasZtpsv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, const cl_mem p6, size_t p7, cl_mem p8, size_t p9, int p10, cl_uint p11, cl_command_queue* p12, cl_uint p13, const cl_event* p14, cl_event* p15)) +//clblasStatus (*clblasZtpsv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, const cl_mem, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZtpsv_switch_fn; +//static const struct DynamicFnEntry clblasZtpsv_definition = { "clblasZtpsv", (void**)&clblasZtpsv}; + +//openclamdblas_fn19(OPENCLAMDBLAS_FN_clblasZtrmm, clblasStatus, (clblasOrder p1, clblasSide p2, clblasUplo p3, clblasTranspose p4, clblasDiag p5, size_t p6, size_t p7, DoubleComplex p8, const cl_mem p9, size_t p10, size_t p11, cl_mem p12, size_t p13, size_t p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) +//clblasStatus (*clblasZtrmm)(clblasOrder, clblasSide, clblasUplo, clblasTranspose, clblasDiag, size_t, size_t, DoubleComplex, const cl_mem, size_t, size_t, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZtrmm_switch_fn; +//static const struct DynamicFnEntry clblasZtrmm_definition = { "clblasZtrmm", (void**)&clblasZtrmm}; + +//openclamdblas_fn17(OPENCLAMDBLAS_FN_clblasZtrmv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, const cl_mem p6, size_t p7, size_t p8, cl_mem p9, size_t p10, int p11, cl_mem p12, cl_uint p13, cl_command_queue* p14, cl_uint p15, const cl_event* p16, cl_event* p17)) +//clblasStatus (*clblasZtrmv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZtrmv_switch_fn; +//static const struct DynamicFnEntry clblasZtrmv_definition = { "clblasZtrmv", (void**)&clblasZtrmv}; + +//openclamdblas_fn19(OPENCLAMDBLAS_FN_clblasZtrsm, clblasStatus, (clblasOrder p1, clblasSide p2, clblasUplo p3, clblasTranspose p4, clblasDiag p5, size_t p6, size_t p7, DoubleComplex p8, const cl_mem p9, size_t p10, size_t p11, cl_mem p12, size_t p13, size_t p14, cl_uint p15, cl_command_queue* p16, cl_uint p17, const cl_event* p18, cl_event* p19)) +//clblasStatus (*clblasZtrsm)(clblasOrder, clblasSide, clblasUplo, clblasTranspose, clblasDiag, size_t, size_t, DoubleComplex, const cl_mem, size_t, size_t, cl_mem, size_t, size_t, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZtrsm_switch_fn; +//static const struct DynamicFnEntry clblasZtrsm_definition = { "clblasZtrsm", (void**)&clblasZtrsm}; + +//openclamdblas_fn16(OPENCLAMDBLAS_FN_clblasZtrsv, clblasStatus, (clblasOrder p1, clblasUplo p2, clblasTranspose p3, clblasDiag p4, size_t p5, const cl_mem p6, size_t p7, size_t p8, cl_mem p9, size_t p10, int p11, cl_uint p12, cl_command_queue* p13, cl_uint p14, const cl_event* p15, cl_event* p16)) +//clblasStatus (*clblasZtrsv)(clblasOrder, clblasUplo, clblasTranspose, clblasDiag, size_t, const cl_mem, size_t, size_t, cl_mem, size_t, int, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasZtrsv_switch_fn; +//static const struct DynamicFnEntry clblasZtrsv_definition = { "clblasZtrsv", (void**)&clblasZtrsv}; + +//openclamdblas_fn12(OPENCLAMDBLAS_FN_clblasiCamax, clblasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) +//clblasStatus (*clblasiCamax)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasiCamax_switch_fn; +//static const struct DynamicFnEntry clblasiCamax_definition = { "clblasiCamax", (void**)&clblasiCamax}; + +//openclamdblas_fn12(OPENCLAMDBLAS_FN_clblasiDamax, clblasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) +//clblasStatus (*clblasiDamax)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasiDamax_switch_fn; +//static const struct DynamicFnEntry clblasiDamax_definition = { "clblasiDamax", (void**)&clblasiDamax}; + +//openclamdblas_fn12(OPENCLAMDBLAS_FN_clblasiSamax, clblasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) +//clblasStatus (*clblasiSamax)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasiSamax_switch_fn; +//static const struct DynamicFnEntry clblasiSamax_definition = { "clblasiSamax", (void**)&clblasiSamax}; + +//openclamdblas_fn12(OPENCLAMDBLAS_FN_clblasiZamax, clblasStatus, (size_t p1, cl_mem p2, size_t p3, const cl_mem p4, size_t p5, int p6, cl_mem p7, cl_uint p8, cl_command_queue* p9, cl_uint p10, const cl_event* p11, cl_event* p12)) +//clblasStatus (*clblasiZamax)(size_t, cl_mem, size_t, const cl_mem, size_t, int, cl_mem, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*) = +// OPENCLAMDBLAS_FN_clblasiZamax_switch_fn; +//static const struct DynamicFnEntry clblasiZamax_definition = { "clblasiZamax", (void**)&clblasiZamax}; + + +// generated by parser_clblas.py +static const struct DynamicFnEntry* openclamdblas_fn[] = { + NULL/*&clblasCaxpy_definition*/, + NULL/*&clblasCcopy_definition*/, + NULL/*&clblasCdotc_definition*/, + NULL/*&clblasCdotu_definition*/, + NULL/*&clblasCgbmv_definition*/, + &clblasCgemm_definition, + NULL/*&clblasCgemv_definition*/, + NULL/*&clblasCgerc_definition*/, + NULL/*&clblasCgeru_definition*/, + NULL/*&clblasChbmv_definition*/, + NULL/*&clblasChemm_definition*/, + NULL/*&clblasChemv_definition*/, + NULL/*&clblasCher_definition*/, + NULL/*&clblasCher2_definition*/, + NULL/*&clblasCher2k_definition*/, + NULL/*&clblasCherk_definition*/, + NULL/*&clblasChpmv_definition*/, + NULL/*&clblasChpr_definition*/, + NULL/*&clblasChpr2_definition*/, + NULL/*&clblasCrotg_definition*/, + NULL/*&clblasCscal_definition*/, + NULL/*&clblasCsrot_definition*/, + NULL/*&clblasCsscal_definition*/, + NULL/*&clblasCswap_definition*/, + NULL/*&clblasCsymm_definition*/, + NULL/*&clblasCsyr2k_definition*/, + NULL/*&clblasCsyrk_definition*/, + NULL/*&clblasCtbmv_definition*/, + NULL/*&clblasCtbsv_definition*/, + NULL/*&clblasCtpmv_definition*/, + NULL/*&clblasCtpsv_definition*/, + NULL/*&clblasCtrmm_definition*/, + NULL/*&clblasCtrmv_definition*/, + NULL/*&clblasCtrsm_definition*/, + NULL/*&clblasCtrsv_definition*/, + NULL/*&clblasDasum_definition*/, + NULL/*&clblasDaxpy_definition*/, + NULL/*&clblasDcopy_definition*/, + NULL/*&clblasDdot_definition*/, + NULL/*&clblasDgbmv_definition*/, + &clblasDgemm_definition, + NULL/*&clblasDgemv_definition*/, + NULL/*&clblasDger_definition*/, + NULL/*&clblasDnrm2_definition*/, + NULL/*&clblasDrot_definition*/, + NULL/*&clblasDrotg_definition*/, + NULL/*&clblasDrotm_definition*/, + NULL/*&clblasDrotmg_definition*/, + NULL/*&clblasDsbmv_definition*/, + NULL/*&clblasDscal_definition*/, + NULL/*&clblasDspmv_definition*/, + NULL/*&clblasDspr_definition*/, + NULL/*&clblasDspr2_definition*/, + NULL/*&clblasDswap_definition*/, + NULL/*&clblasDsymm_definition*/, + NULL/*&clblasDsymv_definition*/, + NULL/*&clblasDsyr_definition*/, + NULL/*&clblasDsyr2_definition*/, + NULL/*&clblasDsyr2k_definition*/, + NULL/*&clblasDsyrk_definition*/, + NULL/*&clblasDtbmv_definition*/, + NULL/*&clblasDtbsv_definition*/, + NULL/*&clblasDtpmv_definition*/, + NULL/*&clblasDtpsv_definition*/, + NULL/*&clblasDtrmm_definition*/, + NULL/*&clblasDtrmv_definition*/, + NULL/*&clblasDtrsm_definition*/, + NULL/*&clblasDtrsv_definition*/, + NULL/*&clblasDzasum_definition*/, + NULL/*&clblasDznrm2_definition*/, + NULL/*&clblasGetVersion_definition*/, + NULL/*&clblasSasum_definition*/, + NULL/*&clblasSaxpy_definition*/, + NULL/*&clblasScasum_definition*/, + NULL/*&clblasScnrm2_definition*/, + NULL/*&clblasScopy_definition*/, + NULL/*&clblasSdot_definition*/, + &clblasSetup_definition, + NULL/*&clblasSgbmv_definition*/, + &clblasSgemm_definition, + NULL/*&clblasSgemv_definition*/, + NULL/*&clblasSger_definition*/, + NULL/*&clblasSnrm2_definition*/, + NULL/*&clblasSrot_definition*/, + NULL/*&clblasSrotg_definition*/, + NULL/*&clblasSrotm_definition*/, + NULL/*&clblasSrotmg_definition*/, + NULL/*&clblasSsbmv_definition*/, + NULL/*&clblasSscal_definition*/, + NULL/*&clblasSspmv_definition*/, + NULL/*&clblasSspr_definition*/, + NULL/*&clblasSspr2_definition*/, + NULL/*&clblasSswap_definition*/, + NULL/*&clblasSsymm_definition*/, + NULL/*&clblasSsymv_definition*/, + NULL/*&clblasSsyr_definition*/, + NULL/*&clblasSsyr2_definition*/, + NULL/*&clblasSsyr2k_definition*/, + NULL/*&clblasSsyrk_definition*/, + NULL/*&clblasStbmv_definition*/, + NULL/*&clblasStbsv_definition*/, + NULL/*&clblasStpmv_definition*/, + NULL/*&clblasStpsv_definition*/, + NULL/*&clblasStrmm_definition*/, + NULL/*&clblasStrmv_definition*/, + NULL/*&clblasStrsm_definition*/, + NULL/*&clblasStrsv_definition*/, + &clblasTeardown_definition, + NULL/*&clblasZaxpy_definition*/, + NULL/*&clblasZcopy_definition*/, + NULL/*&clblasZdotc_definition*/, + NULL/*&clblasZdotu_definition*/, + NULL/*&clblasZdrot_definition*/, + NULL/*&clblasZdscal_definition*/, + NULL/*&clblasZgbmv_definition*/, + &clblasZgemm_definition, + NULL/*&clblasZgemv_definition*/, + NULL/*&clblasZgerc_definition*/, + NULL/*&clblasZgeru_definition*/, + NULL/*&clblasZhbmv_definition*/, + NULL/*&clblasZhemm_definition*/, + NULL/*&clblasZhemv_definition*/, + NULL/*&clblasZher_definition*/, + NULL/*&clblasZher2_definition*/, + NULL/*&clblasZher2k_definition*/, + NULL/*&clblasZherk_definition*/, + NULL/*&clblasZhpmv_definition*/, + NULL/*&clblasZhpr_definition*/, + NULL/*&clblasZhpr2_definition*/, + NULL/*&clblasZrotg_definition*/, + NULL/*&clblasZscal_definition*/, + NULL/*&clblasZswap_definition*/, + NULL/*&clblasZsymm_definition*/, + NULL/*&clblasZsyr2k_definition*/, + NULL/*&clblasZsyrk_definition*/, + NULL/*&clblasZtbmv_definition*/, + NULL/*&clblasZtbsv_definition*/, + NULL/*&clblasZtpmv_definition*/, + NULL/*&clblasZtpsv_definition*/, + NULL/*&clblasZtrmm_definition*/, + NULL/*&clblasZtrmv_definition*/, + NULL/*&clblasZtrsm_definition*/, + NULL/*&clblasZtrsv_definition*/, + NULL/*&clblasiCamax_definition*/, + NULL/*&clblasiDamax_definition*/, + NULL/*&clblasiSamax_definition*/, + NULL/*&clblasiZamax_definition*/, +}; + +// number of enabled functions: 6 diff --git a/modules/core/src/opencl/runtime/autogenerated/opencl_clfft_impl.hpp b/modules/core/src/opencl/runtime/autogenerated/opencl_clfft_impl.hpp new file mode 100644 index 0000000000..9876582fa0 --- /dev/null +++ b/modules/core/src/opencl/runtime/autogenerated/opencl_clfft_impl.hpp @@ -0,0 +1,364 @@ +// +// AUTOGENERATED, DO NOT EDIT +// +// generated by parser_clfft.py +enum OPENCLAMDFFT_FN_ID { + OPENCLAMDFFT_FN_clfftBakePlan = 0, +// OPENCLAMDFFT_FN_clfftCopyPlan = 1, + OPENCLAMDFFT_FN_clfftCreateDefaultPlan = 2, + OPENCLAMDFFT_FN_clfftDestroyPlan = 3, + OPENCLAMDFFT_FN_clfftEnqueueTransform = 4, +// OPENCLAMDFFT_FN_clfftGetLayout = 5, +// OPENCLAMDFFT_FN_clfftGetPlanBatchSize = 6, +// OPENCLAMDFFT_FN_clfftGetPlanContext = 7, +// OPENCLAMDFFT_FN_clfftGetPlanDim = 8, +// OPENCLAMDFFT_FN_clfftGetPlanDistance = 9, +// OPENCLAMDFFT_FN_clfftGetPlanInStride = 10, +// OPENCLAMDFFT_FN_clfftGetPlanLength = 11, +// OPENCLAMDFFT_FN_clfftGetPlanOutStride = 12, +// OPENCLAMDFFT_FN_clfftGetPlanPrecision = 13, +// OPENCLAMDFFT_FN_clfftGetPlanScale = 14, +// OPENCLAMDFFT_FN_clfftGetPlanTransposeResult = 15, +// OPENCLAMDFFT_FN_clfftGetResultLocation = 16, + OPENCLAMDFFT_FN_clfftGetTmpBufSize = 17, + OPENCLAMDFFT_FN_clfftGetVersion = 18, + OPENCLAMDFFT_FN_clfftSetLayout = 19, + OPENCLAMDFFT_FN_clfftSetPlanBatchSize = 20, +// OPENCLAMDFFT_FN_clfftSetPlanCallback = 21, +// OPENCLAMDFFT_FN_clfftSetPlanDim = 22, + OPENCLAMDFFT_FN_clfftSetPlanDistance = 23, + OPENCLAMDFFT_FN_clfftSetPlanInStride = 24, +// OPENCLAMDFFT_FN_clfftSetPlanLength = 25, + OPENCLAMDFFT_FN_clfftSetPlanOutStride = 26, + OPENCLAMDFFT_FN_clfftSetPlanPrecision = 27, + OPENCLAMDFFT_FN_clfftSetPlanScale = 28, +// OPENCLAMDFFT_FN_clfftSetPlanTransposeResult = 29, + OPENCLAMDFFT_FN_clfftSetResultLocation = 30, + OPENCLAMDFFT_FN_clfftSetup = 31, + OPENCLAMDFFT_FN_clfftTeardown = 32, +}; + +namespace { +// generated by parser_clfft.py +#define openclamdfft_fn0(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(); } \ + +#define openclamdfft_fn1(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1); } \ + +#define openclamdfft_fn2(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2); } \ + +#define openclamdfft_fn3(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3); } \ + +#define openclamdfft_fn4(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4); } \ + +#define openclamdfft_fn5(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5); } \ + +#define openclamdfft_fn6(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6); } \ + +#define openclamdfft_fn7(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7); } \ + +#define openclamdfft_fn8(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8); } \ + +#define openclamdfft_fn9(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9); } \ + +#define openclamdfft_fn10(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); } \ + +#define openclamdfft_fn11(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); } \ + +#define openclamdfft_fn12(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); } \ + +#define openclamdfft_fn13(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); } \ + +#define openclamdfft_fn14(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); } \ + +#define openclamdfft_fn15(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); } \ + +#define openclamdfft_fn16(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); } \ + +#define openclamdfft_fn17(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17); } \ + +#define openclamdfft_fn18(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18); } \ + +#define openclamdfft_fn19(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19); } \ + +#define openclamdfft_fn20(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20); } \ + +#define openclamdfft_fn21(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21); } \ + +#define openclamdfft_fn22(ID, _R, decl_args) \ + typedef _R (*ID##FN)decl_args; \ + static _R ID##_switch_fn decl_args \ + { return ((ID##FN)openclamdfft_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22); } \ + +} + +// generated by parser_clfft.py +openclamdfft_fn5(OPENCLAMDFFT_FN_clfftBakePlan, clfftStatus, (clfftPlanHandle p1, cl_uint p2, cl_command_queue* p3, void (CL_CALLBACK*p4) (clfftPlanHandle plHandle, void* user_data), void* p5)) +clfftStatus (*clfftBakePlan)(clfftPlanHandle, cl_uint, cl_command_queue*, void (CL_CALLBACK*) (clfftPlanHandle plHandle, void* user_data), void*) = + OPENCLAMDFFT_FN_clfftBakePlan_switch_fn; +static const struct DynamicFnEntry clfftBakePlan_definition = { "clfftBakePlan", (void**)&clfftBakePlan}; + +//openclamdfft_fn3(OPENCLAMDFFT_FN_clfftCopyPlan, clfftStatus, (clfftPlanHandle* p1, cl_context p2, clfftPlanHandle p3)) +//clfftStatus (*clfftCopyPlan)(clfftPlanHandle*, cl_context, clfftPlanHandle) = +// OPENCLAMDFFT_FN_clfftCopyPlan_switch_fn; +//static const struct DynamicFnEntry clfftCopyPlan_definition = { "clfftCopyPlan", (void**)&clfftCopyPlan}; + +openclamdfft_fn4(OPENCLAMDFFT_FN_clfftCreateDefaultPlan, clfftStatus, (clfftPlanHandle* p1, cl_context p2, const clfftDim p3, const size_t* p4)) +clfftStatus (*clfftCreateDefaultPlan)(clfftPlanHandle*, cl_context, const clfftDim, const size_t*) = + OPENCLAMDFFT_FN_clfftCreateDefaultPlan_switch_fn; +static const struct DynamicFnEntry clfftCreateDefaultPlan_definition = { "clfftCreateDefaultPlan", (void**)&clfftCreateDefaultPlan}; + +openclamdfft_fn1(OPENCLAMDFFT_FN_clfftDestroyPlan, clfftStatus, (clfftPlanHandle* p1)) +clfftStatus (*clfftDestroyPlan)(clfftPlanHandle*) = + OPENCLAMDFFT_FN_clfftDestroyPlan_switch_fn; +static const struct DynamicFnEntry clfftDestroyPlan_definition = { "clfftDestroyPlan", (void**)&clfftDestroyPlan}; + +openclamdfft_fn10(OPENCLAMDFFT_FN_clfftEnqueueTransform, clfftStatus, (clfftPlanHandle p1, clfftDirection p2, cl_uint p3, cl_command_queue* p4, cl_uint p5, const cl_event* p6, cl_event* p7, cl_mem* p8, cl_mem* p9, cl_mem p10)) +clfftStatus (*clfftEnqueueTransform)(clfftPlanHandle, clfftDirection, cl_uint, cl_command_queue*, cl_uint, const cl_event*, cl_event*, cl_mem*, cl_mem*, cl_mem) = + OPENCLAMDFFT_FN_clfftEnqueueTransform_switch_fn; +static const struct DynamicFnEntry clfftEnqueueTransform_definition = { "clfftEnqueueTransform", (void**)&clfftEnqueueTransform}; + +//openclamdfft_fn3(OPENCLAMDFFT_FN_clfftGetLayout, clfftStatus, (const clfftPlanHandle p1, clfftLayout* p2, clfftLayout* p3)) +//clfftStatus (*clfftGetLayout)(const clfftPlanHandle, clfftLayout*, clfftLayout*) = +// OPENCLAMDFFT_FN_clfftGetLayout_switch_fn; +//static const struct DynamicFnEntry clfftGetLayout_definition = { "clfftGetLayout", (void**)&clfftGetLayout}; + +//openclamdfft_fn2(OPENCLAMDFFT_FN_clfftGetPlanBatchSize, clfftStatus, (const clfftPlanHandle p1, size_t* p2)) +//clfftStatus (*clfftGetPlanBatchSize)(const clfftPlanHandle, size_t*) = +// OPENCLAMDFFT_FN_clfftGetPlanBatchSize_switch_fn; +//static const struct DynamicFnEntry clfftGetPlanBatchSize_definition = { "clfftGetPlanBatchSize", (void**)&clfftGetPlanBatchSize}; + +//openclamdfft_fn2(OPENCLAMDFFT_FN_clfftGetPlanContext, clfftStatus, (const clfftPlanHandle p1, cl_context* p2)) +//clfftStatus (*clfftGetPlanContext)(const clfftPlanHandle, cl_context*) = +// OPENCLAMDFFT_FN_clfftGetPlanContext_switch_fn; +//static const struct DynamicFnEntry clfftGetPlanContext_definition = { "clfftGetPlanContext", (void**)&clfftGetPlanContext}; + +//openclamdfft_fn3(OPENCLAMDFFT_FN_clfftGetPlanDim, clfftStatus, (const clfftPlanHandle p1, clfftDim* p2, cl_uint* p3)) +//clfftStatus (*clfftGetPlanDim)(const clfftPlanHandle, clfftDim*, cl_uint*) = +// OPENCLAMDFFT_FN_clfftGetPlanDim_switch_fn; +//static const struct DynamicFnEntry clfftGetPlanDim_definition = { "clfftGetPlanDim", (void**)&clfftGetPlanDim}; + +//openclamdfft_fn3(OPENCLAMDFFT_FN_clfftGetPlanDistance, clfftStatus, (const clfftPlanHandle p1, size_t* p2, size_t* p3)) +//clfftStatus (*clfftGetPlanDistance)(const clfftPlanHandle, size_t*, size_t*) = +// OPENCLAMDFFT_FN_clfftGetPlanDistance_switch_fn; +//static const struct DynamicFnEntry clfftGetPlanDistance_definition = { "clfftGetPlanDistance", (void**)&clfftGetPlanDistance}; + +//openclamdfft_fn3(OPENCLAMDFFT_FN_clfftGetPlanInStride, clfftStatus, (const clfftPlanHandle p1, const clfftDim p2, size_t* p3)) +//clfftStatus (*clfftGetPlanInStride)(const clfftPlanHandle, const clfftDim, size_t*) = +// OPENCLAMDFFT_FN_clfftGetPlanInStride_switch_fn; +//static const struct DynamicFnEntry clfftGetPlanInStride_definition = { "clfftGetPlanInStride", (void**)&clfftGetPlanInStride}; + +//openclamdfft_fn3(OPENCLAMDFFT_FN_clfftGetPlanLength, clfftStatus, (const clfftPlanHandle p1, const clfftDim p2, size_t* p3)) +//clfftStatus (*clfftGetPlanLength)(const clfftPlanHandle, const clfftDim, size_t*) = +// OPENCLAMDFFT_FN_clfftGetPlanLength_switch_fn; +//static const struct DynamicFnEntry clfftGetPlanLength_definition = { "clfftGetPlanLength", (void**)&clfftGetPlanLength}; + +//openclamdfft_fn3(OPENCLAMDFFT_FN_clfftGetPlanOutStride, clfftStatus, (const clfftPlanHandle p1, const clfftDim p2, size_t* p3)) +//clfftStatus (*clfftGetPlanOutStride)(const clfftPlanHandle, const clfftDim, size_t*) = +// OPENCLAMDFFT_FN_clfftGetPlanOutStride_switch_fn; +//static const struct DynamicFnEntry clfftGetPlanOutStride_definition = { "clfftGetPlanOutStride", (void**)&clfftGetPlanOutStride}; + +//openclamdfft_fn2(OPENCLAMDFFT_FN_clfftGetPlanPrecision, clfftStatus, (const clfftPlanHandle p1, clfftPrecision* p2)) +//clfftStatus (*clfftGetPlanPrecision)(const clfftPlanHandle, clfftPrecision*) = +// OPENCLAMDFFT_FN_clfftGetPlanPrecision_switch_fn; +//static const struct DynamicFnEntry clfftGetPlanPrecision_definition = { "clfftGetPlanPrecision", (void**)&clfftGetPlanPrecision}; + +//openclamdfft_fn3(OPENCLAMDFFT_FN_clfftGetPlanScale, clfftStatus, (const clfftPlanHandle p1, clfftDirection p2, cl_float* p3)) +//clfftStatus (*clfftGetPlanScale)(const clfftPlanHandle, clfftDirection, cl_float*) = +// OPENCLAMDFFT_FN_clfftGetPlanScale_switch_fn; +//static const struct DynamicFnEntry clfftGetPlanScale_definition = { "clfftGetPlanScale", (void**)&clfftGetPlanScale}; + +//openclamdfft_fn2(OPENCLAMDFFT_FN_clfftGetPlanTransposeResult, clfftStatus, (const clfftPlanHandle p1, clfftResultTransposed* p2)) +//clfftStatus (*clfftGetPlanTransposeResult)(const clfftPlanHandle, clfftResultTransposed*) = +// OPENCLAMDFFT_FN_clfftGetPlanTransposeResult_switch_fn; +//static const struct DynamicFnEntry clfftGetPlanTransposeResult_definition = { "clfftGetPlanTransposeResult", (void**)&clfftGetPlanTransposeResult}; + +//openclamdfft_fn2(OPENCLAMDFFT_FN_clfftGetResultLocation, clfftStatus, (const clfftPlanHandle p1, clfftResultLocation* p2)) +//clfftStatus (*clfftGetResultLocation)(const clfftPlanHandle, clfftResultLocation*) = +// OPENCLAMDFFT_FN_clfftGetResultLocation_switch_fn; +//static const struct DynamicFnEntry clfftGetResultLocation_definition = { "clfftGetResultLocation", (void**)&clfftGetResultLocation}; + +openclamdfft_fn2(OPENCLAMDFFT_FN_clfftGetTmpBufSize, clfftStatus, (const clfftPlanHandle p1, size_t* p2)) +clfftStatus (*clfftGetTmpBufSize)(const clfftPlanHandle, size_t*) = + OPENCLAMDFFT_FN_clfftGetTmpBufSize_switch_fn; +static const struct DynamicFnEntry clfftGetTmpBufSize_definition = { "clfftGetTmpBufSize", (void**)&clfftGetTmpBufSize}; + +openclamdfft_fn3(OPENCLAMDFFT_FN_clfftGetVersion, clfftStatus, (cl_uint* p1, cl_uint* p2, cl_uint* p3)) +clfftStatus (*clfftGetVersion)(cl_uint*, cl_uint*, cl_uint*) = + OPENCLAMDFFT_FN_clfftGetVersion_switch_fn; +static const struct DynamicFnEntry clfftGetVersion_definition = { "clfftGetVersion", (void**)&clfftGetVersion}; + +openclamdfft_fn3(OPENCLAMDFFT_FN_clfftSetLayout, clfftStatus, (clfftPlanHandle p1, clfftLayout p2, clfftLayout p3)) +clfftStatus (*clfftSetLayout)(clfftPlanHandle, clfftLayout, clfftLayout) = + OPENCLAMDFFT_FN_clfftSetLayout_switch_fn; +static const struct DynamicFnEntry clfftSetLayout_definition = { "clfftSetLayout", (void**)&clfftSetLayout}; + +openclamdfft_fn2(OPENCLAMDFFT_FN_clfftSetPlanBatchSize, clfftStatus, (clfftPlanHandle p1, size_t p2)) +clfftStatus (*clfftSetPlanBatchSize)(clfftPlanHandle, size_t) = + OPENCLAMDFFT_FN_clfftSetPlanBatchSize_switch_fn; +static const struct DynamicFnEntry clfftSetPlanBatchSize_definition = { "clfftSetPlanBatchSize", (void**)&clfftSetPlanBatchSize}; + +//openclamdfft_fn7(OPENCLAMDFFT_FN_clfftSetPlanCallback, clfftStatus, (clfftPlanHandle p1, const char* p2, const char* p3, int p4, clfftCallbackType p5, cl_mem* p6, int p7)) +//clfftStatus (*clfftSetPlanCallback)(clfftPlanHandle, const char*, const char*, int, clfftCallbackType, cl_mem*, int) = +// OPENCLAMDFFT_FN_clfftSetPlanCallback_switch_fn; +//static const struct DynamicFnEntry clfftSetPlanCallback_definition = { "clfftSetPlanCallback", (void**)&clfftSetPlanCallback}; + +//openclamdfft_fn2(OPENCLAMDFFT_FN_clfftSetPlanDim, clfftStatus, (clfftPlanHandle p1, const clfftDim p2)) +//clfftStatus (*clfftSetPlanDim)(clfftPlanHandle, const clfftDim) = +// OPENCLAMDFFT_FN_clfftSetPlanDim_switch_fn; +//static const struct DynamicFnEntry clfftSetPlanDim_definition = { "clfftSetPlanDim", (void**)&clfftSetPlanDim}; + +openclamdfft_fn3(OPENCLAMDFFT_FN_clfftSetPlanDistance, clfftStatus, (clfftPlanHandle p1, size_t p2, size_t p3)) +clfftStatus (*clfftSetPlanDistance)(clfftPlanHandle, size_t, size_t) = + OPENCLAMDFFT_FN_clfftSetPlanDistance_switch_fn; +static const struct DynamicFnEntry clfftSetPlanDistance_definition = { "clfftSetPlanDistance", (void**)&clfftSetPlanDistance}; + +openclamdfft_fn3(OPENCLAMDFFT_FN_clfftSetPlanInStride, clfftStatus, (clfftPlanHandle p1, const clfftDim p2, size_t* p3)) +clfftStatus (*clfftSetPlanInStride)(clfftPlanHandle, const clfftDim, size_t*) = + OPENCLAMDFFT_FN_clfftSetPlanInStride_switch_fn; +static const struct DynamicFnEntry clfftSetPlanInStride_definition = { "clfftSetPlanInStride", (void**)&clfftSetPlanInStride}; + +//openclamdfft_fn3(OPENCLAMDFFT_FN_clfftSetPlanLength, clfftStatus, (clfftPlanHandle p1, const clfftDim p2, const size_t* p3)) +//clfftStatus (*clfftSetPlanLength)(clfftPlanHandle, const clfftDim, const size_t*) = +// OPENCLAMDFFT_FN_clfftSetPlanLength_switch_fn; +//static const struct DynamicFnEntry clfftSetPlanLength_definition = { "clfftSetPlanLength", (void**)&clfftSetPlanLength}; + +openclamdfft_fn3(OPENCLAMDFFT_FN_clfftSetPlanOutStride, clfftStatus, (clfftPlanHandle p1, const clfftDim p2, size_t* p3)) +clfftStatus (*clfftSetPlanOutStride)(clfftPlanHandle, const clfftDim, size_t*) = + OPENCLAMDFFT_FN_clfftSetPlanOutStride_switch_fn; +static const struct DynamicFnEntry clfftSetPlanOutStride_definition = { "clfftSetPlanOutStride", (void**)&clfftSetPlanOutStride}; + +openclamdfft_fn2(OPENCLAMDFFT_FN_clfftSetPlanPrecision, clfftStatus, (clfftPlanHandle p1, clfftPrecision p2)) +clfftStatus (*clfftSetPlanPrecision)(clfftPlanHandle, clfftPrecision) = + OPENCLAMDFFT_FN_clfftSetPlanPrecision_switch_fn; +static const struct DynamicFnEntry clfftSetPlanPrecision_definition = { "clfftSetPlanPrecision", (void**)&clfftSetPlanPrecision}; + +openclamdfft_fn3(OPENCLAMDFFT_FN_clfftSetPlanScale, clfftStatus, (clfftPlanHandle p1, clfftDirection p2, cl_float p3)) +clfftStatus (*clfftSetPlanScale)(clfftPlanHandle, clfftDirection, cl_float) = + OPENCLAMDFFT_FN_clfftSetPlanScale_switch_fn; +static const struct DynamicFnEntry clfftSetPlanScale_definition = { "clfftSetPlanScale", (void**)&clfftSetPlanScale}; + +//openclamdfft_fn2(OPENCLAMDFFT_FN_clfftSetPlanTransposeResult, clfftStatus, (clfftPlanHandle p1, clfftResultTransposed p2)) +//clfftStatus (*clfftSetPlanTransposeResult)(clfftPlanHandle, clfftResultTransposed) = +// OPENCLAMDFFT_FN_clfftSetPlanTransposeResult_switch_fn; +//static const struct DynamicFnEntry clfftSetPlanTransposeResult_definition = { "clfftSetPlanTransposeResult", (void**)&clfftSetPlanTransposeResult}; + +openclamdfft_fn2(OPENCLAMDFFT_FN_clfftSetResultLocation, clfftStatus, (clfftPlanHandle p1, clfftResultLocation p2)) +clfftStatus (*clfftSetResultLocation)(clfftPlanHandle, clfftResultLocation) = + OPENCLAMDFFT_FN_clfftSetResultLocation_switch_fn; +static const struct DynamicFnEntry clfftSetResultLocation_definition = { "clfftSetResultLocation", (void**)&clfftSetResultLocation}; + +openclamdfft_fn1(OPENCLAMDFFT_FN_clfftSetup, clfftStatus, (const clfftSetupData* p1)) +clfftStatus (*clfftSetup)(const clfftSetupData*) = + OPENCLAMDFFT_FN_clfftSetup_switch_fn; +static const struct DynamicFnEntry clfftSetup_definition = { "clfftSetup", (void**)&clfftSetup}; + +openclamdfft_fn0(OPENCLAMDFFT_FN_clfftTeardown, clfftStatus, ()) +clfftStatus (*clfftTeardown)() = + OPENCLAMDFFT_FN_clfftTeardown_switch_fn; +static const struct DynamicFnEntry clfftTeardown_definition = { "clfftTeardown", (void**)&clfftTeardown}; + + +// generated by parser_clfft.py +static const struct DynamicFnEntry* openclamdfft_fn[] = { + &clfftBakePlan_definition, + NULL/*&clfftCopyPlan_definition*/, + &clfftCreateDefaultPlan_definition, + &clfftDestroyPlan_definition, + &clfftEnqueueTransform_definition, + NULL/*&clfftGetLayout_definition*/, + NULL/*&clfftGetPlanBatchSize_definition*/, + NULL/*&clfftGetPlanContext_definition*/, + NULL/*&clfftGetPlanDim_definition*/, + NULL/*&clfftGetPlanDistance_definition*/, + NULL/*&clfftGetPlanInStride_definition*/, + NULL/*&clfftGetPlanLength_definition*/, + NULL/*&clfftGetPlanOutStride_definition*/, + NULL/*&clfftGetPlanPrecision_definition*/, + NULL/*&clfftGetPlanScale_definition*/, + NULL/*&clfftGetPlanTransposeResult_definition*/, + NULL/*&clfftGetResultLocation_definition*/, + &clfftGetTmpBufSize_definition, + &clfftGetVersion_definition, + &clfftSetLayout_definition, + &clfftSetPlanBatchSize_definition, + NULL/*&clfftSetPlanCallback_definition*/, + NULL/*&clfftSetPlanDim_definition*/, + &clfftSetPlanDistance_definition, + &clfftSetPlanInStride_definition, + NULL/*&clfftSetPlanLength_definition*/, + &clfftSetPlanOutStride_definition, + &clfftSetPlanPrecision_definition, + &clfftSetPlanScale_definition, + NULL/*&clfftSetPlanTransposeResult_definition*/, + &clfftSetResultLocation_definition, + &clfftSetup_definition, + &clfftTeardown_definition, +}; + +// number of enabled functions: 16 diff --git a/modules/core/src/opencl/runtime/generator/common.py b/modules/core/src/opencl/runtime/generator/common.py index 73fe6b0f47..5bfabd2989 100644 --- a/modules/core/src/opencl/runtime/generator/common.py +++ b/modules/core/src/opencl/runtime/generator/common.py @@ -116,7 +116,7 @@ def readFunctionFilter(fns, fileName): def outputToString(f): def wrapped(*args, **kwargs): - from cStringIO import StringIO + from io import StringIO old_stdout = sys.stdout sys.stdout = str_stdout = StringIO() res = f(*args, **kwargs) diff --git a/modules/core/src/opencl/runtime/generator/filter/opencl_clamdblas_functions.list b/modules/core/src/opencl/runtime/generator/filter/opencl_clamdblas_functions.list deleted file mode 100644 index 2b1f0768ec..0000000000 --- a/modules/core/src/opencl/runtime/generator/filter/opencl_clamdblas_functions.list +++ /dev/null @@ -1,176 +0,0 @@ -//clAmdBlasAddScratchImage -//clAmdBlasCaxpy -//clAmdBlasCcopy -//clAmdBlasCdotc -//clAmdBlasCdotu -//clAmdBlasCgbmv -//clAmdBlasCgemm -clAmdBlasCgemmEx -//clAmdBlasCgemv -//clAmdBlasCgemvEx -//clAmdBlasCgerc -//clAmdBlasCgeru -//clAmdBlasChbmv -//clAmdBlasChemm -//clAmdBlasChemv -//clAmdBlasCher -//clAmdBlasCher2 -//clAmdBlasCher2k -//clAmdBlasCherk -//clAmdBlasChpmv -//clAmdBlasChpr -//clAmdBlasChpr2 -//clAmdBlasCrotg -//clAmdBlasCscal -//clAmdBlasCsrot -//clAmdBlasCsscal -//clAmdBlasCswap -//clAmdBlasCsymm -//clAmdBlasCsyr2k -//clAmdBlasCsyr2kEx -//clAmdBlasCsyrk -//clAmdBlasCsyrkEx -//clAmdBlasCtbmv -//clAmdBlasCtbsv -//clAmdBlasCtpmv -//clAmdBlasCtpsv -//clAmdBlasCtrmm -//clAmdBlasCtrmmEx -//clAmdBlasCtrmv -//clAmdBlasCtrsm -//clAmdBlasCtrsmEx -//clAmdBlasCtrsv -//clAmdBlasDasum -//clAmdBlasDaxpy -//clAmdBlasDcopy -//clAmdBlasDdot -//clAmdBlasDgbmv -//clAmdBlasDgemm -clAmdBlasDgemmEx -//clAmdBlasDgemv -//clAmdBlasDgemvEx -//clAmdBlasDger -//clAmdBlasDnrm2 -//clAmdBlasDrot -//clAmdBlasDrotg -//clAmdBlasDrotm -//clAmdBlasDrotmg -//clAmdBlasDsbmv -//clAmdBlasDscal -//clAmdBlasDspmv -//clAmdBlasDspr -//clAmdBlasDspr2 -//clAmdBlasDswap -//clAmdBlasDsymm -//clAmdBlasDsymv -//clAmdBlasDsymvEx -//clAmdBlasDsyr -//clAmdBlasDsyr2 -//clAmdBlasDsyr2k -//clAmdBlasDsyr2kEx -//clAmdBlasDsyrk -//clAmdBlasDsyrkEx -//clAmdBlasDtbmv -//clAmdBlasDtbsv -//clAmdBlasDtpmv -//clAmdBlasDtpsv -//clAmdBlasDtrmm -//clAmdBlasDtrmmEx -//clAmdBlasDtrmv -//clAmdBlasDtrsm -//clAmdBlasDtrsmEx -//clAmdBlasDtrsv -//clAmdBlasDzasum -//clAmdBlasDznrm2 -//clAmdBlasGetVersion -//clAmdBlasRemoveScratchImage -//clAmdBlasSasum -//clAmdBlasSaxpy -//clAmdBlasScasum -//clAmdBlasScnrm2 -//clAmdBlasScopy -//clAmdBlasSdot -clAmdBlasSetup -//clAmdBlasSgbmv -//clAmdBlasSgemm -clAmdBlasSgemmEx -//clAmdBlasSgemv -//clAmdBlasSgemvEx -//clAmdBlasSger -//clAmdBlasSnrm2 -//clAmdBlasSrot -//clAmdBlasSrotg -//clAmdBlasSrotm -//clAmdBlasSrotmg -//clAmdBlasSsbmv -//clAmdBlasSscal -//clAmdBlasSspmv -//clAmdBlasSspr -//clAmdBlasSspr2 -//clAmdBlasSswap -//clAmdBlasSsymm -//clAmdBlasSsymv -//clAmdBlasSsymvEx -//clAmdBlasSsyr -//clAmdBlasSsyr2 -//clAmdBlasSsyr2k -//clAmdBlasSsyr2kEx -//clAmdBlasSsyrk -//clAmdBlasSsyrkEx -//clAmdBlasStbmv -//clAmdBlasStbsv -//clAmdBlasStpmv -//clAmdBlasStpsv -//clAmdBlasStrmm -//clAmdBlasStrmmEx -//clAmdBlasStrmv -//clAmdBlasStrsm -//clAmdBlasStrsmEx -//clAmdBlasStrsv -clAmdBlasTeardown -//clAmdBlasZaxpy -//clAmdBlasZcopy -//clAmdBlasZdotc -//clAmdBlasZdotu -//clAmdBlasZdrot -//clAmdBlasZdscal -//clAmdBlasZgbmv -//clAmdBlasZgemm -clAmdBlasZgemmEx -//clAmdBlasZgemv -//clAmdBlasZgemvEx -//clAmdBlasZgerc -//clAmdBlasZgeru -//clAmdBlasZhbmv -//clAmdBlasZhemm -//clAmdBlasZhemv -//clAmdBlasZher -//clAmdBlasZher2 -//clAmdBlasZher2k -//clAmdBlasZherk -//clAmdBlasZhpmv -//clAmdBlasZhpr -//clAmdBlasZhpr2 -//clAmdBlasZrotg -//clAmdBlasZscal -//clAmdBlasZswap -//clAmdBlasZsymm -//clAmdBlasZsyr2k -//clAmdBlasZsyr2kEx -//clAmdBlasZsyrk -//clAmdBlasZsyrkEx -//clAmdBlasZtbmv -//clAmdBlasZtbsv -//clAmdBlasZtpmv -//clAmdBlasZtpsv -//clAmdBlasZtrmm -//clAmdBlasZtrmmEx -//clAmdBlasZtrmv -//clAmdBlasZtrsm -//clAmdBlasZtrsmEx -//clAmdBlasZtrsv -//clAmdBlasiCamax -//clAmdBlasiDamax -//clAmdBlasiSamax -//clAmdBlasiZamax -#total 175 diff --git a/modules/core/src/opencl/runtime/generator/filter/opencl_clamdfft_functions.list b/modules/core/src/opencl/runtime/generator/filter/opencl_clamdfft_functions.list deleted file mode 100644 index 32e9a9f344..0000000000 --- a/modules/core/src/opencl/runtime/generator/filter/opencl_clamdfft_functions.list +++ /dev/null @@ -1,33 +0,0 @@ -clAmdFftBakePlan -//clAmdFftCopyPlan -clAmdFftCreateDefaultPlan -clAmdFftDestroyPlan -clAmdFftEnqueueTransform -//clAmdFftGetLayout -//clAmdFftGetPlanBatchSize -//clAmdFftGetPlanContext -//clAmdFftGetPlanDim -//clAmdFftGetPlanDistance -//clAmdFftGetPlanInStride -//clAmdFftGetPlanLength -//clAmdFftGetPlanOutStride -//clAmdFftGetPlanPrecision -//clAmdFftGetPlanScale -//clAmdFftGetPlanTransposeResult -//clAmdFftGetResultLocation -clAmdFftGetTmpBufSize -clAmdFftGetVersion -clAmdFftSetLayout -clAmdFftSetPlanBatchSize -//clAmdFftSetPlanDim -clAmdFftSetPlanDistance -clAmdFftSetPlanInStride -//clAmdFftSetPlanLength -clAmdFftSetPlanOutStride -clAmdFftSetPlanPrecision -clAmdFftSetPlanScale -//clAmdFftSetPlanTransposeResult -clAmdFftSetResultLocation -clAmdFftSetup -clAmdFftTeardown -#total 32 diff --git a/modules/core/src/opencl/runtime/generator/filter/opencl_clblas_functions.list b/modules/core/src/opencl/runtime/generator/filter/opencl_clblas_functions.list new file mode 100644 index 0000000000..bbbf4c05d2 --- /dev/null +++ b/modules/core/src/opencl/runtime/generator/filter/opencl_clblas_functions.list @@ -0,0 +1,148 @@ +//clblasCaxpy +//clblasCcopy +//clblasCdotc +//clblasCdotu +//clblasCgbmv +clblasCgemm +//clblasCgemv +//clblasCgerc +//clblasCgeru +//clblasChbmv +//clblasChemm +//clblasChemv +//clblasCher +//clblasCher2 +//clblasCher2k +//clblasCherk +//clblasChpmv +//clblasChpr +//clblasChpr2 +//clblasCrotg +//clblasCscal +//clblasCsrot +//clblasCsscal +//clblasCswap +//clblasCsymm +//clblasCsyr2k +//clblasCsyrk +//clblasCtbmv +//clblasCtbsv +//clblasCtpmv +//clblasCtpsv +//clblasCtrmm +//clblasCtrmv +//clblasCtrsm +//clblasCtrsv +//clblasDasum +//clblasDaxpy +//clblasDcopy +//clblasDdot +//clblasDgbmv +clblasDgemm +//clblasDgemv +//clblasDger +//clblasDnrm2 +//clblasDrot +//clblasDrotg +//clblasDrotm +//clblasDrotmg +//clblasDsbmv +//clblasDscal +//clblasDspmv +//clblasDspr +//clblasDspr2 +//clblasDswap +//clblasDsymm +//clblasDsymv +//clblasDsyr +//clblasDsyr2 +//clblasDsyr2k +//clblasDsyrk +//clblasDtbmv +//clblasDtbsv +//clblasDtpmv +//clblasDtpsv +//clblasDtrmm +//clblasDtrmv +//clblasDtrsm +//clblasDtrsv +//clblasDzasum +//clblasDznrm2 +//clblasGetVersion +//clblasSasum +//clblasSaxpy +//clblasScasum +//clblasScnrm2 +//clblasScopy +//clblasSdot +clblasSetup +//clblasSgbmv +clblasSgemm +//clblasSgemv +//clblasSger +//clblasSnrm2 +//clblasSrot +//clblasSrotg +//clblasSrotm +//clblasSrotmg +//clblasSsbmv +//clblasSscal +//clblasSspmv +//clblasSspr +//clblasSspr2 +//clblasSswap +//clblasSsymm +//clblasSsymv +//clblasSsyr +//clblasSsyr2 +//clblasSsyr2k +//clblasSsyrk +//clblasStbmv +//clblasStbsv +//clblasStpmv +//clblasStpsv +//clblasStrmm +//clblasStrmv +//clblasStrsm +//clblasStrsv +clblasTeardown +//clblasZaxpy +//clblasZcopy +//clblasZdotc +//clblasZdotu +//clblasZdrot +//clblasZdscal +//clblasZgbmv +clblasZgemm +//clblasZgemv +//clblasZgerc +//clblasZgeru +//clblasZhbmv +//clblasZhemm +//clblasZhemv +//clblasZher +//clblasZher2 +//clblasZher2k +//clblasZherk +//clblasZhpmv +//clblasZhpr +//clblasZhpr2 +//clblasZrotg +//clblasZscal +//clblasZswap +//clblasZsymm +//clblasZsyr2k +//clblasZsyrk +//clblasZtbmv +//clblasZtbsv +//clblasZtpmv +//clblasZtpsv +//clblasZtrmm +//clblasZtrmv +//clblasZtrsm +//clblasZtrsv +//clblasiCamax +//clblasiDamax +//clblasiSamax +//clblasiZamax +#total 147 diff --git a/modules/core/src/opencl/runtime/generator/filter/opencl_clfft_functions.list b/modules/core/src/opencl/runtime/generator/filter/opencl_clfft_functions.list new file mode 100644 index 0000000000..45e01bf89f --- /dev/null +++ b/modules/core/src/opencl/runtime/generator/filter/opencl_clfft_functions.list @@ -0,0 +1,34 @@ +clfftBakePlan +//clfftCopyPlan +clfftCreateDefaultPlan +clfftDestroyPlan +clfftEnqueueTransform +//clfftGetLayout +//clfftGetPlanBatchSize +//clfftGetPlanContext +//clfftGetPlanDim +//clfftGetPlanDistance +//clfftGetPlanInStride +//clfftGetPlanLength +//clfftGetPlanOutStride +//clfftGetPlanPrecision +//clfftGetPlanScale +//clfftGetPlanTransposeResult +//clfftGetResultLocation +clfftGetTmpBufSize +clfftGetVersion +clfftSetLayout +clfftSetPlanBatchSize +//clfftSetPlanCallback +//clfftSetPlanDim +clfftSetPlanDistance +clfftSetPlanInStride +//clfftSetPlanLength +clfftSetPlanOutStride +clfftSetPlanPrecision +clfftSetPlanScale +//clfftSetPlanTransposeResult +clfftSetResultLocation +clfftSetup +clfftTeardown +#total 33 diff --git a/modules/core/src/opencl/runtime/generator/parser_cl.py b/modules/core/src/opencl/runtime/generator/parser_cl.py index 1f5050445c..54133e8085 100644 --- a/modules/core/src/opencl/runtime/generator/parser_cl.py +++ b/modules/core/src/opencl/runtime/generator/parser_cl.py @@ -10,10 +10,10 @@ from common import remove_comments, getTokens, getParameters, postProcessParamet try: if len(sys.argv) > 1: module_name = sys.argv[1] - outfile = open('../../../../include/opencv2/core/opencl/runtime/autogenerated/%s.hpp' % module_name, 'wb') - outfile_impl = open('../autogenerated/%s_impl.hpp' % module_name, 'wb') - outfile_static_impl = open('../autogenerated/%s_static_impl.hpp' % module_name, 'wb') - outfile_wrappers = open('../../../../include/opencv2/core/opencl/runtime/autogenerated/%s_wrappers.hpp' % module_name, 'wb') + outfile = open('../../../../include/opencv2/core/opencl/runtime/autogenerated/%s.hpp' % module_name, 'w') + outfile_impl = open('../autogenerated/%s_impl.hpp' % module_name, 'w') + outfile_static_impl = open('../autogenerated/%s_static_impl.hpp' % module_name, 'w') + outfile_wrappers = open('../../../../include/opencv2/core/opencl/runtime/autogenerated/%s_wrappers.hpp' % module_name, 'w') if len(sys.argv) > 2: f = open(sys.argv[2], "r") else: @@ -102,7 +102,7 @@ filterFileName = './filter/%s_functions.list' % module_name numEnabled = readFunctionFilter(fns, filterFileName) functionsFilter = generateFilterNames(fns) -filter_file = open(filterFileName, 'wb') +filter_file = open(filterFileName, 'w') filter_file.write(functionsFilter) ctx = {} diff --git a/modules/core/src/opencl/runtime/generator/parser_clamdblas.py b/modules/core/src/opencl/runtime/generator/parser_clblas.py similarity index 84% rename from modules/core/src/opencl/runtime/generator/parser_clamdblas.py rename to modules/core/src/opencl/runtime/generator/parser_clblas.py index 0303517bd5..d01af0618d 100644 --- a/modules/core/src/opencl/runtime/generator/parser_clamdblas.py +++ b/modules/core/src/opencl/runtime/generator/parser_clblas.py @@ -1,6 +1,6 @@ #!/bin/python # usage: -# cat clAmdBlas.h | $0 +# cat clBLAS.h | $0 from __future__ import print_function import sys, re; @@ -23,7 +23,7 @@ while True: assert isinstance(line, str) line = line.strip() parts = line.split(); - if (line.startswith('clAmd') or line.startswith('cl_') or line == 'void') and len(line.split()) == 1 and line.find('(') == -1: + if (line.startswith('clblas') or line.startswith('cl_') or line == 'void') and len(line.split()) == 1 and line.find('(') == -1: fn = {} modifiers = [] ret = [] @@ -90,11 +90,11 @@ pprint(fns) from common import * -filterFileName='./filter/opencl_clamdblas_functions.list' +filterFileName='./filter/opencl_clblas_functions.list' numEnabled = readFunctionFilter(fns, filterFileName) functionsFilter = generateFilterNames(fns) -filter_file = open(filterFileName, 'wb') +filter_file = open(filterFileName, 'w') filter_file.write(functionsFilter) ctx = {} @@ -102,8 +102,8 @@ ctx['CLAMDBLAS_REMAP_ORIGIN'] = generateRemapOrigin(fns) ctx['CLAMDBLAS_REMAP_DYNAMIC'] = generateRemapDynamic(fns) ctx['CLAMDBLAS_FN_DECLARATIONS'] = generateFnDeclaration(fns) -sys.stdout = open('../../../../include/opencv2/core/opencl/runtime/autogenerated/opencl_clamdblas.hpp', 'wb') -ProcessTemplate('template/opencl_clamdblas.hpp.in', ctx) +sys.stdout = open('../../../../include/opencv2/core/opencl/runtime/autogenerated/opencl_clblas.hpp', 'w') +ProcessTemplate('template/opencl_clblas.hpp.in', ctx) ctx['CL_FN_ENUMS'] = generateEnums(fns, 'OPENCLAMDBLAS_FN', ) ctx['CL_FN_SWITCH'] = generateTemplates(23, 'openclamdblas_fn', 'openclamdblas_check_fn', '') @@ -111,5 +111,5 @@ ctx['CL_FN_ENTRY_DEFINITIONS'] = generateStructDefinitions(fns, 'openclamdblas_f ctx['CL_FN_ENTRY_LIST'] = generateListOfDefinitions(fns, 'openclamdblas_fn') ctx['CL_NUMBER_OF_ENABLED_FUNCTIONS'] = '// number of enabled functions: %d' % (numEnabled) -sys.stdout = open('../autogenerated/opencl_clamdblas_impl.hpp', 'wb') -ProcessTemplate('template/opencl_clamdblas_impl.hpp.in', ctx) +sys.stdout = open('../autogenerated/opencl_clblas_impl.hpp', 'w') +ProcessTemplate('template/opencl_clblas_impl.hpp.in', ctx) diff --git a/modules/core/src/opencl/runtime/generator/parser_clamdfft.py b/modules/core/src/opencl/runtime/generator/parser_clfft.py similarity index 85% rename from modules/core/src/opencl/runtime/generator/parser_clamdfft.py rename to modules/core/src/opencl/runtime/generator/parser_clfft.py index e0229f1d9d..e3daaee621 100644 --- a/modules/core/src/opencl/runtime/generator/parser_clamdfft.py +++ b/modules/core/src/opencl/runtime/generator/parser_clfft.py @@ -1,6 +1,6 @@ #!/bin/python # usage: -# cat clAmdFft.h | $0 +# cat clFFT.h | $0 from __future__ import print_function import sys, re; @@ -23,7 +23,7 @@ while True: break assert isinstance(line, str) line = line.strip() - if line.startswith('CLAMDFFTAPI'): + if line.startswith('CLFFTAPI'): line = re.sub(r'\n', r'', line) while True: nl = f.readline() @@ -44,7 +44,7 @@ while True: i = 0 while True: - if parts[i] == "CLAMDFFTAPI": + if parts[i] == "CLFFTAPI": modifiers.append(parts[i]) else: break @@ -87,11 +87,11 @@ pprint(fns) from common import * -filterFileName='./filter/opencl_clamdfft_functions.list' +filterFileName='./filter/opencl_clfft_functions.list' numEnabled = readFunctionFilter(fns, filterFileName) functionsFilter = generateFilterNames(fns) -filter_file = open(filterFileName, 'wb') +filter_file = open(filterFileName, 'w') filter_file.write(functionsFilter) ctx = {} @@ -99,8 +99,8 @@ ctx['CLAMDFFT_REMAP_ORIGIN'] = generateRemapOrigin(fns) ctx['CLAMDFFT_REMAP_DYNAMIC'] = generateRemapDynamic(fns) ctx['CLAMDFFT_FN_DECLARATIONS'] = generateFnDeclaration(fns) -sys.stdout = open('../../../../include/opencv2/core/opencl/runtime/autogenerated/opencl_clamdfft.hpp', 'wb') -ProcessTemplate('template/opencl_clamdfft.hpp.in', ctx) +sys.stdout = open('../../../../include/opencv2/core/opencl/runtime/autogenerated/opencl_clfft.hpp', 'w') +ProcessTemplate('template/opencl_clfft.hpp.in', ctx) ctx['CL_FN_ENUMS'] = generateEnums(fns, 'OPENCLAMDFFT_FN') ctx['CL_FN_SWITCH'] = generateTemplates(23, 'openclamdfft_fn', 'openclamdfft_check_fn', '') @@ -108,5 +108,5 @@ ctx['CL_FN_ENTRY_DEFINITIONS'] = generateStructDefinitions(fns, 'openclamdfft_fn ctx['CL_FN_ENTRY_LIST'] = generateListOfDefinitions(fns, 'openclamdfft_fn') ctx['CL_NUMBER_OF_ENABLED_FUNCTIONS'] = '// number of enabled functions: %d' % (numEnabled) -sys.stdout = open('../autogenerated/opencl_clamdfft_impl.hpp', 'wb') -ProcessTemplate('template/opencl_clamdfft_impl.hpp.in', ctx) +sys.stdout = open('../autogenerated/opencl_clfft_impl.hpp', 'w') +ProcessTemplate('template/opencl_clfft_impl.hpp.in', ctx) diff --git a/modules/core/src/opencl/runtime/generator/template/opencl_clamdblas.hpp.in b/modules/core/src/opencl/runtime/generator/template/opencl_clblas.hpp.in similarity index 87% rename from modules/core/src/opencl/runtime/generator/template/opencl_clamdblas.hpp.in rename to modules/core/src/opencl/runtime/generator/template/opencl_clblas.hpp.in index 5b48f51400..7c19bfd512 100644 --- a/modules/core/src/opencl/runtime/generator/template/opencl_clamdblas.hpp.in +++ b/modules/core/src/opencl/runtime/generator/template/opencl_clblas.hpp.in @@ -4,7 +4,7 @@ @CLAMDBLAS_REMAP_ORIGIN@ -#include +#include @CLAMDBLAS_REMAP_DYNAMIC@ diff --git a/modules/core/src/opencl/runtime/generator/template/opencl_clamdblas_impl.hpp.in b/modules/core/src/opencl/runtime/generator/template/opencl_clblas_impl.hpp.in similarity index 100% rename from modules/core/src/opencl/runtime/generator/template/opencl_clamdblas_impl.hpp.in rename to modules/core/src/opencl/runtime/generator/template/opencl_clblas_impl.hpp.in diff --git a/modules/core/src/opencl/runtime/generator/template/opencl_clamdfft.hpp.in b/modules/core/src/opencl/runtime/generator/template/opencl_clfft.hpp.in similarity index 87% rename from modules/core/src/opencl/runtime/generator/template/opencl_clamdfft.hpp.in rename to modules/core/src/opencl/runtime/generator/template/opencl_clfft.hpp.in index 4e8a563517..f03c4b2db0 100644 --- a/modules/core/src/opencl/runtime/generator/template/opencl_clamdfft.hpp.in +++ b/modules/core/src/opencl/runtime/generator/template/opencl_clfft.hpp.in @@ -4,7 +4,7 @@ @CLAMDFFT_REMAP_ORIGIN@ -#include +#include @CLAMDFFT_REMAP_DYNAMIC@ diff --git a/modules/core/src/opencl/runtime/generator/template/opencl_clamdfft_impl.hpp.in b/modules/core/src/opencl/runtime/generator/template/opencl_clfft_impl.hpp.in similarity index 100% rename from modules/core/src/opencl/runtime/generator/template/opencl_clamdfft_impl.hpp.in rename to modules/core/src/opencl/runtime/generator/template/opencl_clfft_impl.hpp.in diff --git a/modules/core/src/opencl/runtime/opencl_clamdblas.cpp b/modules/core/src/opencl/runtime/opencl_clblas.cpp similarity index 92% rename from modules/core/src/opencl/runtime/opencl_clamdblas.cpp rename to modules/core/src/opencl/runtime/opencl_clblas.cpp index 379929993f..419c4df443 100644 --- a/modules/core/src/opencl/runtime/opencl_clamdblas.cpp +++ b/modules/core/src/opencl/runtime/opencl_clblas.cpp @@ -44,7 +44,7 @@ #ifdef HAVE_CLAMDBLAS #include "opencv2/core/opencl/runtime/opencl_core.hpp" -#include "opencv2/core/opencl/runtime/opencl_clamdblas.hpp" +#include "opencv2/core/opencl/runtime/opencl_clblas.hpp" #if defined(_WIN32) #include @@ -54,10 +54,10 @@ static HMODULE opencl_module = NULL; if (!opencl_module) { - opencl_module = GetModuleHandleA("clAmdBlas.dll"); + opencl_module = GetModuleHandleA("clBLAS.dll"); if (!opencl_module) { - opencl_module = LoadLibraryA("clAmdBlas.dll"); + opencl_module = LoadLibraryA("clBLAS.dll"); if (!opencl_module) return NULL; } @@ -76,7 +76,7 @@ static void* h = NULL; if (!h) { - h = dlopen("libclAmdBlas.so", RTLD_LAZY | RTLD_GLOBAL); + h = dlopen("libclBLAS.so", RTLD_LAZY | RTLD_GLOBAL); if (!h) return NULL; } @@ -109,7 +109,7 @@ static void* openclamdblas_check_fn(int ID); // END OF CUSTOM FUNCTIONS HERE // -#include "autogenerated/opencl_clamdblas_impl.hpp" +#include "autogenerated/opencl_clblas_impl.hpp" static void* openclamdblas_check_fn(int ID) { diff --git a/modules/core/src/opencl/runtime/opencl_clamdfft.cpp b/modules/core/src/opencl/runtime/opencl_clfft.cpp similarity index 92% rename from modules/core/src/opencl/runtime/opencl_clamdfft.cpp rename to modules/core/src/opencl/runtime/opencl_clfft.cpp index 255bcd826a..44e7466f96 100644 --- a/modules/core/src/opencl/runtime/opencl_clamdfft.cpp +++ b/modules/core/src/opencl/runtime/opencl_clfft.cpp @@ -44,7 +44,7 @@ #ifdef HAVE_CLAMDFFT #include "opencv2/core/opencl/runtime/opencl_core.hpp" -#include "opencv2/core/opencl/runtime/opencl_clamdfft.hpp" +#include "opencv2/core/opencl/runtime/opencl_clfft.hpp" #if defined(_WIN32) #include @@ -54,10 +54,10 @@ static HMODULE opencl_module = NULL; if (!opencl_module) { - opencl_module = GetModuleHandleA("clAmdFft.Runtime.dll"); + opencl_module = GetModuleHandleA("clFFT.dll"); if (!opencl_module) { - opencl_module = LoadLibraryA("clAmdFft.Runtime.dll"); + opencl_module = LoadLibraryA("clFFT.dll"); if (!opencl_module) return NULL; } @@ -76,7 +76,7 @@ static void* h = NULL; if (!h) { - h = dlopen("libclAmdFft.Runtime.so", RTLD_LAZY | RTLD_GLOBAL); + h = dlopen("libclFFT.so", RTLD_LAZY | RTLD_GLOBAL); if (!h) return NULL; } @@ -109,7 +109,7 @@ static void* openclamdfft_check_fn(int ID); // END OF CUSTOM FUNCTIONS HERE // -#include "autogenerated/opencl_clamdfft_impl.hpp" +#include "autogenerated/opencl_clfft_impl.hpp" static void* openclamdfft_check_fn(int ID) { diff --git a/modules/core/src/umatrix.cpp b/modules/core/src/umatrix.cpp index 09ba92ecde..c80d240ecc 100644 --- a/modules/core/src/umatrix.cpp +++ b/modules/core/src/umatrix.cpp @@ -307,8 +307,7 @@ UMat& UMat::operator=(const UMat& m) else copySize(m); allocator = m.allocator; - if (usageFlags == USAGE_DEFAULT) - usageFlags = m.usageFlags; + usageFlags = m.usageFlags; u = m.u; offset = m.offset; } @@ -332,9 +331,6 @@ void UMat::assignTo(UMat& m, int _type) const void UMat::create(int _rows, int _cols, int _type, UMatUsageFlags _usageFlags) { - _type &= TYPE_MASK; - if( dims <= 2 && rows == _rows && cols == _cols && type() == _type && u ) - return; int sz[] = {_rows, _cols}; create(2, sz, _type, _usageFlags); } @@ -426,7 +422,9 @@ UMat& UMat::operator=(UMat&& m) m.step.p = m.step.buf; m.size.p = &m.rows; } - m.flags = MAGIC_VAL; m.dims = m.rows = m.cols = 0; + m.flags = MAGIC_VAL; + m.usageFlags = USAGE_DEFAULT; + m.dims = m.rows = m.cols = 0; m.allocator = NULL; m.u = NULL; m.offset = 0; @@ -600,6 +598,7 @@ UMat Mat::getUMat(AccessFlag accessFlags, UMatUsageFlags usageFlags) const CV_XADD(&(u->urefcount), 1); } hdr.flags = flags; + hdr.usageFlags = usageFlags; setSize(hdr, dims, size.p, step.p); finalizeHdr(hdr); hdr.u = new_u; @@ -610,16 +609,21 @@ UMat Mat::getUMat(AccessFlag accessFlags, UMatUsageFlags usageFlags) const void UMat::create(int d, const int* _sizes, int _type, UMatUsageFlags _usageFlags) { - this->usageFlags = _usageFlags; - int i; CV_Assert(0 <= d && d <= CV_MAX_DIM && _sizes); _type = CV_MAT_TYPE(_type); - if( u && (d == dims || (d == 1 && dims <= 2)) && _type == type() ) + // if param value is USAGE_DEFAULT by implicit default param value -or- explicit value + // ...then don't change the existing usageFlags + // it is not possible to change usage from non-default to USAGE_DEFAULT through create() + // ...instead must construct UMat() + if (_usageFlags == cv::USAGE_DEFAULT) + { + _usageFlags = usageFlags; + } + + if( u && (d == dims || (d == 1 && dims <= 2)) && _type == type() && _usageFlags == usageFlags ) { - if( d == 2 && rows == _sizes[0] && cols == _sizes[1] ) - return; for( i = 0; i < d; i++ ) if( size[i] != _sizes[i] ) break; @@ -636,6 +640,7 @@ void UMat::create(int d, const int* _sizes, int _type, UMatUsageFlags _usageFlag } release(); + usageFlags = _usageFlags; if( d == 0 ) return; flags = (_type & CV_MAT_TYPE_MASK) | MAGIC_VAL; diff --git a/modules/core/test/test_opencl.cpp b/modules/core/test/test_opencl.cpp index 17cd7b5c89..ff1391016e 100644 --- a/modules/core/test/test_opencl.cpp +++ b/modules/core/test/test_opencl.cpp @@ -207,9 +207,32 @@ TEST_P(OCL_OpenCLExecutionContext_P, ScopeTest) executeUMatCall(); } - - INSTANTIATE_TEST_CASE_P(/*nothing*/, OCL_OpenCLExecutionContext_P, getOpenCLTestConfigurations()); +typedef testing::TestWithParam UsageFlagsFixture; +OCL_TEST_P(UsageFlagsFixture, UsageFlagsRetained) +{ + if (!cv::ocl::useOpenCL()) + { + throw SkipTestException("OpenCL is not available / disabled"); + } + + const UMatUsageFlags usage = GetParam(); + cv::UMat flip_in(10, 10, CV_32F, usage); + cv::UMat flip_out(usage); + cv::flip(flip_in, flip_out, 1); + cv::ocl::finish(); + + ASSERT_EQ(usage, flip_in.usageFlags); + ASSERT_EQ(usage, flip_out.usageFlags); +} + +INSTANTIATE_TEST_CASE_P( + /*nothing*/, + UsageFlagsFixture, + testing::Values(USAGE_DEFAULT, USAGE_ALLOCATE_HOST_MEMORY, USAGE_ALLOCATE_DEVICE_MEMORY) +); + + } } // namespace opencv_test::ocl diff --git a/modules/dnn/include/opencv2/dnn/version.hpp b/modules/dnn/include/opencv2/dnn/version.hpp index 1cd0b8f486..98086a80ff 100644 --- a/modules/dnn/include/opencv2/dnn/version.hpp +++ b/modules/dnn/include/opencv2/dnn/version.hpp @@ -6,7 +6,7 @@ #define OPENCV_DNN_VERSION_HPP /// Use with major OpenCV version only. -#define OPENCV_DNN_API_VERSION 20210301 +#define OPENCV_DNN_API_VERSION 20210608 #if !defined CV_DOXYGEN && !defined CV_STATIC_ANALYSIS && !defined CV_DNN_DONT_ADD_INLINE_NS #define CV__DNN_INLINE_NS __CV_CAT(dnn5_v, OPENCV_DNN_API_VERSION) diff --git a/modules/dnn/src/cuda4dnn/csl/cublas.hpp b/modules/dnn/src/cuda4dnn/csl/cublas.hpp index 2928cda779..760e3824fd 100644 --- a/modules/dnn/src/cuda4dnn/csl/cublas.hpp +++ b/modules/dnn/src/cuda4dnn/csl/cublas.hpp @@ -247,6 +247,122 @@ namespace cv { namespace dnn { namespace cuda4dnn { namespace csl { namespace cu ); } + /** @brief Strided batched GEMM for colummn-major matrices + * + * \f$ C_i = \alpha A_i B_i + \beta C_i \f$ for a stack of matrices A, B and C indexed by i + * + * @tparam T matrix element type (must be `half` or `float`) + * + * @param handle valid cuBLAS Handle + * @param transa use transposed matrix of A_i for computation + * @param transb use transposed matrix of B_i for computation + * @param rows_c number of rows in C_i + * @param cols_c number of columns in C_i + * @param common_dim common dimension of A_i (or trans A_i) and B_i (or trans B_i) + * @param alpha scale factor for A_i B_i + * @param[in] A pointer to stack of column-major matrices A in device memory + * @param lda leading dimension of matrix A_i + * @param strideA stride between matrices in A + * @param[in] B pointer to stack of column-major matrices B in device memory + * @param ldb leading dimension of matrix B_i + * @param strideB stride between matrices in B + * @param beta scale factor for C_i + * @param[in,out] C pointer to stack of column-major matrices C in device memory + * @param ldc leading dimension of matrix C_i + * @param strideC stride between matrices in C + * @param batchCount number of matrices in the batch + * + * Exception Guarantee: Basic + */ + template + void gemmStridedBatched(const Handle& handle, + bool transa, bool transb, + std::size_t rows_c, std::size_t cols_c, std::size_t common_dim, + T alpha, const DevicePtr A, std::size_t lda, std::size_t strideA, + const DevicePtr B, std::size_t ldb, std::size_t strideB, + T beta, const DevicePtr C, std::size_t ldc, std::size_t strideC, + std::size_t batchCount); + + template <> inline + void gemmStridedBatched(const Handle& handle, + bool transa, bool transb, + std::size_t rows_c, std::size_t cols_c, std::size_t common_dim, + half alpha, const DevicePtr A, std::size_t lda, std::size_t strideA, + const DevicePtr B, std::size_t ldb, std::size_t strideB, + half beta, const DevicePtr C, std::size_t ldc, std::size_t strideC, + std::size_t batchCount) + { + CV_Assert(handle); + + const auto opa = transa ? CUBLAS_OP_T : CUBLAS_OP_N, + opb = transb ? CUBLAS_OP_T : CUBLAS_OP_N; + const auto irows_c = static_cast(rows_c), + icols_c = static_cast(cols_c), + icommon_dim = static_cast(common_dim), + ilda = static_cast(lda), + ildb = static_cast(ldb), + ildc = static_cast(ldc); + + const auto batch_count = static_cast(batchCount); + const auto stride_a = static_cast(strideA), + stride_b = static_cast(strideB), + stride_c = static_cast(strideC); + + CV_Assert(stride_c >= irows_c * icols_c); // output matrices must not overlap + + CUDA4DNN_CHECK_CUBLAS( + cublasHgemmStridedBatched( + handle.get(), + opa, opb, + irows_c, icols_c, icommon_dim, + &alpha, A.get(), ilda, stride_a, + B.get(), ildb, stride_b, + &beta, C.get(), ildc, stride_c, + batch_count + ) + ); + } + + template <> inline + void gemmStridedBatched(const Handle& handle, + bool transa, bool transb, + std::size_t rows_c, std::size_t cols_c, std::size_t common_dim, + float alpha, const DevicePtr A, std::size_t lda, std::size_t strideA, + const DevicePtr B, std::size_t ldb, std::size_t strideB, + float beta, const DevicePtr C, std::size_t ldc, std::size_t strideC, + std::size_t batchCount) + { + CV_Assert(handle); + + const auto opa = transa ? CUBLAS_OP_T : CUBLAS_OP_N, + opb = transb ? CUBLAS_OP_T : CUBLAS_OP_N; + const auto irows_c = static_cast(rows_c), + icols_c = static_cast(cols_c), + icommon_dim = static_cast(common_dim), + ilda = static_cast(lda), + ildb = static_cast(ldb), + ildc = static_cast(ldc); + + const auto batch_count = static_cast(batchCount); + const auto stride_a = static_cast(strideA), + stride_b = static_cast(strideB), + stride_c = static_cast(strideC); + + CV_Assert(stride_c >= irows_c * icols_c); // output matrices must not overlap + + CUDA4DNN_CHECK_CUBLAS( + cublasSgemmStridedBatched( + handle.get(), + opa, opb, + irows_c, icols_c, icommon_dim, + &alpha, A.get(), ilda, stride_a, + B.get(), ildb, stride_b, + &beta, C.get(), ildc, stride_c, + batch_count + ) + ); + } + }}}}} /* namespace cv::dnn::cuda4dnn::csl::cublas */ #endif /* OPENCV_DNN_SRC_CUDA4DNN_CSL_CUBLAS_HPP */ diff --git a/modules/dnn/src/cuda4dnn/csl/tensor.hpp b/modules/dnn/src/cuda4dnn/csl/tensor.hpp index 6e997ab0eb..5a1286de99 100644 --- a/modules/dnn/src/cuda4dnn/csl/tensor.hpp +++ b/modules/dnn/src/cuda4dnn/csl/tensor.hpp @@ -369,6 +369,26 @@ namespace cv { namespace dnn { namespace cuda4dnn { namespace csl { shape.erase(std::begin(shape) + axis); } + /** @brief squeezes the tensor + * + * removes leading singleton axes until the tensor's rank is equal to the requested rank + * + * Pre-conditions: + * - the tensor must be non-empty + * - the tensor's rank must be at least two + * - the tensor's rank must be at least the requested rank + * - the tensor must be squeezable up to the requested rank + * + * Exception Guarantee: Strong + */ + void squeeze_to(int r) { + CV_Assert(!empty()); + CV_Assert(rank() >= r); + CV_Assert(std::all_of(std::begin(shape), std::end(shape) - r, [](size_type x){ return x == 1; })); + std::copy(std::end(shape) - r, std::end(shape), std::begin(shape)); + shape.resize(r); + } + /** @brief unsqueezes the tensor * * adds a axis of unit size at the requested before the specified axis @@ -665,6 +685,26 @@ namespace cv { namespace dnn { namespace cuda4dnn { namespace csl { shape.erase(std::begin(shape) + axis); } + /** @brief squeezes the tensor + * + * removes leading singleton axes until the tensor's rank is equal to the requested rank + * + * Pre-conditions: + * - the tensor must be non-empty + * - the tensor's rank must be at least two + * - the tensor's rank must be at least the requested rank + * - the tensor must be squeezable up to the requested rank + * + * Exception Guarantee: Strong + */ + void squeeze_to(int r) { + CV_Assert(!empty()); + CV_Assert(rank() >= r); + CV_Assert(std::all_of(std::begin(shape), std::end(shape) - r, [](size_type x){ return x == 1; })); + std::copy(std::end(shape) - r, std::end(shape), std::begin(shape)); + shape.resize(r); + } + /** @brief unsqueezes the tensor * * adds a axis of unit size at the requested before the specified axis @@ -1010,6 +1050,26 @@ namespace cv { namespace dnn { namespace cuda4dnn { namespace csl { shape.erase(std::begin(shape) + axis); } + /** @brief squeezes the tensor + * + * removes leading singleton axes until the tensor's rank is equal to the requested rank + * + * Pre-conditions: + * - the tensor must be non-empty + * - the tensor's rank must be at least two + * - the tensor's rank must be at least the requested rank + * - the tensor must be squeezable up to the requested rank + * + * Exception Guarantee: Strong + */ + void squeeze_to(int r) { + CV_Assert(!empty()); + CV_Assert(rank() >= r); + CV_Assert(std::all_of(std::begin(shape), std::end(shape) - r, [](size_type x){ return x == 1; })); + std::copy(std::end(shape) - r, std::end(shape), std::begin(shape)); + shape.resize(r); + } + /** @brief unsqueezes the tensor * * adds a axis of unit size at the requested before the specified axis diff --git a/modules/dnn/src/cuda4dnn/csl/tensor_ops.hpp b/modules/dnn/src/cuda4dnn/csl/tensor_ops.hpp index aeddaf353b..4ee0e8ab77 100644 --- a/modules/dnn/src/cuda4dnn/csl/tensor_ops.hpp +++ b/modules/dnn/src/cuda4dnn/csl/tensor_ops.hpp @@ -44,6 +44,30 @@ namespace cv { namespace dnn { namespace cuda4dnn { namespace csl { memcpy(dest.get(), src.get(), dest.size(), stream); } + namespace detail { + template + void assertGEMMCompatiblity(const TensorSpan& result, bool transa, const TensorView& A, bool transb, const TensorView& B) { + /* check dimension requirements for matrix multiplication */ + if (!transa && !transb) { + CV_Assert(A.get_axis_size(-2) == result.get_axis_size(-2)); + CV_Assert(A.get_axis_size(-1) == B.get_axis_size(-2)); + CV_Assert(B.get_axis_size(-1) == result.get_axis_size(-1)); + } else if (!transa && transb) { + CV_Assert(A.get_axis_size(-2) == result.get_axis_size(-2)); + CV_Assert(A.get_axis_size(-1) == B.get_axis_size(-1)); + CV_Assert(B.get_axis_size(-2) == result.get_axis_size(-1)); + } else if (transa && !transb) { + CV_Assert(A.get_axis_size(-1) == result.get_axis_size(-2)); + CV_Assert(A.get_axis_size(-2) == B.get_axis_size(-2)); + CV_Assert(B.get_axis_size(-1) == result.get_axis_size(-1)); + } else { + CV_Assert(A.get_axis_size(-1) == result.get_axis_size(-2)); + CV_Assert(A.get_axis_size(-2) == B.get_axis_size(-1)); + CV_Assert(B.get_axis_size(-2) == result.get_axis_size(-1)); + } + } + } + /** @brief performs generalized matrix-multiplication * * Pre-conditions: @@ -54,29 +78,10 @@ namespace cv { namespace dnn { namespace cuda4dnn { namespace csl { */ template inline void gemm(const cublas::Handle& handle, T beta, TensorSpan result, T alpha, bool transa, TensorView A, bool transb, TensorView B) { - /* matrix operations can be performed only on rank two or less tensors */ - CV_Assert(get_effective_rank(A) <= 2 && - get_effective_rank(B) <= 2 && - get_effective_rank(result) <= 2); - - /* check dimension requirements for matrix multiplication */ - if (!transa && !transb) { - CV_Assert(A.get_axis_size(-2) == result.get_axis_size(-2)); - CV_Assert(A.get_axis_size(-1) == B.get_axis_size(-2)); - CV_Assert(B.get_axis_size(-1) == result.get_axis_size(-1)); - } else if (!transa && transb) { - CV_Assert(A.get_axis_size(-2) == result.get_axis_size(-2)); - CV_Assert(A.get_axis_size(-1) == B.get_axis_size(-1)); - CV_Assert(B.get_axis_size(-2) == result.get_axis_size(-1)); - } else if (transa && !transb) { - CV_Assert(A.get_axis_size(-1) == result.get_axis_size(-2)); - CV_Assert(A.get_axis_size(-2) == B.get_axis_size(-2)); - CV_Assert(B.get_axis_size(-1) == result.get_axis_size(-1)); - } else { - CV_Assert(A.get_axis_size(-1) == result.get_axis_size(-2)); - CV_Assert(A.get_axis_size(-2) == B.get_axis_size(-1)); - CV_Assert(B.get_axis_size(-2) == result.get_axis_size(-1)); - } + /* matrix operations can be performed only on tensors with rank two or below */ + CV_Assert(get_effective_rank(A) <= 2); + CV_Assert(get_effective_rank(B) <= 2); + CV_Assert(get_effective_rank(result) <= 2); const auto result_nr = result.get_axis_size(-2); const auto result_nc = result.get_axis_size(-1); @@ -84,6 +89,8 @@ namespace cv { namespace dnn { namespace cuda4dnn { namespace csl { const auto A_nc = A.get_axis_size(-1); const auto B_nc = B.get_axis_size(-1); + detail::assertGEMMCompatiblity(result, transa, A, transb, B); + /* tensors are stored in row-major but cublas::gemm operates on column-major matrices * a row-major matrix when read as column-major matrix gives the transpose of the intended matrix * @@ -103,6 +110,47 @@ namespace cv { namespace dnn { namespace cuda4dnn { namespace csl { beta, result.get(), result_nc); } + /** @brief performs generalized matrix-multiplication for a strided batch of matrices + * + * Pre-conditions: + * - A, B and C must be rank three tensors with dimensions (batch, rows, cols) + * - the last two axes of \p A and \p B must meet the mathematical requirements for matrix multiplication + * - \p result must be large enough to hold the result and the matrices must not overlap in memory + * - batch dimension should be same in \p A, \p B and \p result + * + * Exception Guarantee: Basic + */ + template inline + void gemmStridedBatched(const cublas::Handle& handle, T beta, TensorSpan result, T alpha, bool transa, TensorView A, bool transb, TensorView B) { + CV_Assert(A.rank() == 3); + CV_Assert(B.rank() == 3); + CV_Assert(result.rank() == 3); + + const auto batch_size = result.get_axis_size(0); + CV_Assert(batch_size == A.get_axis_size(0)); + CV_Assert(batch_size == B.get_axis_size(0)); + + detail::assertGEMMCompatiblity(result, transa, A, transb, B); + + const auto result_nr = result.get_axis_size(-2); + const auto result_nc = result.get_axis_size(-1); + const auto common_dim = A.get_axis_size(transa ? -2 : -1); + const auto A_nc = A.get_axis_size(-1); + const auto B_nc = B.get_axis_size(-1); + + std::size_t strideA = (A.size() / batch_size), + strideB = (B.size() / batch_size), + strideC = (result.size() / batch_size); + + cublas::gemmStridedBatched(handle, + transb, transa, + result_nc, result_nr, common_dim, + alpha, B.get(), B_nc, strideB, + A.get(), A_nc, strideA, + beta, result.get(), result_nc, strideC, + batch_size); + } + /** @brief performs element-wise addition with broadcasting * * Pre-conditions: diff --git a/modules/dnn/src/cuda4dnn/primitives/matmul.hpp b/modules/dnn/src/cuda4dnn/primitives/matmul.hpp new file mode 100644 index 0000000000..e29036d5f4 --- /dev/null +++ b/modules/dnn/src/cuda4dnn/primitives/matmul.hpp @@ -0,0 +1,95 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. + +#ifndef OPENCV_DNN_SRC_CUDA4DNN_PRIMITIVES_MATMUL_HPP +#define OPENCV_DNN_SRC_CUDA4DNN_PRIMITIVES_MATMUL_HPP + +#include "../../op_cuda.hpp" + +#include "../csl/stream.hpp" +#include "../csl/cublas.hpp" +#include "../csl/tensor.hpp" +#include "../csl/tensor_ops.hpp" + +#include + +#include + +namespace cv { namespace dnn { namespace cuda4dnn { + + template + class MatMulOp final : public CUDABackendNode { + public: + using wrapper_type = GetCUDABackendWrapperType; + + MatMulOp(csl::Stream stream_, csl::cublas::Handle handle) + : stream(std::move(stream_)), cublasHandle(std::move(handle)) + { + } + + void forward( + const std::vector>& inputs, + const std::vector>& outputs, + csl::Workspace& workspace) override + { + CV_Assert(inputs.size() == 2 && outputs.size() == 1); + + auto input1_wrapper = inputs[0].dynamicCast(); + auto input1 = input1_wrapper->getView(); + + auto input2_wrapper = inputs[1].dynamicCast(); + auto input2 = input2_wrapper->getView(); + + auto output_wrapper = outputs[0].dynamicCast(); + auto output = output_wrapper->getSpan(); + + auto rank = output.rank(); + CV_Assert(rank == input1.rank()); + CV_Assert(rank == input2.rank()); + CV_Assert(rank >= 2); // 1D MatMul not supported + + for (int i = 0; i < rank - 2; i++) + { + // broadcasting not supported + auto size = output.get_axis_size(i); + CV_Assert(input1.get_axis_size(i) == size); + CV_Assert(input2.get_axis_size(i) == size); + } + + auto m = input1.get_axis_size(-2); + auto n = input1.get_axis_size(-1); + auto k = input2.get_axis_size(-1); + auto b = input1.size() / m / n; + CV_Assert(input2.get_axis_size(-2) == n); + CV_Assert(output.get_axis_size(-2) == m); + CV_Assert(output.get_axis_size(-1) == k); + + if (get_effective_rank(output) <= 2) + { + CV_Assert(b == 1); + CV_Assert(get_effective_rank(input1) <= 2); + CV_Assert(get_effective_rank(input2) <= 2); + csl::tensor_ops::gemm(cublasHandle, 0.0, output, 1.0, false, input1, false, input2); + } + else + { + CV_Assert(rank >= 3); + input1.reshape(b, m, n); + input2.reshape(b, n, k); + output.reshape(b, m, k); + input1.squeeze_to(3); + input2.squeeze_to(3); + output.squeeze_to(3); + csl::tensor_ops::gemmStridedBatched(cublasHandle, 0.0, output, 1.0, false, input1, false, input2); + } + } + + private: + csl::Stream stream; + csl::cublas::Handle cublasHandle; + }; + +}}} /* namespace cv::dnn::cuda4dnn */ + +#endif /* OPENCV_DNN_SRC_CUDA4DNN_PRIMITIVES_MATMUL_HPP */ diff --git a/modules/dnn/src/layers/fully_connected_layer.cpp b/modules/dnn/src/layers/fully_connected_layer.cpp index 709420c3ca..d9c1fa65c1 100644 --- a/modules/dnn/src/layers/fully_connected_layer.cpp +++ b/modules/dnn/src/layers/fully_connected_layer.cpp @@ -55,6 +55,7 @@ using namespace cv::dnn::ocl4dnn; #endif #ifdef HAVE_CUDA +#include "../cuda4dnn/primitives/matmul.hpp" #include "../cuda4dnn/primitives/inner_product.hpp" using namespace cv::dnn::cuda4dnn; #endif @@ -523,10 +524,14 @@ public: { auto context = reinterpret_cast(context_); + if (weightsMat.empty()) + { + CV_Assert(!bias); + return make_cuda_node(preferableTarget, std::move(context->stream), std::move(context->cublas_handle)); + } + auto input_wrapper = inputs[0].dynamicCast(); - auto flatten_start_axis = normalize_axis(axis, input_wrapper->getRank()); - auto biasMat_ = bias ? biasMat : Mat(); return make_cuda_node(preferableTarget, std::move(context->stream), std::move(context->cublas_handle), flatten_start_axis, weightsMat, biasMat_); } diff --git a/modules/dnn/test/test_onnx_importer.cpp b/modules/dnn/test/test_onnx_importer.cpp index 81ea1dcdd0..22a504df69 100644 --- a/modules/dnn/test/test_onnx_importer.cpp +++ b/modules/dnn/test/test_onnx_importer.cpp @@ -485,8 +485,6 @@ TEST_P(Test_ONNX_layers, MatMul) { if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER); - if (backend == DNN_BACKEND_CUDA) - applyTestTag(CV_TEST_TAG_DNN_SKIP_CUDA); // not supported testONNXModels("matmul_2d"); testONNXModels("matmul_3d"); @@ -735,8 +733,6 @@ TEST_P(Test_ONNX_layers, MatmulWithTwoInputs) #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2020040000) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE); #endif - if (backend == DNN_BACKEND_CUDA) - applyTestTag(CV_TEST_TAG_DNN_SKIP_CUDA); testONNXModels("matmul_with_two_inputs"); } diff --git a/modules/gapi/include/opencv2/gapi/cpu/stereo.hpp b/modules/gapi/include/opencv2/gapi/cpu/stereo.hpp index f7d79e9b3c..e2a2242bd0 100644 --- a/modules/gapi/include/opencv2/gapi/cpu/stereo.hpp +++ b/modules/gapi/include/opencv2/gapi/cpu/stereo.hpp @@ -25,8 +25,8 @@ struct GAPI_EXPORTS StereoInitParam { int numDisparities = 0; int blockSize = 21; - double baseline = 70.; - double focus = 1000.; + double baseline = 63.5; + double focus = 3.6; }; } // namespace cpu diff --git a/modules/gapi/include/opencv2/gapi/gtype_traits.hpp b/modules/gapi/include/opencv2/gapi/gtype_traits.hpp index 2e8dcb1aec..0b11b18485 100644 --- a/modules/gapi/include/opencv2/gapi/gtype_traits.hpp +++ b/modules/gapi/include/opencv2/gapi/gtype_traits.hpp @@ -43,6 +43,19 @@ namespace detail GOPAQUE, // a cv::GOpaqueU (note - exactly GOpaqueU, not GOpaque!) }; + template + constexpr const char* meta_to_string() noexcept; + template<> + constexpr const char* meta_to_string() noexcept { return "GMatDesc"; } + template<> + constexpr const char* meta_to_string() noexcept { return "GScalarDesc"; } + template<> + constexpr const char* meta_to_string() noexcept { return "GArrayDesc"; } + template<> + constexpr const char* meta_to_string() noexcept { return "GOpaqueDesc"; } + template<> + constexpr const char* meta_to_string() noexcept { return "GFrameDesc";} + // Describe G-API types (G-types) with traits. Mostly used by // cv::GArg to store meta information about types passed into // operation arguments. Please note that cv::GComputation is diff --git a/modules/gapi/include/opencv2/gapi/gtyped.hpp b/modules/gapi/include/opencv2/gapi/gtyped.hpp index 6fe52a62e1..27d9777944 100644 --- a/modules/gapi/include/opencv2/gapi/gtyped.hpp +++ b/modules/gapi/include/opencv2/gapi/gtyped.hpp @@ -35,6 +35,7 @@ namespace detail template<> struct ProtoToMeta { using type = cv::GScalarDesc; }; template struct ProtoToMeta > { using type = cv::GArrayDesc; }; template struct ProtoToMeta > { using type = cv::GOpaqueDesc; }; + template<> struct ProtoToMeta { using type = cv::GFrameDesc; }; template using ProtoToMetaT = typename ProtoToMeta::type; //workaround for MSVC 19.0 bug diff --git a/modules/gapi/include/opencv2/gapi/infer.hpp b/modules/gapi/include/opencv2/gapi/infer.hpp index 7ba3a44881..eb9b9768c9 100644 --- a/modules/gapi/include/opencv2/gapi/infer.hpp +++ b/modules/gapi/include/opencv2/gapi/infer.hpp @@ -531,7 +531,11 @@ typename Net::Result infer(Args&&... args) { } /** - * @brief Special network type + * @brief Generic network type: input and output layers are configured dynamically at runtime + * + * Unlike the network types defined with G_API_NET macro, this one + * doesn't fix number of network inputs and outputs at the compilation stage + * thus providing user with an opportunity to program them in runtime. */ struct Generic { }; diff --git a/modules/gapi/include/opencv2/gapi/infer/ie.hpp b/modules/gapi/include/opencv2/gapi/infer/ie.hpp index 2bed13abc3..0bcb8e6210 100644 --- a/modules/gapi/include/opencv2/gapi/infer/ie.hpp +++ b/modules/gapi/include/opencv2/gapi/infer/ie.hpp @@ -2,7 +2,7 @@ // It is subject to the license terms in the LICENSE file found in the top-level directory // of this distribution and at http://opencv.org/license.html. // -// Copyright (C) 2019 Intel Corporation +// Copyright (C) 2019-2021 Intel Corporation #ifndef OPENCV_GAPI_INFER_IE_HPP #define OPENCV_GAPI_INFER_IE_HPP @@ -29,7 +29,7 @@ namespace ie { GAPI_EXPORTS cv::gapi::GBackend backend(); /** - * Specify how G-API and IE should trait input data + * Specifies how G-API and IE should trait input data * * In OpenCV, the same cv::Mat is used to represent both * image and tensor data. Sometimes those are hardly distinguishable, @@ -47,34 +47,30 @@ enum class TraitAs: int using IEConfig = std::map; namespace detail { - struct ParamDesc { - std::string model_path; - std::string weights_path; - std::string device_id; +struct ParamDesc { + std::string model_path; + std::string weights_path; + std::string device_id; - // NB: Here order follows the `Net` API - std::vector input_names; - std::vector output_names; + std::vector input_names; + std::vector output_names; - using ConstInput = std::pair; - std::unordered_map const_inputs; + using ConstInput = std::pair; + std::unordered_map const_inputs; - // NB: nun_* may differ from topology's real input/output port numbers - // (e.g. topology's partial execution) - std::size_t num_in; // How many inputs are defined in the operation - std::size_t num_out; // How many outputs are defined in the operation + std::size_t num_in; + std::size_t num_out; - enum class Kind { Load, Import }; - Kind kind; - bool is_generic; - IEConfig config; + enum class Kind {Load, Import}; + Kind kind; + bool is_generic; + IEConfig config; - std::map> reshape_table; - std::unordered_set layer_names_to_reshape; + std::map> reshape_table; + std::unordered_set layer_names_to_reshape; - // NB: Number of asyncrhonious infer requests - size_t nireq; - }; + size_t nireq; +}; } // namespace detail // FIXME: this is probably a shared (reusable) thing @@ -88,8 +84,21 @@ struct PortCfg { , std::tuple_size::value >; }; +/** + * @brief This structure provides functions + * that fill inference parameters for "OpenVINO Toolkit" model. + */ template class Params { public: + /** @brief Class constructor. + + Constructs Params based on model information and specifies default values for other + inference description parameters. Model is loaded and compiled using "OpenVINO Toolkit". + + @param model Path to topology IR (.xml file). + @param weights Path to weights (.bin file). + @param device target device to use. + */ Params(const std::string &model, const std::string &weights, const std::string &device) @@ -104,6 +113,13 @@ public: , 1u} { }; + /** @overload + Use this constructor to work with pre-compiled network. + Model is imported from a pre-compiled blob. + + @param model Path to model. + @param device target device to use. + */ Params(const std::string &model, const std::string &device) : desc{ model, {}, device, {}, {}, {} @@ -117,22 +133,53 @@ public: , 1u} { }; - Params& cfgInputLayers(const typename PortCfg::In &ll) { + /** @brief Specifies sequence of network input layers names for inference. + + The function is used to associate cv::gapi::infer<> inputs with the model inputs. + Number of names has to match the number of network inputs as defined in G_API_NET(). + In case a network has only single input layer, there is no need to specify name manually. + + @param layer_names std::array where N is the number of inputs + as defined in the @ref G_API_NET. Contains names of input layers. + @return reference to this parameter structure. + */ + Params& cfgInputLayers(const typename PortCfg::In &layer_names) { desc.input_names.clear(); - desc.input_names.reserve(ll.size()); - std::copy(ll.begin(), ll.end(), + desc.input_names.reserve(layer_names.size()); + std::copy(layer_names.begin(), layer_names.end(), std::back_inserter(desc.input_names)); return *this; } - Params& cfgOutputLayers(const typename PortCfg::Out &ll) { + /** @brief Specifies sequence of network output layers names for inference. + + The function is used to associate cv::gapi::infer<> outputs with the model outputs. + Number of names has to match the number of network outputs as defined in G_API_NET(). + In case a network has only single output layer, there is no need to specify name manually. + + @param layer_names std::array where N is the number of outputs + as defined in the @ref G_API_NET. Contains names of output layers. + @return reference to this parameter structure. + */ + Params& cfgOutputLayers(const typename PortCfg::Out &layer_names) { desc.output_names.clear(); - desc.output_names.reserve(ll.size()); - std::copy(ll.begin(), ll.end(), + desc.output_names.reserve(layer_names.size()); + std::copy(layer_names.begin(), layer_names.end(), std::back_inserter(desc.output_names)); return *this; } + /** @brief Specifies a constant input. + + The function is used to set a constant input. This input has to be + a preprocessed tensor if its type is TENSOR. Need to provide name of the + network layer which will receive provided data. + + @param layer_name Name of network layer. + @param data cv::Mat that contains data which will be associated with network layer. + @param hint Input type @sa cv::gapi::ie::TraitAs. + @return reference to this parameter structure. + */ Params& constInput(const std::string &layer_name, const cv::Mat &data, TraitAs hint = TraitAs::TENSOR) { @@ -140,52 +187,100 @@ public: return *this; } + /** @brief Specifies OpenVINO plugin configuration. + + The function is used to set configuration for OpenVINO plugin. Some parameters + can be different for each plugin. Please follow https://docs.openvinotoolkit.org/latest/index.html + to check information about specific plugin. + + @param cfg Map of pairs: (config parameter name, config parameter value). + @return reference to this parameter structure. + */ + Params& pluginConfig(const IEConfig& cfg) { + desc.config = cfg; + return *this; + } + + /** @overload + Function with a rvalue parameter. + + @param cfg rvalue map of pairs: (config parameter name, config parameter value). + @return reference to this parameter structure. + */ Params& pluginConfig(IEConfig&& cfg) { desc.config = std::move(cfg); return *this; } - Params& pluginConfig(const IEConfig& cfg) { - desc.config = cfg; - return *this; - } + /** @brief Specifies number of asynchronous inference requests. + @param nireq Number of inference asynchronous requests. + @return reference to this parameter structure. + */ Params& cfgNumRequests(size_t nireq) { GAPI_Assert(nireq > 0 && "Number of infer requests must be greater than zero!"); desc.nireq = nireq; return *this; } - Params& cfgInputReshape(std::map>&& reshape_table) { - desc.reshape_table = std::move(reshape_table); - return *this; - } + /** @brief Specifies new input shapes for the network inputs. + The function is used to specify new input shapes for the network inputs. + Follow https://docs.openvinotoolkit.org/latest/classInferenceEngine_1_1networkNetwork.html + for additional information. + + @param reshape_table Map of pairs: name of corresponding data and its dimension. + @return reference to this parameter structure. + */ Params& cfgInputReshape(const std::map>& reshape_table) { desc.reshape_table = reshape_table; return *this; } - Params& cfgInputReshape(std::string&& layer_name, std::vector&& layer_dims) { - desc.reshape_table.emplace(layer_name, layer_dims); + /** @overload */ + Params& cfgInputReshape(std::map>&& reshape_table) { + desc.reshape_table = std::move(reshape_table); return *this; } + /** @overload + + @param layer_name Name of layer. + @param layer_dims New dimensions for this layer. + @return reference to this parameter structure. + */ Params& cfgInputReshape(const std::string& layer_name, const std::vector& layer_dims) { desc.reshape_table.emplace(layer_name, layer_dims); return *this; } - Params& cfgInputReshape(std::unordered_set&& layer_names) { - desc.layer_names_to_reshape = std::move(layer_names); + /** @overload */ + Params& cfgInputReshape(std::string&& layer_name, std::vector&& layer_dims) { + desc.reshape_table.emplace(layer_name, layer_dims); return *this; } + /** @overload + + @param layer_names set of names of network layers that will be used for network reshape. + @return reference to this parameter structure. + */ Params& cfgInputReshape(const std::unordered_set& layer_names) { desc.layer_names_to_reshape = layer_names; return *this; } + /** @overload + + @param layer_names rvalue set of the selected layers will be reshaped automatically + its input image size. + @return reference to this parameter structure. + */ + Params& cfgInputReshape(std::unordered_set&& layer_names) { + desc.layer_names_to_reshape = std::move(layer_names); + return *this; + } + // BEGIN(G-API's network parametrization API) GBackend backend() const { return cv::gapi::ie::backend(); } std::string tag() const { return Net::tag(); } @@ -196,9 +291,24 @@ protected: detail::ParamDesc desc; }; +/* +* @brief This structure provides functions for generic network type that +* fill inference parameters. +* @see struct Generic +*/ template<> class Params { public: + /** @brief Class constructor. + + Constructs Params based on model information and sets default values for other + inference description parameters. Model is loaded and compiled using OpenVINO Toolkit. + + @param tag string tag of the network for which these parameters are intended. + @param model path to topology IR (.xml file). + @param weights path to weights (.bin file). + @param device target device to use. + */ Params(const std::string &tag, const std::string &model, const std::string &weights, @@ -206,22 +316,34 @@ public: : desc{ model, weights, device, {}, {}, {}, 0u, 0u, detail::ParamDesc::Kind::Load, true, {}, {}, {}, 1u}, m_tag(tag) { }; + /** @overload + + This constructor for pre-compiled networks. Model is imported from pre-compiled + blob. + + @param tag string tag of the network for which these parameters are intended. + @param model path to model. + @param device target device to use. + */ Params(const std::string &tag, const std::string &model, const std::string &device) : desc{ model, {}, device, {}, {}, {}, 0u, 0u, detail::ParamDesc::Kind::Import, true, {}, {}, {}, 1u}, m_tag(tag) { }; - Params& pluginConfig(IEConfig&& cfg) { - desc.config = std::move(cfg); - return *this; - } - + /** @see ie::Params::pluginConfig. */ Params& pluginConfig(const IEConfig& cfg) { desc.config = cfg; return *this; } + /** @overload */ + Params& pluginConfig(IEConfig&& cfg) { + desc.config = std::move(cfg); + return *this; + } + + /** @see ie::Params::constInput. */ Params& constInput(const std::string &layer_name, const cv::Mat &data, TraitAs hint = TraitAs::TENSOR) { @@ -229,37 +351,44 @@ public: return *this; } + /** @see ie::Params::cfgNumRequests. */ Params& cfgNumRequests(size_t nireq) { GAPI_Assert(nireq > 0 && "Number of infer requests must be greater than zero!"); desc.nireq = nireq; return *this; } - Params& cfgInputReshape(std::map> && reshape_table) { - desc.reshape_table = std::move(reshape_table); - return *this; - } - + /** @see ie::Params::cfgInputReshape */ Params& cfgInputReshape(const std::map>&reshape_table) { desc.reshape_table = reshape_table; return *this; } + /** @overload */ + Params& cfgInputReshape(std::map> && reshape_table) { + desc.reshape_table = std::move(reshape_table); + return *this; + } + + /** @overload */ Params& cfgInputReshape(std::string && layer_name, std::vector && layer_dims) { desc.reshape_table.emplace(layer_name, layer_dims); return *this; } + /** @overload */ Params& cfgInputReshape(const std::string & layer_name, const std::vector&layer_dims) { desc.reshape_table.emplace(layer_name, layer_dims); return *this; } + /** @overload */ Params& cfgInputReshape(std::unordered_set && layer_names) { desc.layer_names_to_reshape = std::move(layer_names); return *this; } + /** @overload */ Params& cfgInputReshape(const std::unordered_set&layer_names) { desc.layer_names_to_reshape = layer_names; return *this; diff --git a/modules/gapi/include/opencv2/gapi/infer/onnx.hpp b/modules/gapi/include/opencv2/gapi/infer/onnx.hpp index 3a4e35fb09..761f688669 100644 --- a/modules/gapi/include/opencv2/gapi/infer/onnx.hpp +++ b/modules/gapi/include/opencv2/gapi/infer/onnx.hpp @@ -2,7 +2,7 @@ // It is subject to the license terms in the LICENSE file found in the top-level directory // of this distribution and at http://opencv.org/license.html. // -// Copyright (C) 2020 Intel Corporation +// Copyright (C) 2020-2021 Intel Corporation #ifndef OPENCV_GAPI_INFER_ONNX_HPP #define OPENCV_GAPI_INFER_ONNX_HPP @@ -34,32 +34,35 @@ enum class TraitAs: int { using PostProc = std::function &, std::unordered_map &)>; - namespace detail { +/** +* @brief This structure contains description of inference parameters +* which is specific to ONNX models. +*/ struct ParamDesc { - std::string model_path; + std::string model_path; //!< Path to model. // NB: nun_* may differ from topology's real input/output port numbers // (e.g. topology's partial execution) - std::size_t num_in; // How many inputs are defined in the operation - std::size_t num_out; // How many outputs are defined in the operation + std::size_t num_in; //!< How many inputs are defined in the operation + std::size_t num_out; //!< How many outputs are defined in the operation // NB: Here order follows the `Net` API - std::vector input_names; - std::vector output_names; + std::vector input_names; //!< Names of input network layers. + std::vector output_names; //!< Names of output network layers. using ConstInput = std::pair; - std::unordered_map const_inputs; + std::unordered_map const_inputs; //!< Map with pair of name of network layer and ConstInput which will be associated with this. - std::vector mean; - std::vector stdev; + std::vector mean; //!< Mean values for preprocessing. + std::vector stdev; //!< Standard deviation values for preprocessing. - std::vector out_metas; - PostProc custom_post_proc; + std::vector out_metas; //!< Out meta information about your output (type, dimension). + PostProc custom_post_proc; //!< Post processing function. - std::vector normalize; + std::vector normalize; //!< Vector of bool values that enabled or disabled normalize of input data. - std::vector names_to_remap; + std::vector names_to_remap; //!< Names of output layers that will be processed in PostProc function. }; } // namespace detail @@ -79,30 +82,71 @@ struct PortCfg { , std::tuple_size::value >; }; +/** + * Contains description of inference parameters and kit of functions that + * fill this parameters. + */ template class Params { public: + /** @brief Class constructor. + + Constructs Params based on model information and sets default values for other + inference description parameters. + + @param model Path to model (.onnx file). + */ Params(const std::string &model) { desc.model_path = model; desc.num_in = std::tuple_size::value; desc.num_out = std::tuple_size::value; }; - // BEGIN(G-API's network parametrization API) - GBackend backend() const { return cv::gapi::onnx::backend(); } - std::string tag() const { return Net::tag(); } - cv::util::any params() const { return { desc }; } - // END(G-API's network parametrization API) + /** @brief Specifies sequence of network input layers names for inference. - Params& cfgInputLayers(const typename PortCfg::In &ll) { - desc.input_names.assign(ll.begin(), ll.end()); + The function is used to associate data of graph inputs with input layers of + network topology. Number of names has to match the number of network inputs. If a network + has only one input layer, there is no need to call it as the layer is + associated with input automatically but this doesn't prevent you from + doing it yourself. Count of names has to match to number of network inputs. + + @param layer_names std::array where N is the number of inputs + as defined in the @ref G_API_NET. Contains names of input layers. + @return the reference on modified object. + */ + Params& cfgInputLayers(const typename PortCfg::In &layer_names) { + desc.input_names.assign(layer_names.begin(), layer_names.end()); return *this; } - Params& cfgOutputLayers(const typename PortCfg::Out &ll) { - desc.output_names.assign(ll.begin(), ll.end()); + /** @brief Specifies sequence of output layers names for inference. + + The function is used to associate data of graph outputs with output layers of + network topology. If a network has only one output layer, there is no need to call it + as the layer is associated with ouput automatically but this doesn't prevent + you from doing it yourself. Count of names has to match to number of network + outputs or you can set your own output but for this case you have to + additionally use @ref cfgPostProc function. + + @param layer_names std::array where N is the number of outputs + as defined in the @ref G_API_NET. Contains names of output layers. + @return the reference on modified object. + */ + Params& cfgOutputLayers(const typename PortCfg::Out &layer_names) { + desc.output_names.assign(layer_names.begin(), layer_names.end()); return *this; } + /** @brief Sets a constant input. + + The function is used to set constant input. This input has to be + a prepared tensor since preprocessing is disabled for this case. You should + provide name of network layer which will receive provided data. + + @param layer_name Name of network layer. + @param data cv::Mat that contains data which will be associated with network layer. + @param hint Type of input (TENSOR). + @return the reference on modified object. + */ Params& constInput(const std::string &layer_name, const cv::Mat &data, TraitAs hint = TraitAs::TENSOR) { @@ -110,6 +154,17 @@ public: return *this; } + /** @brief Specifies mean value and standard deviation for preprocessing. + + The function is used to set mean value and standard deviation for preprocessing + of input data. + + @param m std::array where N is the number of inputs + as defined in the @ref G_API_NET. Contains mean values. + @param s std::array where N is the number of inputs + as defined in the @ref G_API_NET. Contains standard deviation values. + @return the reference on modified object. + */ Params& cfgMeanStd(const typename PortCfg::NormCoefs &m, const typename PortCfg::NormCoefs &s) { desc.mean.assign(m.begin(), m.end()); @@ -117,75 +172,103 @@ public: return *this; } - /** @brief Configures graph output and sets the post processing function from user. + /** @brief Configures graph output and provides the post processing function from user. - The function is used for the case of infer of networks with dynamic outputs. - Since these networks haven't known output parameters needs provide them for - construction of output of graph. - The function provides meta information of outputs and post processing function. - Post processing function is used for copy information from ONNX infer's result - to output of graph which is allocated by out meta information. + The function is used when you work with networks with dynamic outputs. + Since we can't know dimensions of inference result needs provide them for + construction of graph output. This dimensions can differ from inference result. + So you have to provide @ref PostProc function that gets information from inference + result and fill output which is constructed by dimensions from out_metas. - @param out_metas out meta information. - @param pp post processing function, which has two parameters. First is onnx + @param out_metas Out meta information about your output (type, dimension). + @param remap_function Post processing function, which has two parameters. First is onnx result, second is graph output. Both parameters is std::map that contain pair of layer's name and cv::Mat. - @return reference to object of class Params. + @return the reference on modified object. */ Params& cfgPostProc(const std::vector &out_metas, - const PostProc &pp) { + const PostProc &remap_function) { desc.out_metas = out_metas; - desc.custom_post_proc = pp; + desc.custom_post_proc = remap_function; return *this; } /** @overload - The function has rvalue parameters. + Function with a rvalue parameters. + + @param out_metas rvalue out meta information about your output (type, dimension). + @param remap_function rvalue post processing function, which has two parameters. First is onnx + result, second is graph output. Both parameters is std::map that contain pair of + layer's name and cv::Mat. + @return the reference on modified object. */ Params& cfgPostProc(std::vector &&out_metas, - PostProc &&pp) { + PostProc &&remap_function) { desc.out_metas = std::move(out_metas); - desc.custom_post_proc = std::move(pp); + desc.custom_post_proc = std::move(remap_function); return *this; } /** @overload The function has additional parameter names_to_remap. This parameter provides - information about output layers which will be used for infer and in post + information about output layers which will be used for inference and post processing function. - @param out_metas out meta information. - @param pp post processing function. - @param names_to_remap contains names of output layers. CNN's infer will be done on these layers. - Infer's result will be processed in post processing function using these names. - @return reference to object of class Params. + @param out_metas Out meta information. + @param remap_function Post processing function. + @param names_to_remap Names of output layers. network's inference will + be done on these layers. Inference's result will be processed in post processing + function using these names. + @return the reference on modified object. */ Params& cfgPostProc(const std::vector &out_metas, - const PostProc &pp, + const PostProc &remap_function, const std::vector &names_to_remap) { desc.out_metas = out_metas; - desc.custom_post_proc = pp; + desc.custom_post_proc = remap_function; desc.names_to_remap = names_to_remap; return *this; } /** @overload - The function has rvalue parameters. + Function with a rvalue parameters and additional parameter names_to_remap. + + @param out_metas rvalue out meta information. + @param remap_function rvalue post processing function. + @param names_to_remap rvalue names of output layers. network's inference will + be done on these layers. Inference's result will be processed in post processing + function using these names. + @return the reference on modified object. */ Params& cfgPostProc(std::vector &&out_metas, - PostProc &&pp, + PostProc &&remap_function, std::vector &&names_to_remap) { desc.out_metas = std::move(out_metas); - desc.custom_post_proc = std::move(pp); + desc.custom_post_proc = std::move(remap_function); desc.names_to_remap = std::move(names_to_remap); return *this; } - Params& cfgNormalize(const typename PortCfg::Normalize &n) { - desc.normalize.assign(n.begin(), n.end()); + /** @brief Specifies normalize parameter for preprocessing. + + The function is used to set normalize parameter for preprocessing of input data. + + @param normalizations std::array where N is the number of inputs + as defined in the @ref G_API_NET. Сontains bool values that enabled or disabled + normalize of input data. + @return the reference on modified object. + */ + Params& cfgNormalize(const typename PortCfg::Normalize &normalizations) { + desc.normalize.assign(normalizations.begin(), normalizations.end()); return *this; } + // BEGIN(G-API's network parametrization API) + GBackend backend() const { return cv::gapi::onnx::backend(); } + std::string tag() const { return Net::tag(); } + cv::util::any params() const { return { desc }; } + // END(G-API's network parametrization API) + protected: detail::ParamDesc desc; }; diff --git a/modules/gapi/include/opencv2/gapi/media.hpp b/modules/gapi/include/opencv2/gapi/media.hpp index 3d7f5a5b65..61a7098b55 100644 --- a/modules/gapi/include/opencv2/gapi/media.hpp +++ b/modules/gapi/include/opencv2/gapi/media.hpp @@ -13,6 +13,7 @@ #include // forward<>() #include +#include namespace cv { @@ -30,6 +31,10 @@ public: View access(Access) const; cv::GFrameDesc desc() const; + // FIXME: design a better solution + // Should be used only if the actual adapter provides implementation + cv::util::any blobParams() const; + // Cast underlying MediaFrame adapter to the particular adapter type, // return nullptr if underlying type is different template T* get() const @@ -78,6 +83,9 @@ public: virtual ~IAdapter() = 0; virtual cv::GFrameDesc meta() const = 0; virtual MediaFrame::View access(MediaFrame::Access) = 0; + // FIXME: design a better solution + // The default implementation does nothing + virtual cv::util::any blobParams() const; }; } //namespace cv diff --git a/modules/gapi/include/opencv2/gapi/stereo.hpp b/modules/gapi/include/opencv2/gapi/stereo.hpp index 908045d4c7..278ae34950 100644 --- a/modules/gapi/include/opencv2/gapi/stereo.hpp +++ b/modules/gapi/include/opencv2/gapi/stereo.hpp @@ -14,11 +14,28 @@ namespace cv { namespace gapi { +/** + * The enum specified format of result that you get from @ref cv::gapi::stereo. + */ enum class StereoOutputFormat { - DEPTH_FLOAT16, - DEPTH_FLOAT32, - DISPARITY_FIXED16_11_5, - DISPARITY_FIXED16_12_4 + DEPTH_FLOAT16, ///< Floating point 16 bit value, CV_16FC1. + ///< This identifier is deprecated, use DEPTH_16F instead. + DEPTH_FLOAT32, ///< Floating point 32 bit value, CV_32FC1 + ///< This identifier is deprecated, use DEPTH_16F instead. + DISPARITY_FIXED16_11_5, ///< 16 bit signed: first bit for sign, + ///< 10 bits for integer part, + ///< 5 bits for fractional part. + ///< This identifier is deprecated, + ///< use DISPARITY_16Q_10_5 instead. + DISPARITY_FIXED16_12_4, ///< 16 bit signed: first bit for sign, + ///< 11 bits for integer part, + ///< 4 bits for fractional part. + ///< This identifier is deprecated, + ///< use DISPARITY_16Q_11_4 instead. + DEPTH_16F = DEPTH_FLOAT16, ///< Same as DEPTH_FLOAT16 + DEPTH_32F = DEPTH_FLOAT32, ///< Same as DEPTH_FLOAT32 + DISPARITY_16Q_10_5 = DISPARITY_FIXED16_11_5, ///< Same as DISPARITY_FIXED16_11_5 + DISPARITY_16Q_11_4 = DISPARITY_FIXED16_12_4 ///< Same as DISPARITY_FIXED16_12_4 }; namespace calib3d { @@ -47,13 +64,12 @@ G_TYPED_KERNEL(GStereo, , "org.openc } // namespace calib3d -/** @brief Extract disparity/depth information depending on passed StereoOutputFormat argument. -The function extracts disparity/depth information depending on passed StereoOutputFormat argument from -given stereo-pair. +/** @brief Computes disparity/depth map for the specified stereo-pair. +The function computes disparity or depth map depending on passed StereoOutputFormat argument. -@param left left 8-bit unsigned 1-channel image of @ref CV_8UC1 type -@param right right 8-bit unsigned 1-channel image of @ref CV_8UC1 type -@param of enum to specify output kind: depth or disparity and corresponding type +@param left 8-bit single-channel left image of @ref CV_8UC1 type. +@param right 8-bit single-channel right image of @ref CV_8UC1 type. +@param of enum to specified output kind: depth or disparity and corresponding type */ GAPI_EXPORTS GMat stereo(const GMat& left, const GMat& right, diff --git a/modules/gapi/samples/face_detection_mtcnn.cpp b/modules/gapi/samples/face_detection_mtcnn.cpp index 6e88a9ec56..c437bdbba4 100644 --- a/modules/gapi/samples/face_detection_mtcnn.cpp +++ b/modules/gapi/samples/face_detection_mtcnn.cpp @@ -364,7 +364,8 @@ GAPI_OCV_KERNEL(OCVR_O_NetPreProcGetROIs, R_O_NetPreProcGetROIs) { for (const auto& face : in_faces) { cv::Rect tmp_rect = face.bbox.getRect(); //Compare to transposed sizes width<->height - tmp_rect &= cv::Rect(tmp_rect.x, tmp_rect.y, in_image_size.height - tmp_rect.x - 4, in_image_size.width - tmp_rect.y - 4); + tmp_rect &= cv::Rect(tmp_rect.x, tmp_rect.y, in_image_size.height - tmp_rect.x, in_image_size.width - tmp_rect.y) & + cv::Rect(0, 0, in_image_size.height, in_image_size.width); outs.push_back(tmp_rect); } } diff --git a/modules/gapi/src/api/gproto.cpp b/modules/gapi/src/api/gproto.cpp index 0c7c6462ee..94234c9b4d 100644 --- a/modules/gapi/src/api/gproto.cpp +++ b/modules/gapi/src/api/gproto.cpp @@ -14,6 +14,7 @@ #include "api/gorigin.hpp" #include "api/gproto_priv.hpp" +#include "logger.hpp" // FIXME: it should be a visitor! // FIXME: Reimplement with traits? @@ -201,6 +202,52 @@ bool cv::can_describe(const GMetaArgs &metas, const GRunArgs &args) }); } +void cv::gimpl::proto::validate_input_meta_arg(const cv::GMetaArg& meta) +{ + switch (meta.index()) + { + case cv::GMetaArg::index_of(): + { + cv::gimpl::proto::validate_input_meta(cv::util::get(meta)); //may throw + break; + } + default: + break; + } +} + +void cv::gimpl::proto::validate_input_meta(const cv::GMatDesc& meta) +{ + if (meta.dims.empty()) + { + if (!(meta.size.height > 0 && meta.size.width > 0)) + { + cv::util::throw_error + (std::logic_error( + "Image format is invalid. Size must contain positive values" + ", got width: " + std::to_string(meta.size.width ) + + (", height: ") + std::to_string(meta.size.height))); + } + + if (!(meta.chan > 0)) + { + cv::util::throw_error + (std::logic_error( + "Image format is invalid. Channel mustn't be negative value, got channel: " + + std::to_string(meta.chan))); + } + } + + if (!(meta.depth >= 0)) + { + cv::util::throw_error + (std::logic_error( + "Image format is invalid. Depth must be positive value, got depth: " + + std::to_string(meta.depth))); + } + // All checks are ok +} + // FIXME: Is it tested for all types? // FIXME: Where does this validation happen?? void cv::validate_input_arg(const GRunArg& arg) @@ -212,13 +259,15 @@ void cv::validate_input_arg(const GRunArg& arg) case GRunArg::index_of(): { const auto desc = cv::descr_of(util::get(arg)); - GAPI_Assert(desc.size.height != 0 && desc.size.width != 0 && "incorrect dimensions of cv::UMat!"); break; + cv::gimpl::proto::validate_input_meta(desc); //may throw + break; } #endif // !defined(GAPI_STANDALONE) case GRunArg::index_of(): { const auto desc = cv::descr_of(util::get(arg)); - GAPI_Assert(desc.size.height != 0 && desc.size.width != 0 && "incorrect dimensions of Mat!"); break; + cv::gimpl::proto::validate_input_meta(desc); //may throw + break; } default: // No extra handling @@ -228,9 +277,13 @@ void cv::validate_input_arg(const GRunArg& arg) void cv::validate_input_args(const GRunArgs& args) { + GAPI_LOG_DEBUG(nullptr, "Total count: " << args.size()); + size_t index = 0; for (const auto& arg : args) { + GAPI_LOG_DEBUG(nullptr, "Process index: " << index); validate_input_arg(arg); + index ++; } } diff --git a/modules/gapi/src/api/gproto_priv.hpp b/modules/gapi/src/api/gproto_priv.hpp index b1d71df881..e42afc3461 100644 --- a/modules/gapi/src/api/gproto_priv.hpp +++ b/modules/gapi/src/api/gproto_priv.hpp @@ -31,6 +31,9 @@ GProtoArg rewrap (const GArg &arg); // FIXME:: GAPI_EXPORTS because of tests only!! GAPI_EXPORTS const void* ptr (const GRunArgP &arg); +void validate_input_meta_arg(const GMetaArg& meta); +void validate_input_meta(const GMatDesc& meta); + } // proto } // gimpl } // cv diff --git a/modules/gapi/src/api/media.cpp b/modules/gapi/src/api/media.cpp index 3c171b215f..884fc9e83d 100644 --- a/modules/gapi/src/api/media.cpp +++ b/modules/gapi/src/api/media.cpp @@ -26,6 +26,11 @@ cv::MediaFrame::View cv::MediaFrame::access(Access code) const { return m->adapter->access(code); } +cv::util::any cv::MediaFrame::blobParams() const +{ + return m->adapter->blobParams(); +} + cv::MediaFrame::IAdapter* cv::MediaFrame::getAdapter() const { return m->adapter.get(); } @@ -42,5 +47,11 @@ cv::MediaFrame::View::~View() { } } +cv::util::any cv::MediaFrame::IAdapter::blobParams() const +{ + // Does nothing by default + return {}; +} + cv::MediaFrame::IAdapter::~IAdapter() { } diff --git a/modules/gapi/src/compiler/gcompiler.cpp b/modules/gapi/src/compiler/gcompiler.cpp index 2f442e40bd..7dd3c80cdf 100644 --- a/modules/gapi/src/compiler/gcompiler.cpp +++ b/modules/gapi/src/compiler/gcompiler.cpp @@ -343,19 +343,26 @@ void cv::gimpl::GCompiler::validateInputMeta() return false; // should never happen }; + GAPI_LOG_DEBUG(nullptr, "Total count: " << m_metas.size()); for (const auto meta_arg_idx : ade::util::indexed(ade::util::zip(m_metas, c_expr.m_ins))) { const auto &meta = std::get<0>(ade::util::value(meta_arg_idx)); const auto &proto = std::get<1>(ade::util::value(meta_arg_idx)); + const auto index = ade::util::index(meta_arg_idx); + GAPI_LOG_DEBUG(nullptr, "Process index: " << index); + + // check types validity if (!meta_matches(meta, proto)) { - const auto index = ade::util::index(meta_arg_idx); util::throw_error(std::logic_error ("GComputation object type / metadata descriptor mismatch " "(argument " + std::to_string(index) + ")")); // FIXME: report what we've got and what we've expected } + + // check value consistency + gimpl::proto::validate_input_meta_arg(meta); //may throw } // All checks are ok } diff --git a/modules/gapi/src/compiler/gcompiler.hpp b/modules/gapi/src/compiler/gcompiler.hpp index 85b05d54db..2712c79394 100644 --- a/modules/gapi/src/compiler/gcompiler.hpp +++ b/modules/gapi/src/compiler/gcompiler.hpp @@ -29,7 +29,7 @@ class GAPI_EXPORTS GCompiler cv::gapi::GKernelPackage m_all_kernels; cv::gapi::GNetPackage m_all_networks; - // Patters built from transformations + // Patterns built from transformations std::vector> m_all_patterns; diff --git a/modules/gapi/test/cpu/gapi_stereo_tests_cpu.cpp b/modules/gapi/test/cpu/gapi_stereo_tests_cpu.cpp index 5a70b5faea..bc4ed3fe84 100644 --- a/modules/gapi/test/cpu/gapi_stereo_tests_cpu.cpp +++ b/modules/gapi/test/cpu/gapi_stereo_tests_cpu.cpp @@ -26,11 +26,14 @@ INSTANTIATE_TEST_CASE_P(CPU_Tests, TestGAPIStereo, Values(STEREO_CPU), Values(cv::gapi::StereoOutputFormat::DEPTH_FLOAT16, cv::gapi::StereoOutputFormat::DEPTH_FLOAT32, - cv::gapi::StereoOutputFormat::DISPARITY_FIXED16_12_4), + cv::gapi::StereoOutputFormat::DISPARITY_FIXED16_12_4, + cv::gapi::StereoOutputFormat::DEPTH_16F, + cv::gapi::StereoOutputFormat::DEPTH_32F, + cv::gapi::StereoOutputFormat::DISPARITY_16Q_11_4), Values(16), Values(43), - Values(10.), - Values(100.), + Values(63.5), + Values(3.6), Values(AbsExact().to_compare_obj()))); } // opencv_test diff --git a/modules/gapi/test/gapi_frame_tests.cpp b/modules/gapi/test/gapi_frame_tests.cpp index ab271087dc..5911ef9d9a 100644 --- a/modules/gapi/test/gapi_frame_tests.cpp +++ b/modules/gapi/test/gapi_frame_tests.cpp @@ -174,4 +174,11 @@ TEST(MediaFrame, Callback) { EXPECT_EQ(3, counter); } +TEST(MediaFrame, blobParams) { + cv::Mat bgr = cv::Mat::eye(240, 320, CV_8UC3); + cv::MediaFrame frame = cv::MediaFrame::Create(bgr); + + EXPECT_NO_THROW(frame.blobParams()); +} + } // namespace opencv_test diff --git a/modules/gapi/test/gapi_gcompiled_tests.cpp b/modules/gapi/test/gapi_gcompiled_tests.cpp index 7951a4c2ff..25d02fb8e9 100644 --- a/modules/gapi/test/gapi_gcompiled_tests.cpp +++ b/modules/gapi/test/gapi_gcompiled_tests.cpp @@ -37,6 +37,31 @@ namespace { } }; + + struct GCompiledValidateMetaEmpty: public ::testing::Test + { + cv::GMat in; + cv::GScalar scale; + cv::GComputation m_ucc; + + G_API_OP(GReturn42, (cv::GMat)>, "org.opencv.test.return_42") + { + static GOpaqueDesc outMeta(cv::GMatDesc /* in */) { return cv::empty_gopaque_desc(); } + }; + + GAPI_OCV_KERNEL(GOCVReturn42, GReturn42) + { + static void run(const cv::Mat &/* in */, int &out) + { + out = 42; + } + }; + + GCompiledValidateMetaEmpty() : m_ucc(cv::GIn(in), + cv::GOut(GReturn42::on(in))) + { + } + }; } // anonymous namespace TEST_F(GCompiledValidateMetaTyped, ValidMeta) @@ -170,4 +195,38 @@ TEST_F(GCompiledValidateMetaUntyped, InvalidMetaNumber) EXPECT_THROW(f(cv::gin(in1, sc), cv::gout(out1, out2)), std::logic_error); } +TEST_F(GCompiledValidateMetaEmpty, InvalidMatMetaCompile) +{ + EXPECT_THROW(m_ucc.compile(cv::empty_gmat_desc(), + cv::empty_scalar_desc()), + std::logic_error); +} + +TEST_F(GCompiledValidateMetaEmpty, InvalidMatMetaApply) +{ + cv::Mat emptyIn; + int out {}; + const auto pkg = cv::gapi::kernels(); + + EXPECT_THROW(m_ucc.apply(cv::gin(emptyIn), cv::gout(out), cv::compile_args(pkg)), + std::logic_error); +} + +TEST_F(GCompiledValidateMetaEmpty, ValidInvalidMatMetasApply) +{ + int out {}; + const auto pkg = cv::gapi::kernels(); + + cv::Mat nonEmptyMat = cv::Mat::eye(cv::Size(64,32), CV_8UC1); + m_ucc.apply(cv::gin(nonEmptyMat), cv::gout(out), cv::compile_args(pkg)); + EXPECT_EQ(out, 42); + + cv::Mat emptyIn; + EXPECT_THROW(m_ucc.apply(cv::gin(emptyIn), cv::gout(out), cv::compile_args(pkg)), + std::logic_error); + + out = 0; + m_ucc.apply(cv::gin(nonEmptyMat), cv::gout(out), cv::compile_args(pkg)); + EXPECT_EQ(out, 42); +} } // namespace opencv_test diff --git a/modules/gapi/test/infer/gapi_infer_ie_test.cpp b/modules/gapi/test/infer/gapi_infer_ie_test.cpp index 4ea33f7713..e33f165ae1 100644 --- a/modules/gapi/test/infer/gapi_infer_ie_test.cpp +++ b/modules/gapi/test/infer/gapi_infer_ie_test.cpp @@ -56,6 +56,15 @@ public: cv::MediaFrame::View::Strides ss = { m_mat.step, 0u, 0u, 0u }; return cv::MediaFrame::View(std::move(pp), std::move(ss), Cb{m_cb}); } + cv::util::any blobParams() const override { + return std::make_pair({IE::Precision::U8, + {1, 3, 300, 300}, + IE::Layout::NCHW}, + {{"HELLO", 42}, + {"COLOR_FORMAT", + InferenceEngine::ColorFormat::NV12}}); + } }; class TestMediaNV12 final: public cv::MediaFrame::IAdapter { @@ -2028,6 +2037,21 @@ TEST_F(ROIList, CallInferMultipleTimes) validate(); } +TEST(IEFrameAdapter, blobParams) +{ + cv::Mat bgr = cv::Mat::eye(240, 320, CV_8UC3); + cv::MediaFrame frame = cv::MediaFrame::Create(bgr); + + auto expected = std::make_pair(IE::TensorDesc{IE::Precision::U8, {1, 3, 300, 300}, + IE::Layout::NCHW}, + IE::ParamMap{{"HELLO", 42}, {"COLOR_FORMAT", + IE::ColorFormat::NV12}}); + + auto actual = cv::util::any_cast(frame.blobParams()); + + EXPECT_EQ(expected, actual); +} + } // namespace opencv_test #endif // HAVE_INF_ENGINE diff --git a/modules/highgui/CMakeLists.txt b/modules/highgui/CMakeLists.txt index 9b68b4672e..b4d4b9f503 100644 --- a/modules/highgui/CMakeLists.txt +++ b/modules/highgui/CMakeLists.txt @@ -1,26 +1,5 @@ set(the_description "High-level GUI") -set(ENABLE_PLUGINS_DEFAULT ON) -if(EMSCRIPTEN OR IOS OR WINRT) - set(ENABLE_PLUGINS_DEFAULT OFF) -endif() -set(HIGHGUI_PLUGIN_LIST "" CACHE STRING "List of GUI backends to be compiled as plugins (gtk, gtk2/gtk3, qt, win32 or special value 'all')") -set(HIGHGUI_ENABLE_PLUGINS "${ENABLE_PLUGINS_DEFAULT}" CACHE BOOL "Allow building and using of GUI plugins") -mark_as_advanced(HIGHGUI_PLUGIN_LIST HIGHGUI_ENABLE_PLUGINS) - -string(REPLACE "," ";" HIGHGUI_PLUGIN_LIST "${HIGHGUI_PLUGIN_LIST}") # support comma-separated list (,) too -if(NOT HIGHGUI_ENABLE_PLUGINS) - if(HIGHGUI_PLUGIN_LIST) - message(WARNING "HighGUI: plugins are disabled through HIGHGUI_ENABLE_PLUGINS, so HIGHGUI_PLUGIN_LIST='${HIGHGUI_PLUGIN_LIST}' is ignored") - set(HIGHGUI_PLUGIN_LIST "") - endif() -else() - # Make virtual plugins target - if(NOT TARGET opencv_highgui_plugins) - add_custom_target(opencv_highgui_plugins ALL) - endif() -endif() - if(ANDROID) ocv_add_module(highgui opencv_imgproc opencv_imgcodecs OPTIONAL opencv_videoio WRAP python) else() @@ -68,7 +47,10 @@ file(GLOB highgui_ext_hdrs # Removing WinRT API headers by default list(REMOVE_ITEM highgui_ext_hdrs "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/highgui_winrt.hpp") +set(OPENCV_HIGHGUI_BUILTIN_BACKEND "") + if(HAVE_QT5) + set(OPENCV_HIGHGUI_BUILTIN_BACKEND "QT5") add_definitions(-DHAVE_QT) # "Automoc" doesn't work properly with opencv_world build, use QT5_WRAP_CPP() directly @@ -96,8 +78,8 @@ if(HAVE_QT5) include_directories(${Qt5OpenGL_INCLUDE_DIRS}) list(APPEND HIGHGUI_LIBRARIES ${Qt5OpenGL_LIBRARIES}) endif() - elseif(HAVE_QT) + set(OPENCV_HIGHGUI_BUILTIN_BACKEND "QT4") add_definitions(-DHAVE_QT) if(HAVE_QT_OPENGL) add_definitions(-DHAVE_QT_OPENGL) @@ -115,6 +97,7 @@ elseif(HAVE_QT) set_source_files_properties(${_RCC_OUTFILES} PROPERTIES COMPILE_FLAGS -Wno-missing-declarations) endif() elseif(WINRT) + set(OPENCV_HIGHGUI_BUILTIN_BACKEND "WINRT") if(NOT WINRT_8_0) # Dependencies used by the implementation referenced # below are not available on WinRT 8.0. @@ -149,11 +132,13 @@ elseif(WINRT) message(STATUS " ${name}: Leaving '${HIGHGUI_LIBRARIES}'") endif() elseif(HAVE_WIN32UI) + set(OPENCV_HIGHGUI_BUILTIN_BACKEND "WIN32UI") list(APPEND highgui_srcs ${CMAKE_CURRENT_LIST_DIR}/src/window_w32.cpp) if(OpenCV_ARCH STREQUAL "ARM64") list(APPEND HIGHGUI_LIBRARIES "comdlg32" "advapi32") endif() elseif(HAVE_COCOA) + set(OPENCV_HIGHGUI_BUILTIN_BACKEND "COCOA") add_definitions(-DHAVE_COCOA) list(APPEND highgui_srcs ${CMAKE_CURRENT_LIST_DIR}/src/window_cocoa.mm) list(APPEND HIGHGUI_LIBRARIES "-framework Cocoa") @@ -170,16 +155,31 @@ if(TARGET ocv.3rdparty.gtk3 OR TARGET ocv.3rdparty.gtk2) AND NOT "gtk" IN_LIST HIGHGUI_PLUGIN_LIST AND NOT "gtk2" IN_LIST HIGHGUI_PLUGIN_LIST AND NOT "gtk3" IN_LIST HIGHGUI_PLUGIN_LIST + AND NOT OPENCV_HIGHGUI_BUILTIN_BACKEND ) + if(__gtk_dependency STREQUAL "ocv.3rdparty.gtk3") + set(OPENCV_HIGHGUI_BUILTIN_BACKEND "GTK3") + elseif(__gtk_dependency STREQUAL "ocv.3rdparty.gtk2") + set(OPENCV_HIGHGUI_BUILTIN_BACKEND "GTK2") + else() + set(OPENCV_HIGHGUI_BUILTIN_BACKEND "GTK") + endif() list(APPEND highgui_srcs ${CMAKE_CURRENT_LIST_DIR}/src/window_gtk.cpp) list(APPEND tgts ${__gtk_dependency}) if(TARGET ocv.3rdparty.gthread) list(APPEND tgts ocv.3rdparty.gthread) endif() if(TARGET ocv.3rdparty.gtkglext + AND __gtk_dependency STREQUAL "ocv.3rdparty.gtk2" AND NOT OPENCV_GTK_DISABLE_GTKGLEXT ) list(APPEND tgts ocv.3rdparty.gtkglext) + if(TARGET ocv.3rdparty.gtk_opengl + AND __gtk_dependency STREQUAL "ocv.3rdparty.gtk2" + AND NOT OPENCV_GTK_DISABLE_OPENGL + ) + list(APPEND tgts ocv.3rdparty.gtk_opengl) + endif() endif() elseif("gtk" IN_LIST HIGHGUI_PLUGIN_LIST) ocv_create_builtin_highgui_plugin(opencv_highgui_gtk ${__gtk_dependency} "window_gtk.cpp") @@ -211,6 +211,11 @@ if(TARGET ocv.3rdparty.gtk3 OR TARGET ocv.3rdparty.gtk2) endif() endif() +if(NOT OPENCV_HIGHGUI_BUILTIN_BACKEND) + set(OPENCV_HIGHGUI_BUILTIN_BACKEND "NONE") +endif() +message(STATUS "highgui: using builtin backend: ${OPENCV_HIGHGUI_BUILTIN_BACKEND}") # FIXIT: propagate to root CMake + if(TRUE) # these variables are set by 'ocv_append_build_options(HIGHGUI ...)' foreach(P ${HIGHGUI_INCLUDE_DIRS}) @@ -271,3 +276,15 @@ if(HIGHGUI_ENABLE_PLUGINS) endif() ocv_target_link_libraries(${the_module} LINK_PRIVATE ${tgts}) + +# generate module configuration +set(CONFIG_STR "// Auto-generated file +#define OPENCV_HIGHGUI_BUILTIN_BACKEND_STR \"${OPENCV_HIGHGUI_BUILTIN_BACKEND}\" +") +if(OPENCV_HIGHGUI_BUILTIN_BACKEND STREQUAL "NONE") +set(CONFIG_STR "${CONFIG_STR} +#define OPENCV_HIGHGUI_WITHOUT_BUILTIN_BACKEND 1 +") +endif() + +ocv_update_file("${CMAKE_CURRENT_BINARY_DIR}/opencv_highgui_config.hpp" "${CONFIG_STR}") diff --git a/modules/highgui/cmake/detect_gtk.cmake b/modules/highgui/cmake/detect_gtk.cmake index 1f91986020..cdc054fad0 100644 --- a/modules/highgui/cmake/detect_gtk.cmake +++ b/modules/highgui/cmake/detect_gtk.cmake @@ -1,5 +1,5 @@ # --- GTK --- -ocv_clear_vars(HAVE_GTK HAVE_GTK3 HAVE_GTHREAD HAVE_GTKGLEXT) +ocv_clear_vars(HAVE_GTK HAVE_GTK2 HAVE_GTK3 HAVE_GTHREAD HAVE_GTKGLEXT) if(WITH_GTK) if(NOT WITH_GTK_2_X) ocv_check_modules(GTK3 gtk+-3.0) @@ -32,7 +32,7 @@ if(WITH_GTK) set(HAVE_GTHREAD "${HAVE_GTHREAD}" PARENT_SCOPE) # informational set(GTHREAD_VERSION "${GTHREAD_VERSION}" PARENT_SCOPE) # informational endif() - if(WITH_OPENGL AND NOT HAVE_GTK3) + if((WITH_OPENGL OR HAVE_OPENGL) AND HAVE_GTK2) ocv_check_modules(GTKGLEXT gtkglext-1.0) if(HAVE_GTKGLEXT) ocv_add_external_target(gtkglext "${GTKGLEXT_INCLUDE_DIRS}" "${GTKGLEXT_LIBRARIES}" "HAVE_GTKGLEXT") @@ -44,4 +44,13 @@ elseif(HAVE_GTK) ocv_add_external_target(gtk "${GTK_INCLUDE_DIRS}" "${GTK_LIBRARIES}" "${GTK_DEFINES};HAVE_GTK") endif() +if(WITH_OPENGL AND HAVE_GTKGLEXT) + find_package(OpenGL QUIET) + if(OPENGL_FOUND) + set(HAVE_OPENGL TRUE) + #set(HAVE_OPENGL ${HAVE_OPENGL} PARENT_SCOPE) + ocv_add_external_target(gtk_opengl "${OPENGL_INCLUDE_DIRS}" "${OPENGL_LIBRARIES}" "HAVE_OPENGL") + endif() +endif() + set(HAVE_GTK ${HAVE_GTK} PARENT_SCOPE) diff --git a/modules/highgui/cmake/init.cmake b/modules/highgui/cmake/init.cmake index 1a115f22ed..3b766b3758 100644 --- a/modules/highgui/cmake/init.cmake +++ b/modules/highgui/cmake/init.cmake @@ -1,3 +1,30 @@ +if(PROJECT_NAME STREQUAL "OpenCV") + set(ENABLE_PLUGINS_DEFAULT ON) + if(EMSCRIPTEN OR IOS OR WINRT) + set(ENABLE_PLUGINS_DEFAULT OFF) + endif() + set(HIGHGUI_PLUGIN_LIST "" CACHE STRING "List of GUI backends to be compiled as plugins (gtk, gtk2/gtk3, qt, win32 or special value 'all')") + set(HIGHGUI_ENABLE_PLUGINS "${ENABLE_PLUGINS_DEFAULT}" CACHE BOOL "Allow building and using of GUI plugins") + mark_as_advanced(HIGHGUI_PLUGIN_LIST HIGHGUI_ENABLE_PLUGINS) + + string(REPLACE "," ";" HIGHGUI_PLUGIN_LIST "${HIGHGUI_PLUGIN_LIST}") # support comma-separated list (,) too + if(NOT HIGHGUI_ENABLE_PLUGINS) + if(HIGHGUI_PLUGIN_LIST) + message(WARNING "HighGUI: plugins are disabled through HIGHGUI_ENABLE_PLUGINS, so HIGHGUI_PLUGIN_LIST='${HIGHGUI_PLUGIN_LIST}' is ignored") + set(HIGHGUI_PLUGIN_LIST "") + endif() + else() + # Make virtual plugins target + if(NOT TARGET opencv_highgui_plugins) + add_custom_target(opencv_highgui_plugins ALL) + endif() + endif() +endif() + +# +# Detect available dependencies +# + include(FindPkgConfig) # FIXIT: stop using PARENT_SCOPE in dependencies diff --git a/modules/highgui/misc/plugins/build_plugins.sh b/modules/highgui/misc/plugins/build_plugins.sh index a27f4a0eca..0018eef3ba 100755 --- a/modules/highgui/misc/plugins/build_plugins.sh +++ b/modules/highgui/misc/plugins/build_plugins.sh @@ -11,7 +11,7 @@ DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" OCV="$( cd "${DIR}/../../../.." >/dev/null 2>&1 && pwd )" mkdir -p "${1}" # Docker creates non-existed mounts with 'root' owner, lets ensure that dir exists under the current user to avoid "Permission denied" problem DST="$( cd "$1" >/dev/null 2>&1 && pwd )" -CFG=$2 +CFG=${2:-Release} do_build() { @@ -40,30 +40,33 @@ docker run \ -e CFG=$CFG \ --user $(id -u):$(id -g) \ $TAG \ - $@ + "$@" } build_gtk2_ubuntu() { VER=$1 +shift 1 TAG=opencv_highgui_ubuntu_gtk2_builder:${VER} do_build $TAG "${DIR}/plugin_gtk" Dockerfile-ubuntu-gtk2 --build-arg VER=${VER} -do_run $TAG /opencv/modules/highgui/misc/plugins/plugin_gtk/build.sh /dst gtk2_ubuntu${VER} ${CFG} +do_run $TAG /opencv/modules/highgui/misc/plugins/plugin_gtk/build.sh /dst gtk2_ubuntu${VER} ${CFG} "$@" } build_gtk3_ubuntu() { VER=$1 +shift 1 TAG=opencv_highgui_ubuntu_gtk3_builder:${VER} do_build $TAG "${DIR}/plugin_gtk" Dockerfile-ubuntu-gtk3 --build-arg VER=${VER} -do_run $TAG /opencv/modules/highgui/misc/plugins/plugin_gtk/build.sh /dst gtk3_ubuntu${VER} ${CFG} +do_run $TAG /opencv/modules/highgui/misc/plugins/plugin_gtk/build.sh /dst gtk3_ubuntu${VER} ${CFG} "$@" } echo "OpenCV: ${OCV}" echo "Destination: ${DST}" build_gtk2_ubuntu 16.04 +build_gtk2_ubuntu 16.04 -DOPENCV_PLUGIN_NAME=opencv_highgui_gtk2-opengl_ubuntu16.04 -DWITH_OPENGL=ON -DWITH_GTK_2_X=ON build_gtk2_ubuntu 18.04 build_gtk3_ubuntu 18.04 build_gtk3_ubuntu 20.04 diff --git a/modules/highgui/misc/plugins/plugin_gtk/CMakeLists.txt b/modules/highgui/misc/plugins/plugin_gtk/CMakeLists.txt index 22462900f1..6a2da0c9c3 100644 --- a/modules/highgui/misc/plugins/plugin_gtk/CMakeLists.txt +++ b/modules/highgui/misc/plugins/plugin_gtk/CMakeLists.txt @@ -25,6 +25,21 @@ else() message(FATAL_ERROR "Missing dependency target for GTK libraries") endif() ocv_create_plugin(highgui "opencv_highgui_gtk" "${__deps}" "GTK" "src/window_gtk.cpp") +if(WITH_OPENGL) + if(HAVE_GTK2 + AND TARGET ocv.3rdparty.gtkglext + AND TARGET ocv.3rdparty.gtk_opengl + AND NOT OPENCV_GTK_DISABLE_GTKGLEXT + AND NOT OPENCV_GTK_DISABLE_OPENGL + ) + message(STATUS "OpenGL: YES") + target_link_libraries(${OPENCV_PLUGIN_NAME} PRIVATE + ocv.3rdparty.gtkglext ocv.3rdparty.gtk_opengl + ) + else() + message(WARNING "OpenGL dependencies are not available!") + endif() +endif() if(HAVE_GTK3) message(STATUS "GTK3+: ver ${GTK3_VERSION}") @@ -41,8 +56,3 @@ if(HAVE_GTHREAD) else() message(STATUS "GThread : NO") endif() -if(HAVE_GTKGLEXT) - message(STATUS "GtkGlExt: YES (ver ${GTKGLEXT_VERSION})") -else() - message(STATUS "GtkGlExt: NO") -endif() diff --git a/modules/highgui/misc/plugins/plugin_gtk/Dockerfile-ubuntu-gtk2 b/modules/highgui/misc/plugins/plugin_gtk/Dockerfile-ubuntu-gtk2 index 81836cb384..fefa0ba339 100644 --- a/modules/highgui/misc/plugins/plugin_gtk/Dockerfile-ubuntu-gtk2 +++ b/modules/highgui/misc/plugins/plugin_gtk/Dockerfile-ubuntu-gtk2 @@ -18,4 +18,11 @@ RUN \ && \ rm -rf /var/lib/apt/lists/* +RUN \ + apt-get update && \ + DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \ + libgtkglext1-dev \ + && \ + rm -rf /var/lib/apt/lists/* + WORKDIR /tmp diff --git a/modules/highgui/misc/plugins/plugin_gtk/build.sh b/modules/highgui/misc/plugins/plugin_gtk/build.sh index 58048698db..4383016910 100755 --- a/modules/highgui/misc/plugins/plugin_gtk/build.sh +++ b/modules/highgui/misc/plugins/plugin_gtk/build.sh @@ -4,10 +4,18 @@ set -e DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" +OPENCV_PLUGIN_DESTINATION=$1 +OPENCV_PLUGIN_NAME=opencv_highgui_$2 +CMAKE_BUILD_TYPE=${3:-Release} + +shift 3 || true + +set -x cmake -GNinja \ - -DOPENCV_PLUGIN_NAME=opencv_highgui_$2 \ - -DOPENCV_PLUGIN_DESTINATION=$1 \ - -DCMAKE_BUILD_TYPE=$3 \ + -DOPENCV_PLUGIN_NAME=${OPENCV_PLUGIN_NAME} \ + -DOPENCV_PLUGIN_DESTINATION=${OPENCV_PLUGIN_DESTINATION} \ + -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} \ + "$@" \ $DIR ninja -v diff --git a/modules/highgui/src/backend.cpp b/modules/highgui/src/backend.cpp index 4c0de0584e..9ea475cecc 100644 --- a/modules/highgui/src/backend.cpp +++ b/modules/highgui/src/backend.cpp @@ -103,7 +103,7 @@ std::shared_ptr createUIBackend() } if (name.empty()) { - CV_LOG_DEBUG(NULL, "UI: fallback on builtin code"); + CV_LOG_DEBUG(NULL, "UI: fallback on builtin code: " OPENCV_HIGHGUI_BUILTIN_BACKEND_STR); } else { diff --git a/modules/highgui/src/plugin_wrapper.impl.hpp b/modules/highgui/src/plugin_wrapper.impl.hpp index 3fa2cfa11a..97aea69098 100644 --- a/modules/highgui/src/plugin_wrapper.impl.hpp +++ b/modules/highgui/src/plugin_wrapper.impl.hpp @@ -232,8 +232,12 @@ std::vector getPluginCandidates(const std::string& baseName) return results; } +// NB: require loading of imgcodecs module +static void* g_imwrite = (void*)imwrite; + void PluginUIBackendFactory::loadPlugin() { + CV_Assert(g_imwrite); for (const FileSystemPath_t& plugin : getPluginCandidates(baseName_)) { auto lib = std::make_shared(plugin); diff --git a/modules/highgui/src/precomp.hpp b/modules/highgui/src/precomp.hpp index 275cc556ae..6ad5bce8b4 100644 --- a/modules/highgui/src/precomp.hpp +++ b/modules/highgui/src/precomp.hpp @@ -47,6 +47,9 @@ #endif #include "opencv2/highgui.hpp" +#if !defined(BUILD_PLUGIN) +#include "opencv_highgui_config.hpp" // generated by CMake +#endif #include "opencv2/core/utility.hpp" #if defined(__OPENCV_BUILD) diff --git a/modules/highgui/src/registry.impl.hpp b/modules/highgui/src/registry.impl.hpp index a2e4dbea47..ccf81f9280 100644 --- a/modules/highgui/src/registry.impl.hpp +++ b/modules/highgui/src/registry.impl.hpp @@ -162,6 +162,9 @@ public: const BackendInfo& info = enabledBackends[i]; os << info.name << '(' << info.priority << ')'; } +#if !defined(OPENCV_HIGHGUI_WITHOUT_BUILTIN_BACKEND) + os << " + BUILTIN(" OPENCV_HIGHGUI_BUILTIN_BACKEND_STR ")"; +#endif return os.str(); } diff --git a/modules/highgui/src/window.cpp b/modules/highgui/src/window.cpp index 7a4532e1b8..dca6ddbaf8 100644 --- a/modules/highgui/src/window.cpp +++ b/modules/highgui/src/window.cpp @@ -179,6 +179,14 @@ static void cleanupTrackbarCallbacksWithData_() using namespace cv::impl; +#if defined(OPENCV_HIGHGUI_WITHOUT_BUILTIN_BACKEND) && defined(ENABLE_PLUGINS) +static void deprecateNotFoundNoOpBehavior() +{ + CV_LOG_ONCE_WARNING(NULL, "This no-op behavior is deprecated. Future versions of OpenCV will trigger exception in this case"); +} +#define CV_NOT_FOUND_DEPRECATION deprecateNotFoundNoOpBehavior() +#endif + CV_IMPL void cvSetWindowProperty(const char* name, int prop_id, double prop_value) { CV_TRACE_FUNCTION(); @@ -193,6 +201,19 @@ CV_IMPL void cvSetWindowProperty(const char* name, int prop_id, double prop_valu } } +#if defined(OPENCV_HIGHGUI_WITHOUT_BUILTIN_BACKEND) && defined(ENABLE_PLUGINS) + auto backend = getCurrentUIBackend(); + if (backend) + { + CV_LOG_WARNING(NULL, "Can't find window with name: '" << name << "'. Do nothing"); + CV_NOT_FOUND_DEPRECATION; + } + else + { + CV_LOG_WARNING(NULL, "No UI backends available. Use OPENCV_LOG_LEVEL=DEBUG for investigation"); + } + return; +#else switch(prop_id) { //change between fullscreen or not. @@ -249,6 +270,7 @@ CV_IMPL void cvSetWindowProperty(const char* name, int prop_id, double prop_valu default:; } +#endif } /* return -1 if error */ @@ -268,6 +290,19 @@ CV_IMPL double cvGetWindowProperty(const char* name, int prop_id) } } +#if defined(OPENCV_HIGHGUI_WITHOUT_BUILTIN_BACKEND) && defined(ENABLE_PLUGINS) + auto backend = getCurrentUIBackend(); + if (backend) + { + CV_LOG_WARNING(NULL, "Can't find window with name: '" << name << "'. Do nothing"); + CV_NOT_FOUND_DEPRECATION; + } + else + { + CV_LOG_WARNING(NULL, "No UI backends available. Use OPENCV_LOG_LEVEL=DEBUG for investigation"); + } + return -1; +#else switch(prop_id) { case CV_WND_PROP_FULLSCREEN: @@ -361,13 +396,13 @@ CV_IMPL double cvGetWindowProperty(const char* name, int prop_id) default: return -1; } +#endif } cv::Rect cvGetWindowImageRect(const char* name) { CV_TRACE_FUNCTION(); - if (!name) - return cv::Rect(-1, -1, -1, -1); + CV_Assert(name); { auto window = findWindow_(name); @@ -377,6 +412,20 @@ cv::Rect cvGetWindowImageRect(const char* name) } } +#if defined(OPENCV_HIGHGUI_WITHOUT_BUILTIN_BACKEND) && defined(ENABLE_PLUGINS) + auto backend = getCurrentUIBackend(); + if (backend) + { + CV_LOG_WARNING(NULL, "Can't find window with name: '" << name << "'. Do nothing"); + CV_NOT_FOUND_DEPRECATION; + } + else + { + CV_LOG_WARNING(NULL, "No UI backends available. Use OPENCV_LOG_LEVEL=DEBUG for investigation"); + } + return Rect(-1, -1, -1, -1); +#else + #if defined (HAVE_QT) return cvGetWindowRect_QT(name); #elif defined(HAVE_WIN32UI) @@ -386,8 +435,10 @@ cv::Rect cvGetWindowImageRect(const char* name) #elif defined (HAVE_COCOA) return cvGetWindowRect_COCOA(name); #else - return cv::Rect(-1, -1, -1, -1); + return Rect(-1, -1, -1, -1); #endif + +#endif } cv::Rect cv::getWindowImageRect(const String& winname) @@ -483,7 +534,21 @@ void cv::resizeWindow( const String& winname, int width, int height ) } } +#if defined(OPENCV_HIGHGUI_WITHOUT_BUILTIN_BACKEND) && defined(ENABLE_PLUGINS) + auto backend = getCurrentUIBackend(); + if (backend) + { + CV_LOG_WARNING(NULL, "Can't find window with name: '" << winname << "'. Do nothing"); + CV_NOT_FOUND_DEPRECATION; + } + else + { + CV_LOG_WARNING(NULL, "No UI backends available. Use OPENCV_LOG_LEVEL=DEBUG for investigation"); + } + return; +#else cvResizeWindow( winname.c_str(), width, height ); +#endif } void cv::resizeWindow(const String& winname, const cv::Size& size) @@ -504,7 +569,21 @@ void cv::moveWindow( const String& winname, int x, int y ) } } +#if defined(OPENCV_HIGHGUI_WITHOUT_BUILTIN_BACKEND) && defined(ENABLE_PLUGINS) + auto backend = getCurrentUIBackend(); + if (backend) + { + CV_LOG_WARNING(NULL, "Can't find window with name: '" << winname << "'. Do nothing"); + CV_NOT_FOUND_DEPRECATION; + } + else + { + CV_LOG_WARNING(NULL, "No UI backends available. Use OPENCV_LOG_LEVEL=DEBUG for investigation"); + } + return; +#else cvMoveWindow( winname.c_str(), x, y ); +#endif } void cv::setWindowProperty(const String& winname, int prop_id, double prop_value) @@ -616,8 +695,22 @@ int cv::createTrackbar(const String& trackbarName, const String& winName, } } +#if defined(OPENCV_HIGHGUI_WITHOUT_BUILTIN_BACKEND) && defined(ENABLE_PLUGINS) + auto backend = getCurrentUIBackend(); + if (backend) + { + CV_LOG_WARNING(NULL, "Can't find window with name: '" << winName << "'. Do nothing"); + CV_NOT_FOUND_DEPRECATION; + } + else + { + CV_LOG_WARNING(NULL, "No UI backends available. Use OPENCV_LOG_LEVEL=DEBUG for investigation"); + } + return 0; +#else return cvCreateTrackbar2(trackbarName.c_str(), winName.c_str(), value, count, callback, userdata); +#endif } void cv::setTrackbarPos( const String& trackbarName, const String& winName, int value ) @@ -635,7 +728,21 @@ void cv::setTrackbarPos( const String& trackbarName, const String& winName, int } } +#if defined(OPENCV_HIGHGUI_WITHOUT_BUILTIN_BACKEND) && defined(ENABLE_PLUGINS) + auto backend = getCurrentUIBackend(); + if (backend) + { + CV_LOG_WARNING(NULL, "Can't find window with name: '" << winName << "'. Do nothing"); + CV_NOT_FOUND_DEPRECATION; + } + else + { + CV_LOG_WARNING(NULL, "No UI backends available. Use OPENCV_LOG_LEVEL=DEBUG for investigation"); + } + return; +#else cvSetTrackbarPos(trackbarName.c_str(), winName.c_str(), value ); +#endif } void cv::setTrackbarMax(const String& trackbarName, const String& winName, int maxval) @@ -655,7 +762,21 @@ void cv::setTrackbarMax(const String& trackbarName, const String& winName, int m } } +#if defined(OPENCV_HIGHGUI_WITHOUT_BUILTIN_BACKEND) && defined(ENABLE_PLUGINS) + auto backend = getCurrentUIBackend(); + if (backend) + { + CV_LOG_WARNING(NULL, "Can't find window with name: '" << winName << "'. Do nothing"); + CV_NOT_FOUND_DEPRECATION; + } + else + { + CV_LOG_WARNING(NULL, "No UI backends available. Use OPENCV_LOG_LEVEL=DEBUG for investigation"); + } + return; +#else cvSetTrackbarMax(trackbarName.c_str(), winName.c_str(), maxval); +#endif } void cv::setTrackbarMin(const String& trackbarName, const String& winName, int minval) @@ -675,7 +796,21 @@ void cv::setTrackbarMin(const String& trackbarName, const String& winName, int m } } +#if defined(OPENCV_HIGHGUI_WITHOUT_BUILTIN_BACKEND) && defined(ENABLE_PLUGINS) + auto backend = getCurrentUIBackend(); + if (backend) + { + CV_LOG_WARNING(NULL, "Can't find window with name: '" << winName << "'. Do nothing"); + CV_NOT_FOUND_DEPRECATION; + } + else + { + CV_LOG_WARNING(NULL, "No UI backends available. Use OPENCV_LOG_LEVEL=DEBUG for investigation"); + } + return; +#else cvSetTrackbarMin(trackbarName.c_str(), winName.c_str(), minval); +#endif } int cv::getTrackbarPos( const String& trackbarName, const String& winName ) @@ -693,7 +828,21 @@ int cv::getTrackbarPos( const String& trackbarName, const String& winName ) } } +#if defined(OPENCV_HIGHGUI_WITHOUT_BUILTIN_BACKEND) && defined(ENABLE_PLUGINS) + auto backend = getCurrentUIBackend(); + if (backend) + { + CV_LOG_WARNING(NULL, "Can't find window with name: '" << winName << "'. Do nothing"); + CV_NOT_FOUND_DEPRECATION; + } + else + { + CV_LOG_WARNING(NULL, "No UI backends available. Use OPENCV_LOG_LEVEL=DEBUG for investigation"); + } + return -1; +#else return cvGetTrackbarPos(trackbarName.c_str(), winName.c_str()); +#endif } void cv::setMouseCallback( const String& windowName, MouseCallback onMouse, void* param) @@ -709,7 +858,21 @@ void cv::setMouseCallback( const String& windowName, MouseCallback onMouse, void } } +#if defined(OPENCV_HIGHGUI_WITHOUT_BUILTIN_BACKEND) && defined(ENABLE_PLUGINS) + auto backend = getCurrentUIBackend(); + if (backend) + { + CV_LOG_WARNING(NULL, "Can't find window with name: '" << windowName << "'. Do nothing"); + CV_NOT_FOUND_DEPRECATION; + } + else + { + CV_LOG_WARNING(NULL, "No UI backends available. Use OPENCV_LOG_LEVEL=DEBUG for investigation"); + } + return; +#else cvSetMouseCallback(windowName.c_str(), onMouse, param); +#endif } int cv::getMouseWheelDelta( int flags ) diff --git a/modules/highgui/src/window_gtk.cpp b/modules/highgui/src/window_gtk.cpp index f2d02d66b0..efa3fbd96f 100644 --- a/modules/highgui/src/window_gtk.cpp +++ b/modules/highgui/src/window_gtk.cpp @@ -45,6 +45,14 @@ #if defined (HAVE_GTK) #include + +#if (GTK_MAJOR_VERSION == 3) && defined(HAVE_OPENGL) + #undef HAVE_OPENGL // no support with GTK3 +#endif +#if defined(HAVE_OPENGL) && !defined(HAVE_GTKGLEXT) + #undef HAVE_OPENGL // gtkglext is required +#endif + #include #include #include @@ -1187,7 +1195,7 @@ static std::shared_ptr namedWindow_(const std::string& name, int flags #ifdef HAVE_OPENGL if (window->useGl) - cvSetOpenGlContext(name); + cvSetOpenGlContext(name.c_str()); #endif return window_ptr; @@ -1205,7 +1213,7 @@ CV_IMPL void cvSetOpenGlContext(const char* name) CV_LOCK_MUTEX(); - CvWindow* window = icvFindWindowByName(name); + auto window = icvFindWindowByName(name); if (!window) CV_Error( CV_StsNullPtr, "NULL window" ); @@ -1225,7 +1233,7 @@ CV_IMPL void cvUpdateWindow(const char* name) CV_LOCK_MUTEX(); - CvWindow* window = icvFindWindowByName(name); + auto window = icvFindWindowByName(name); if (!window) return; @@ -1239,7 +1247,7 @@ CV_IMPL void cvSetOpenGlDrawCallback(const char* name, CvOpenGlDrawCallback call CV_LOCK_MUTEX(); - CvWindow* window = icvFindWindowByName(name); + auto window = icvFindWindowByName(name); if( !window ) return; @@ -1905,17 +1913,19 @@ static gboolean icvOnClose( GtkWidget* widget, GdkEvent* /*event*/, gpointer use static gboolean icvOnMouse( GtkWidget *widget, GdkEvent *event, gpointer user_data ) { // TODO move this logic to CvImageWidget + // TODO add try-catch wrappers into all callbacks CvWindow* window = (CvWindow*)user_data; + if (!window || !widget || + window->signature != CV_WINDOW_MAGIC_VAL || + window->widget != widget || + !window->on_mouse) + return FALSE; + CvPoint2D32f pt32f = {-1., -1.}; CvPoint pt = {-1,-1}; int cv_event = -1, state = 0, flags = 0; CvImageWidget * image_widget = CV_IMAGE_WIDGET( widget ); - if( window->signature != CV_WINDOW_MAGIC_VAL || - window->widget != widget || !window->widget || - !window->on_mouse /*|| !image_widget->original_image*/) - return FALSE; - if( event->type == GDK_MOTION_NOTIFY ) { GdkEventMotion* event_motion = (GdkEventMotion*)event; @@ -2008,8 +2018,10 @@ static gboolean icvOnMouse( GtkWidget *widget, GdkEvent *event, gpointer user_da pt = cvPointFrom32f( pt32f ); } - if((unsigned)pt.x < (unsigned)(image_widget->original_image->width) && - (unsigned)pt.y < (unsigned)(image_widget->original_image->height) ) + if (!image_widget->original_image/*OpenGL*/ || ( + (unsigned)pt.x < (unsigned)(image_widget->original_image->width) && + (unsigned)pt.y < (unsigned)(image_widget->original_image->height) + )) { flags |= BIT_MAP(state, GDK_SHIFT_MASK, CV_EVENT_FLAG_SHIFTKEY) | BIT_MAP(state, GDK_CONTROL_MASK, CV_EVENT_FLAG_CTRLKEY) | @@ -2319,6 +2331,11 @@ public: class GTKBackendUI : public UIBackend { public: + GTKBackendUI() + { + // NB: avoid static initialization order fiasco + (void)getGTKWindows(); + } ~GTKBackendUI() CV_OVERRIDE { destroyAllWindows(); diff --git a/modules/java/android_sdk/android_gradle_lib/build.gradle b/modules/java/android_sdk/android_gradle_lib/build.gradle index 8f969a0a86..3966c9def6 100644 --- a/modules/java/android_sdk/android_gradle_lib/build.gradle +++ b/modules/java/android_sdk/android_gradle_lib/build.gradle @@ -1,4 +1,5 @@ apply plugin: 'com.android.library' +@KOTLIN_PLUGIN_DECLARATION@ def openCVersionName = "@OPENCV_VERSION@" def openCVersionCode = ((@OPENCV_VERSION_MAJOR@ * 100 + @OPENCV_VERSION_MINOR@) * 100 + @OPENCV_VERSION_PATCH@) * 10 + 0 diff --git a/modules/java/android_sdk/build.gradle.in b/modules/java/android_sdk/build.gradle.in index 4ff5cd86be..3ac66b3c79 100644 --- a/modules/java/android_sdk/build.gradle.in +++ b/modules/java/android_sdk/build.gradle.in @@ -89,6 +89,7 @@ // apply plugin: 'com.android.library' +@KOTLIN_PLUGIN_DECLARATION@ def openCVersionName = "@OPENCV_VERSION@" def openCVersionCode = ((@OPENCV_VERSION_MAJOR@ * 100 + @OPENCV_VERSION_MINOR@) * 100 + @OPENCV_VERSION_PATCH@) * 10 + 0 diff --git a/modules/java/generator/gen_java.py b/modules/java/generator/gen_java.py index b0769178c6..a5f403b246 100755 --- a/modules/java/generator/gen_java.py +++ b/modules/java/generator/gen_java.py @@ -1250,13 +1250,13 @@ JNIEXPORT void JNICALL Java_org_opencv_%(module)s_%(j_cls)s_delete def copy_java_files(java_files_dir, java_base_path, default_package_path='org/opencv/'): global total_files, updated_files java_files = [] - re_filter = re.compile(r'^.+\.(java|aidl)(.in)?$') + re_filter = re.compile(r'^.+\.(java|aidl|kt)(.in)?$') for root, dirnames, filenames in os.walk(java_files_dir): java_files += [os.path.join(root, filename) for filename in filenames if re_filter.match(filename)] java_files = [f.replace('\\', '/') for f in java_files] re_package = re.compile(r'^package +(.+);') - re_prefix = re.compile(r'^.+[\+/]([^\+]+).(java|aidl)(.in)?$') + re_prefix = re.compile(r'^.+[\+/]([^\+]+).(java|aidl|kt)(.in)?$') for java_file in java_files: src = checkFileRemap(java_file) with open(src, 'r') as f: diff --git a/modules/java/test/pure_test/src/org/opencv/test/OpenCVTestCase.java b/modules/java/test/pure_test/src/org/opencv/test/OpenCVTestCase.java index 3fd918dbfe..7ed8a41ba8 100644 --- a/modules/java/test/pure_test/src/org/opencv/test/OpenCVTestCase.java +++ b/modules/java/test/pure_test/src/org/opencv/test/OpenCVTestCase.java @@ -312,6 +312,13 @@ public class OpenCVTestCase extends TestCase { //assertTrue(Math.abs(ar1[i].doubleValue() - ar2[i].doubleValue()) <= epsilon); } + public static void assertArrayEquals(byte[] ar1, byte[] ar2) { + assertEquals(ar1.length, ar2.length); + + for (int i = 0; i < ar1.length; i++) + assertEquals(ar1[i], ar2[i]); + } + public static void assertArrayEquals(short[] ar1, short[] ar2) { assertEquals(ar1.length, ar2.length); diff --git a/modules/python/common.cmake b/modules/python/common.cmake index 1a6cc97429..0ea4ee7b27 100644 --- a/modules/python/common.cmake +++ b/modules/python/common.cmake @@ -232,8 +232,9 @@ if(NOT OPENCV_SKIP_PYTHON_LOADER) if(extra_py_files) list(SORT extra_py_files) foreach(f ${extra_py_files}) + get_filename_component(__dir "${f}" DIRECTORY) configure_file("${__base}/${f}" "${__loader_path}/cv2/_extra_py_code/${f}" COPYONLY) - install(FILES "${__base}/${f}" DESTINATION "${OPENCV_PYTHON_INSTALL_PATH}/cv2/_extra_py_code/${f}" COMPONENT python) + install(FILES "${__base}/${f}" DESTINATION "${OPENCV_PYTHON_INSTALL_PATH}/cv2/_extra_py_code/${__dir}/" COMPONENT python) endforeach() else() message(WARNING "Module ${m} has no .py files in misc/python/package") diff --git a/modules/python/package/cv2/__init__.py b/modules/python/package/cv2/__init__.py index 27db65eef6..27e7edd083 100644 --- a/modules/python/package/cv2/__init__.py +++ b/modules/python/package/cv2/__init__.py @@ -78,8 +78,20 @@ def bootstrap(): if DEBUG: print('OpenCV loader: PYTHON_EXTENSIONS_PATHS={}'.format(str(l_vars['PYTHON_EXTENSIONS_PATHS']))) if DEBUG: print('OpenCV loader: BINARIES_PATHS={}'.format(str(l_vars['BINARIES_PATHS']))) + applySysPathWorkaround = False + if hasattr(sys, 'OpenCV_REPLACE_SYS_PATH_0'): + applySysPathWorkaround = True + else: + try: + BASE_DIR = os.path.dirname(LOADER_DIR) + if sys.path[0] == BASE_DIR or os.path.realpath(sys.path[0]) == BASE_DIR: + applySysPathWorkaround = True + except: + if DEBUG: print('OpenCV loader: exception during checking workaround for sys.path[0]') + pass # applySysPathWorkaround is False + for p in reversed(l_vars['PYTHON_EXTENSIONS_PATHS']): - sys.path.insert(1, p) + sys.path.insert(1 if not applySysPathWorkaround else 0, p) if os.name == 'nt': if sys.version_info[:2] >= (3, 8): # https://github.com/python/cpython/pull/12302 diff --git a/modules/stereo/include/opencv2/stereo.hpp b/modules/stereo/include/opencv2/stereo.hpp index 665043ae43..f3a0de2d32 100644 --- a/modules/stereo/include/opencv2/stereo.hpp +++ b/modules/stereo/include/opencv2/stereo.hpp @@ -61,7 +61,7 @@ pixels from the original images from the cameras are retained in the rectified i image pixels are lost). Any intermediate value yields an intermediate result between those two extreme cases. @param newImageSize New image resolution after rectification. The same size should be passed to -initUndistortRectifyMap (see the stereo_calib.cpp sample in OpenCV samples directory). When (0,0) +#initUndistortRectifyMap (see the stereo_calib.cpp sample in OpenCV samples directory). When (0,0) is passed (default), it is set to the original imageSize . Setting it to a larger value can help you preserve details in the original image, especially when there is a big radial distortion. @param validPixROI1 Optional output rectangles inside the rectified images where all the pixels @@ -73,7 +73,7 @@ are valid. If alpha=0 , the ROIs cover the whole images. Otherwise, they are lik The function computes the rotation matrices for each camera that (virtually) make both camera image planes the same plane. Consequently, this makes all the epipolar lines parallel and thus simplifies -the dense stereo correspondence problem. The function takes the matrices computed by stereoCalibrate +the dense stereo correspondence problem. The function takes the matrices computed by #stereoCalibrate as input. As output, it provides two rotation matrices and also two projection matrices in the new coordinates. The function distinguishes the following two cases: @@ -117,7 +117,7 @@ coordinates. The function distinguishes the following two cases: @ref STEREO_ZERO_DISPARITY is set. As you can see, the first three columns of P1 and P2 will effectively be the new "rectified" camera -matrices. The matrices, together with R1 and R2 , can then be passed to initUndistortRectifyMap to +matrices. The matrices, together with R1 and R2 , can then be passed to #initUndistortRectifyMap to initialize the rectification map for each camera. See below the screenshot from the stereo_calib.cpp sample. Some red horizontal lines pass through @@ -140,9 +140,9 @@ CV_EXPORTS_W void stereoRectify( InputArray cameraMatrix1, InputArray distCoeffs @param points1 Array of feature points in the first image. @param points2 The corresponding points in the second image. The same formats as in -findFundamentalMat are supported. +#findFundamentalMat are supported. @param F Input fundamental matrix. It can be computed from the same set of point pairs using -findFundamentalMat . +#findFundamentalMat . @param imgSize Size of the image. @param H1 Output rectification homography matrix for the first image. @param H2 Output rectification homography matrix for the second image. @@ -153,7 +153,7 @@ rejected prior to computing the homographies. Otherwise, all the points are cons The function computes the rectification transformations without knowing intrinsic parameters of the cameras and their relative position in the space, which explains the suffix "uncalibrated". Another -related difference from stereoRectify is that the function outputs not the rectification +related difference from #stereoRectify is that the function outputs not the rectification transformations in the object (3D) space, but the planar perspective transformations encoded by the homography matrices H1 and H2 . The function implements the algorithm @cite Hartley99 . @@ -162,8 +162,8 @@ homography matrices H1 and H2 . The function implements the algorithm @cite Hart depends on the epipolar geometry. Therefore, if the camera lenses have a significant distortion, it would be better to correct it before computing the fundamental matrix and calling this function. For example, distortion coefficients can be estimated for each head of stereo camera - separately by using calibrateCamera . Then, the images can be corrected using undistort , or - just the point coordinates can be corrected with undistortPoints . + separately by using #calibrateCamera . Then, the images can be corrected using #undistort , or + just the point coordinates can be corrected with #undistortPoints . */ CV_EXPORTS_W bool stereoRectifyUncalibrated( InputArray points1, InputArray points2, InputArray F, Size imgSize, @@ -378,7 +378,7 @@ CV_EXPORTS_W void filterSpeckles( InputOutputArray img, double newVal, int maxSpeckleSize, double maxDiff, InputOutputArray buf = noArray() ); -//! computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by cv::stereoRectify()) +//! computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by #stereoRectify) CV_EXPORTS_W Rect getValidDisparityROI( Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int blockSize ); diff --git a/modules/ts/include/opencv2/ts.hpp b/modules/ts/include/opencv2/ts.hpp index ed7491a89a..394bc6e0fa 100644 --- a/modules/ts/include/opencv2/ts.hpp +++ b/modules/ts/include/opencv2/ts.hpp @@ -326,6 +326,7 @@ Mat calcSobelKernel2D( int dx, int dy, int apertureSize, int origin=0 ); Mat calcLaplaceKernel2D( int aperture_size ); void initUndistortMap( const Mat& a, const Mat& k, const Mat& R, const Mat& new_a, Size sz, Mat& mapx, Mat& mapy, int map_type ); +void initInverseRectificationMap( const Mat& a, const Mat& k, const Mat& R, const Mat& new_a, Size sz, Mat& mapx, Mat& mapy, int map_type ); void minMaxLoc(const Mat& src, double* minval, double* maxval, vector* minloc, vector* maxloc, const Mat& mask=Mat()); diff --git a/modules/video/src/tracking/tracker_dasiamrpn.cpp b/modules/video/src/tracking/tracker_dasiamrpn.cpp index 4d1004b419..72e0aa1f3a 100644 --- a/modules/video/src/tracking/tracker_dasiamrpn.cpp +++ b/modules/video/src/tracking/tracker_dasiamrpn.cpp @@ -251,14 +251,14 @@ void TrackerDaSiamRPNImpl::trackerEval(Mat img) pscore = penalty.mul(score); pscore = pscore * (1.0 - trackState.windowInfluence) + trackState.windows * trackState.windowInfluence; - int bestID[] = { 0 }; + int bestID[2] = { 0, 0 }; // Find the index of best score. minMaxIdx(pscore.reshape(0, { trackState.anchorNum * trackState.scoreSize * trackState.scoreSize, 1 }), 0, 0, 0, bestID); delta = delta.reshape(0, { 4, trackState.anchorNum * trackState.scoreSize * trackState.scoreSize }); penalty = penalty.reshape(0, { trackState.anchorNum * trackState.scoreSize * trackState.scoreSize, 1 }); score = score.reshape(0, { trackState.anchorNum * trackState.scoreSize * trackState.scoreSize, 1 }); - int index[] = { 0, bestID[0] }; + int index[2] = { 0, bestID[0] }; Rect2f resBox = { 0, 0, 0, 0 }; resBox.x = delta.at(index) / scaleZ; @@ -311,7 +311,7 @@ void TrackerDaSiamRPNImpl::softmax(const Mat& src, Mat& dst) void TrackerDaSiamRPNImpl::elementMax(Mat& src) { int* p = src.size.p; - int index[] = { 0, 0, 0, 0 }; + int index[4] = { 0, 0, 0, 0 }; for (int n = 0; n < *p; n++) { for (int k = 0; k < *(p + 1); k++) @@ -365,8 +365,8 @@ Mat TrackerDaSiamRPNImpl::generateAnchors() baseAnchors.push_back(anchor); } - int anchorIndex[] = { 0, 0, 0, 0 }; - const int sizes[] = { 4, (int)ratios.size(), scoreSize, scoreSize }; + int anchorIndex[4] = { 0, 0, 0, 0 }; + const int sizes[4] = { 4, (int)ratios.size(), scoreSize, scoreSize }; Mat anchors(4, sizes, CV_32F); for (auto i = 0; i < scoreSize; i++) diff --git a/modules/videoio/src/cap_dshow.cpp b/modules/videoio/src/cap_dshow.cpp index d3abc3694f..175f1d0329 100644 --- a/modules/videoio/src/cap_dshow.cpp +++ b/modules/videoio/src/cap_dshow.cpp @@ -2503,7 +2503,10 @@ static void findClosestSizeAndSubtype(videoDevice * VD, int widthIn, int heightI int tempH = 999999; //Don't want to get stuck in a loop - if(stepX < 1 || stepY < 1) continue; + if(stepX < 1 || stepY < 1){ + MyDeleteMediaType(pmtConfig); + continue; + } //DebugPrintOut("min is %i %i max is %i %i - res is %i %i\n", scc.MinOutputSize.cx, scc.MinOutputSize.cy, scc.MaxOutputSize.cx, scc.MaxOutputSize.cy, stepX, stepY); //DebugPrintOut("min frame duration is %i max duration is %i\n", scc.MinFrameInterval, scc.MaxFrameInterval); @@ -2619,7 +2622,8 @@ static bool setSizeAndSubtype(videoDevice * VD, int attemptWidth, int attemptHei return true; }else{ VD->streamConf->SetFormat(tmpType); - if( tmpType != NULL )MyDeleteMediaType(tmpType); + if( VD->pAmMediaType != NULL)MyDeleteMediaType(VD->pAmMediaType); + VD->pAmMediaType = tmpType; } return false; diff --git a/modules/videoio/test/test_video_io.cpp b/modules/videoio/test/test_video_io.cpp index 8bc98c73fb..9545ae4ec2 100644 --- a/modules/videoio/test/test_video_io.cpp +++ b/modules/videoio/test/test_video_io.cpp @@ -752,6 +752,9 @@ TEST_P(videocapture_acceleration, read) { if (filename == "sample_322x242_15frames.yuv420p.libvpx-vp9.mp4") throw SkipTestException("Unable to read the first frame with VP9 codec (media stack misconfiguration / bug)"); + // FFMPEG: [av1 @ 0000027ac07d1340] Your platform doesn't suppport hardware accelerated AV1 decoding. + if (filename == "sample_322x242_15frames.yuv420p.libaom-av1.mp4") + throw SkipTestException("Unable to read the first frame with AV1 codec (missing support)"); } EXPECT_TRUE(read_umat_result); ASSERT_FALSE(umat.empty()); @@ -764,6 +767,9 @@ TEST_P(videocapture_acceleration, read) { if (filename == "sample_322x242_15frames.yuv420p.libvpx-vp9.mp4") throw SkipTestException("Unable to read the first frame with VP9 codec (media stack misconfiguration / bug)"); + // FFMPEG: [av1 @ 0000027ac07d1340] Your platform doesn't suppport hardware accelerated AV1 decoding. + if (filename == "sample_322x242_15frames.yuv420p.libaom-av1.mp4") + throw SkipTestException("Unable to read the first frame with AV1 codec (missing support)"); } EXPECT_TRUE(read_result); } diff --git a/platforms/android/build_sdk.py b/platforms/android/build_sdk.py index 7d898e4c36..88cb5ff87f 100755 --- a/platforms/android/build_sdk.py +++ b/platforms/android/build_sdk.py @@ -159,6 +159,7 @@ class Builder: self.debug_info = True if config.debug_info else False self.no_samples_build = True if config.no_samples_build else False self.opencl = True if config.opencl else False + self.no_kotlin = True if config.no_kotlin else False def get_cmake(self): if not self.config.use_android_buildtools and check_executable(['cmake', '--version']): @@ -219,6 +220,7 @@ class Builder: CMAKE_TOOLCHAIN_FILE=self.get_toolchain_file(), INSTALL_CREATE_DISTRIB="ON", WITH_OPENCL="OFF", + BUILD_KOTLIN_EXTENSIONS="ON", WITH_IPP=("ON" if abi.haveIPP() else "OFF"), WITH_TBB="ON", BUILD_EXAMPLES="OFF", @@ -240,6 +242,9 @@ class Builder: if self.opencl: cmake_vars['WITH_OPENCL'] = "ON" + if self.no_kotlin: + cmake_vars['BUILD_KOTLIN_EXTENSIONS'] = "OFF" + if self.config.modules_list is not None: cmd.append("-DBUILD_LIST='%s'" % self.config.modules_list) @@ -359,6 +364,7 @@ if __name__ == "__main__": parser.add_argument('--debug_info', action="store_true", help="Build with debug information (useful for Release mode: BUILD_WITH_DEBUG_INFO=ON)") parser.add_argument('--no_samples_build', action="store_true", help="Do not build samples (speeds up build)") parser.add_argument('--opencl', action="store_true", help="Enable OpenCL support") + parser.add_argument('--no_kotlin', action="store_true", help="Disable Kotlin extensions") args = parser.parse_args() log.basicConfig(format='%(message)s', level=log.DEBUG) diff --git a/platforms/android/ndk-22.config.py b/platforms/android/ndk-22.config.py index 69321e0f0c..95ab8b172d 100644 --- a/platforms/android/ndk-22.config.py +++ b/platforms/android/ndk-22.config.py @@ -1,6 +1,6 @@ ABIs = [ - ABI("2", "armeabi-v7a", None, cmake_vars=dict(ANDROID_ABI='armeabi-v7a with NEON', ANDROID_GRADLE_PLUGIN_VERSION='4.1.2', GRADLE_VERSION='6.5')), - ABI("3", "arm64-v8a", None, cmake_vars=dict(ANDROID_GRADLE_PLUGIN_VERSION='4.1.2', GRADLE_VERSION='6.5')), - ABI("5", "x86_64", None, cmake_vars=dict(ANDROID_GRADLE_PLUGIN_VERSION='4.1.2', GRADLE_VERSION='6.5')), - ABI("4", "x86", None, cmake_vars=dict(ANDROID_GRADLE_PLUGIN_VERSION='4.1.2', GRADLE_VERSION='6.5')), + ABI("2", "armeabi-v7a", None, cmake_vars=dict(ANDROID_ABI='armeabi-v7a with NEON', ANDROID_GRADLE_PLUGIN_VERSION='4.1.2', GRADLE_VERSION='6.5', KOTLIN_PLUGIN_VERSION='1.5.10')), + ABI("3", "arm64-v8a", None, cmake_vars=dict(ANDROID_GRADLE_PLUGIN_VERSION='4.1.2', GRADLE_VERSION='6.5', KOTLIN_PLUGIN_VERSION='1.5.10')), + ABI("5", "x86_64", None, cmake_vars=dict(ANDROID_GRADLE_PLUGIN_VERSION='4.1.2', GRADLE_VERSION='6.5', KOTLIN_PLUGIN_VERSION='1.5.10')), + ABI("4", "x86", None, cmake_vars=dict(ANDROID_GRADLE_PLUGIN_VERSION='4.1.2', GRADLE_VERSION='6.5', KOTLIN_PLUGIN_VERSION='1.5.10')), ] diff --git a/samples/android/build.gradle.in b/samples/android/build.gradle.in index e89eb911be..934a1a69d0 100644 --- a/samples/android/build.gradle.in +++ b/samples/android/build.gradle.in @@ -8,6 +8,7 @@ buildscript { } dependencies { classpath 'com.android.tools.build:gradle:@ANDROID_GRADLE_PLUGIN_VERSION@' + classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:@KOTLIN_PLUGIN_VERSION@' // NOTE: Do not place your application dependencies here; they belong // in the individual module build.gradle files diff --git a/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/App.xaml.cs b/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/App.xaml.cs index fd2a7c8466..73190e28f3 100644 --- a/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/App.xaml.cs +++ b/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/App.xaml.cs @@ -207,7 +207,7 @@ namespace PhoneXamlDirect3DApp1 catch { // If an exception is caught here it is most likely due to either - // ResourceLangauge not being correctly set to a supported language + // ResourceLanguage not being correctly set to a supported language // code or ResourceFlowDirection is set to a value other than LeftToRight // or RightToLeft. @@ -220,4 +220,4 @@ namespace PhoneXamlDirect3DApp1 } } } -} \ No newline at end of file +} diff --git a/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/App.xaml.cs b/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/App.xaml.cs index fd2a7c8466..73190e28f3 100644 --- a/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/App.xaml.cs +++ b/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/App.xaml.cs @@ -207,7 +207,7 @@ namespace PhoneXamlDirect3DApp1 catch { // If an exception is caught here it is most likely due to either - // ResourceLangauge not being correctly set to a supported language + // ResourceLanguage not being correctly set to a supported language // code or ResourceFlowDirection is set to a value other than LeftToRight // or RightToLeft. @@ -220,4 +220,4 @@ namespace PhoneXamlDirect3DApp1 } } } -} \ No newline at end of file +} diff --git a/samples/wp8/OpenCVXaml/OpenCVXaml/App.xaml.cs b/samples/wp8/OpenCVXaml/OpenCVXaml/App.xaml.cs index 6fe3a54410..17f8fed93e 100644 --- a/samples/wp8/OpenCVXaml/OpenCVXaml/App.xaml.cs +++ b/samples/wp8/OpenCVXaml/OpenCVXaml/App.xaml.cs @@ -207,7 +207,7 @@ namespace OpenCVXaml catch { // If an exception is caught here it is most likely due to either - // ResourceLangauge not being correctly set to a supported language + // ResourceLanguage not being correctly set to a supported language // code or ResourceFlowDirection is set to a value other than LeftToRight // or RightToLeft. @@ -220,4 +220,4 @@ namespace OpenCVXaml } } } -} \ No newline at end of file +}