Added IPP Async converters, doc and sample

modules/core/doc/core.rst

@@ -16,3 +16,4 @@ core. The Core Functionality
     clustering
     utility_and_system_functions_and_macros
     opengl_interop
+    ipp_async_converters

modules/core/doc/ipp_async_converters.rst

@@ -0,0 +1,62 @@
+Intel® IPP Asynchronous C/C++ Converters
+========================================
+
+.. highlight:: cpp
+
+General Information
+-------------------
+
+This section describes conversion between OpenCV and `Intel® IPP Asynchronous C/C++ <http://software.intel.com/en-us/intel-ipp-preview>`_ library. 
+`Getting Started Guide <http://registrationcenter.intel.com/irc_nas/3727/ipp_async_get_started.htm>`_ help you to install the library, configure header and library build paths.
+
+hpp::getHpp
+-----------
+Create ``hppiMatrix`` from ``Mat``.
+
+.. ocv:function:: Ptr<hppiMatrix> hpp::getHpp(const Mat& src)
+
+    :param src: input matrix.
+
+This function allocates and initializes the ``hppiMatrix`` that has the same size and type as input matrix, returns the ``Ptr<hppiMatrix>``.
+Supports ``CV_8U``, ``CV_16U``, ``CV_16S``, ``CV_32S``, ``CV_32F``, ``CV_64F``.
+
+.. note:: The ``hppiMatrix`` pointer to the image buffer in system memory refers to the ``src.data``. Control the lifetime of the matrix and don't change its data, if there is no special need. 
+.. seealso:: :ref:`howToUseIPPAconversion`, :ocv:func:`hpp::getMat`
+
+
+hpp::getMat
+-----------
+Create ``Mat`` from ``hppiMatrix``.
+
+.. ocv:function:: Mat hpp::getMat(hppiMatrix* src, hppAccel accel, int cn)
+
+    :param src: input hppiMatrix.
+
+    :param accel: accelerator instance.
+
+    :param cn: number of channels.
+
+This function allocates and initializes the ``Mat`` that has the same size and type as input matrix. 
+Supports ``CV_8U``, ``CV_16U``, ``CV_16S``, ``CV_32S``, ``CV_32F``, ``CV_64F``.
+
+.. seealso:: :ref:`howToUseIPPAconversion`, :ocv:func:`hpp::copyHppToMat`, :ocv:func:`hpp::getHpp`.
+
+
+hpp::copyHppToMat
+-----------------
+Convert ``hppiMatrix`` to ``Mat``.
+
+.. ocv:function:: void hpp::copyHppToMat(hppiMatrix* src, Mat& dst, hppAccel accel, int cn)
+
+    :param src: input hppiMatrix.
+    
+    :param dst: output matrix.
+
+    :param accel: accelerator instance.
+
+    :param cn: number of channels.
+
+This function allocates and initializes new matrix (if needed) that has the same size and type as input matrix. 
+Supports ``CV_8U``, ``CV_16U``, ``CV_16S``, ``CV_32S``, ``CV_32F``, ``CV_64F``.
+
+.. seealso:: :ref:`howToUseIPPAconversion`, :ocv:func:`hpp::getMat`, :ocv:func:`hpp::getHpp`.

modules/core/include/opencv2/core/ippasync.hpp

@@ -0,0 +1,92 @@
+#ifndef __OPENCV_CORE_IPPASYNC_HPP__
+#define __OPENCV_CORE_IPPASYNC_HPP__
+
+#include "opencv2/core.hpp"
+#include <ipp_async_op.h>
+#include <ipp_async_accel.h>
+
+namespace cv
+{
+    void DefaultDeleter<hppiMatrix>::operator () (hppiMatrix* p) const
+    {
+        hppiFreeMatrix(p);
+    }
+
+namespace hpp
+{
+    //convert OpenCV data type to hppDataType
+    inline int toHppType(const int cvType)
+    {
+        int depth = CV_MAT_DEPTH(cvType);
+        int hppType = depth == CV_8U ? HPP_DATA_TYPE_8U :
+                     depth == CV_16U ? HPP_DATA_TYPE_16U :
+                     depth == CV_16S ? HPP_DATA_TYPE_16S :
+                     depth == CV_32S ? HPP_DATA_TYPE_32S :
+                     depth == CV_32F ? HPP_DATA_TYPE_32F :
+                     depth == CV_64F ? HPP_DATA_TYPE_64F : -1;
+        CV_Assert( hppType >= 0 );
+        return hppType; 
+    }
+
+    //convert hppDataType to OpenCV data type
+    inline int toCvType(const int hppType)
+    {
+        int cvType = hppType == HPP_DATA_TYPE_8U ? CV_8U :
+                    hppType == HPP_DATA_TYPE_16U ? CV_16U :
+                    hppType == HPP_DATA_TYPE_16S ? CV_16S :
+                    hppType == HPP_DATA_TYPE_32S ? CV_32S :
+                    hppType == HPP_DATA_TYPE_32F ? CV_32F :
+                    hppType == HPP_DATA_TYPE_64F ? CV_64F : -1;
+        CV_Assert( cvType >= 0 );
+        return cvType;
+    }
+
+    inline void copyHppToMat(hppiMatrix* src, Mat& dst, hppAccel accel, int cn)
+    {
+        hppDataType type;
+        hpp32u width, height;
+        hppStatus sts;
+
+        CV_Assert(src!=NULL);
+
+        sts = hppiInquireMatrix(src, &type, &width, &height);
+
+        CV_Assert( sts == HPP_STATUS_NO_ERROR);
+
+        int matType = CV_MAKETYPE(toCvType(type), cn);
+
+        CV_Assert(width%cn == 0);
+
+        width /= cn;
+
+        dst.create((int)height, (int)width, (int)matType);
+
+        size_t newSize = (size_t)(height*(hpp32u)(dst.step));
+
+        sts = hppiGetMatrixData(accel,src,(hpp32u)(dst.step),dst.data,&newSize);
+
+        CV_Assert( sts == HPP_STATUS_NO_ERROR);
+    }
+
+    //create cv::Mat from hppiMatrix
+    inline Mat getMat(hppiMatrix* src, hppAccel accel, int cn)
+    {
+        Mat dst;
+        copyHppToMat(src, dst, accel, cn);
+        return dst;
+    }
+
+     //create hppiMatrix from cv::Mat
+    inline Ptr<hppiMatrix> getHpp(const Mat& src)
+    {
+        int htype = toHppType(src.type());
+        int cn = src.channels();
+
+        CV_Assert(src.data);
+        hppiMatrix *dst = hppiCreateMatrix(htype, src.cols*cn, src.rows, src.data, (hpp32s)(src.step));
+
+        return Ptr<hppiMatrix>(dst);
+    }
+}}
+
+#endif

modules/core/test/test_ippasync.cpp

@@ -0,0 +1,116 @@
+#include "test_precomp.hpp"
+#include "opencv2/ts/ocl_test.hpp"
+
+#include "opencv2/core/ippasync.hpp"
+
+using namespace cv;
+using namespace std;
+using namespace cvtest;
+
+namespace cvtest {
+namespace ocl {
+
+PARAM_TEST_CASE(IPPAsync, MatDepth, Channels, hppAccelType)
+{
+    int type;
+    int cn;
+    int depth;
+    hppAccelType accelType;
+
+    Mat matrix, result;
+    Ptr<hppiMatrix> hppMat;
+    hppAccel accel;
+    hppiVirtualMatrix * virtMatrix;
+    hppStatus sts;
+
+    virtual void SetUp()
+    {
+        type = CV_MAKE_TYPE(GET_PARAM(0), GET_PARAM(1));
+        depth = GET_PARAM(0);
+        cn = GET_PARAM(1);
+        accelType = GET_PARAM(2);
+    }
+
+    virtual void generateTestData()
+    {
+        Size matrix_Size = randomSize(2, 100);
+        const double upValue = 100;
+
+        matrix = randomMat(matrix_Size, type, -upValue, upValue);
+    }
+
+    void Near(double threshold = 0.0)
+    {
+        EXPECT_MAT_NEAR(matrix, result, threshold);
+    }
+};
+
+TEST_P(IPPAsync, accuracy)
+{
+    if (depth==CV_32S || depth==CV_64F)
+        return;
+    
+    sts = hppCreateInstance(accelType, 0, &accel);
+    CV_Assert(sts==HPP_STATUS_NO_ERROR);
+    virtMatrix = hppiCreateVirtualMatrices(accel, 2);
+
+    for (int j = 0; j < test_loop_times; j++)
+    {
+        generateTestData();
+        hppMat = hpp::getHpp(matrix);
+
+        hppScalar a = 3;
+
+        sts = hppiAddC(accel, hppMat, a, 0, virtMatrix[0]);
+        CV_Assert(sts==HPP_STATUS_NO_ERROR);
+        sts = hppiSubC(accel, virtMatrix[0], a, 0, virtMatrix[1]);
+        CV_Assert(sts==HPP_STATUS_NO_ERROR);
+
+        sts = hppWait(accel, HPP_TIME_OUT_INFINITE);
+        CV_Assert(sts==HPP_STATUS_NO_ERROR);
+        
+        result = hpp::getMat(virtMatrix[1], accel, cn);
+
+        Near(5.0e-6);
+    }
+
+    sts = hppiDeleteVirtualMatrices(accel, virtMatrix);
+    CV_Assert(sts==HPP_STATUS_NO_ERROR);
+    sts = hppDeleteInstance(accel);
+    CV_Assert(sts==HPP_STATUS_NO_ERROR);
+}
+
+TEST_P(IPPAsync, conversion)
+{
+    sts = hppCreateInstance(accelType, 0, &accel);
+    CV_Assert(sts==HPP_STATUS_NO_ERROR);
+    virtMatrix = hppiCreateVirtualMatrices(accel, 1);
+
+    for (int j = 0; j < test_loop_times; j++)
+    {
+        generateTestData();
+        hppMat = hpp::getHpp(matrix);
+
+        sts = hppiCopy (accel, hppMat, virtMatrix[0]);
+        CV_Assert(sts==HPP_STATUS_NO_ERROR);
+
+        sts = hppWait(accel, HPP_TIME_OUT_INFINITE);
+        CV_Assert(sts==HPP_STATUS_NO_ERROR);
+        
+        result = hpp::getMat(virtMatrix[0], accel, cn);
+
+        Near();
+    }
+
+    sts = hppiDeleteVirtualMatrices(accel, virtMatrix);
+    CV_Assert(sts==HPP_STATUS_NO_ERROR);
+    sts = hppDeleteInstance(accel);
+    CV_Assert(sts==HPP_STATUS_NO_ERROR);
+}
+
+INSTANTIATE_TEST_CASE_P(IppATest, IPPAsync, Combine(Values(CV_8U, CV_16U, CV_16S, CV_32S, CV_32F, CV_64F),
+                                                   Values(1, 2, 3, 4),
+                                                   Values( HPP_ACCEL_TYPE_CPU, HPP_ACCEL_TYPE_GPU)));
+
+}
+}