pp.h

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

/* ////////////////////////////////////////////////////////////////////////
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 2002-2005 Intel Corporation. All Rights Reserved.
//
//
//
*/

/*
//  Performance primitives C++ wrapper.
//
//
//
*/

#ifndef __PP_H__
#define __PP_H__

#include "ipps.h"
#include "ippi.h"
#include "ippj.h"


#include "rowiterator.h"


#if _MSC_VER
#pragma warning( disable : 4514 ) // unreferenced inline/local function has been removed
#pragma warning( disable : 4710 ) // 'function' : function not inlined
#endif

///////////////////////////////////////////////////////////////////////////
//
//  IPP signal-processing primitives (ipps) wrappers
//
//


#ifndef XSCALE

inline void Add(const Ipp32f *src1, const Ipp32f *src2, Ipp32f *dst, unsigned int size)
{
    ippsAdd_32f(src1, src2, dst, size);
}

inline void Add(const Ipp32f *src, Ipp32f *srcDst, unsigned int size)
{
    ippsAdd_32f_I(src, srcDst, size);
}

inline void Add(Ipp32f value, Ipp32f* srcDst, unsigned int size)
{
    ippsAddC_32f_I(value, srcDst, size);
}

inline void Add(Ipp32f value, const Ipp32f* src, Ipp32f *dst, unsigned int size)
{
    ippsAddC_32f(src, value, dst, size);
}

#endif //#ifndef XSCALE


inline void Add(const Ipp32s *src1, const Ipp32s *src2, Ipp32s *dst, unsigned int size)
{
    ippsAdd_32s_Sfs(src1, src2, dst, size, 0);
}

inline void Add(const Ipp32s *src, Ipp32s *srcDst, unsigned int size)
{
    ippsAdd_32s_ISfs(src, srcDst, size, 0);
}

inline void Add(Ipp32s value, Ipp32s* srcDst, unsigned int size)
{
    ippsAddC_32s_ISfs(value, srcDst, size, 0);
}

inline void Add(Ipp32s value, const Ipp32s* src, Ipp32s *dst, unsigned int size)
{
    ippsAddC_32s_Sfs(src, value, dst, size, 0);
}


inline void Add(const Ipp16s *src1, const Ipp16s *src2, Ipp16s *dst, unsigned int size)
{
    ippsAdd_16s_Sfs(src1, src2, dst, size, 0);
}

inline void Add(const Ipp16s *src, Ipp16s *srcDst, unsigned int size)
{
    ippsAdd_16s_ISfs(src, srcDst, size, 0);
}

inline void Add(Ipp16s value, Ipp16s* srcDst, unsigned int size)
{
    ippsAddC_16s_ISfs(value, srcDst, size, 0);
}

inline void Add(Ipp32s value, const Ipp16s* src, Ipp16s *dst, unsigned int size)
{
    ippsAddC_16s_Sfs(src, value, dst, size, 0);
}


inline void Add(Ipp16s value, Ipp16s* srcDst, unsigned int size, int scaleFactor)
{
    ippsAddC_16s_ISfs(value, srcDst, size, scaleFactor);
}

inline void Add(Ipp32s value, Ipp32s* srcDst, unsigned int size, int scaleFactor)
{
    ippsAddC_32s_ISfs(value, srcDst, size, scaleFactor);
}


#ifndef XSCALE

inline void Mul(const Ipp32f *src1, const Ipp32f *src2, Ipp32f *dst, unsigned int size)
{
    ippsMul_32f(src1, src2, dst, size);
}

inline void Mul(const Ipp32f *src, Ipp32f *srcDst, unsigned int size)
{
    ippsMul_32f_I(src, srcDst, size);
}

inline void Mul(Ipp32f value, Ipp32f* srcDst, unsigned int size)
{
    ippsMulC_32f_I(value, srcDst, size);
}

inline void Mul(Ipp32f value, const Ipp32f* src, Ipp32f *dst, unsigned int size)
{
    ippsMulC_32f(src, value, dst, size);
}

#endif //#ifndef XSCALE


inline void Mul(Ipp32s value, Ipp32s* srcDst, unsigned int size, int scaleFactor)
{
    ippsMulC_32s_ISfs(value, srcDst, size, scaleFactor);
}


#ifndef XSCALE

inline void Sub(const Ipp32f *src1, const Ipp32f *src2, Ipp32f *dst, unsigned int size)
{
    ippsSub_32f(src1, src2, dst, size);
}

inline void Sub(const Ipp32f *src, Ipp32f *srcDst, unsigned int size)
{
    ippsSub_32f_I(src, srcDst, size);
}

inline void Sub(Ipp32f value, Ipp32f* srcDst, unsigned int size)
{
    ippsSubC_32f_I(value, srcDst, size);
}

#endif //#ifndef XSCALE


inline void Sub(const Ipp32s *src1, const Ipp32s *src2, Ipp32s *dst, unsigned int size)
{
    ippsSub_32s_Sfs(src1, src2, dst, size, 0);
}

inline void Sub(const Ipp32s *src, Ipp32s *srcDst, unsigned int size)
{
    ippsSub_32s_ISfs(src, srcDst, size, 0);
}

inline void Sub(Ipp32s value, Ipp32s* srcDst, unsigned int size)
{
    ippsSubC_32s_ISfs(value, srcDst, size, 0);
}


inline void Sub(const Ipp16s *src1, const Ipp16s *src2, Ipp16s *dst, unsigned int size)
{
    ippsSub_16s_Sfs(src1, src2, dst, size, 0);
}

inline void Sub(const Ipp16s *src, Ipp16s *srcDst, unsigned int size)
{
    ippsSub_16s_ISfs(src, srcDst, size, 0);
}

inline void Sub(Ipp16s value, Ipp16s* srcDst, unsigned int size)
{
    ippsSubC_16s_ISfs(value, srcDst, size, 0);
}


inline void Sub(Ipp32s value, Ipp32s* srcDst, unsigned int size, int scaleFactor)
{
    ippsSubC_32s_ISfs(value, srcDst, size, scaleFactor);
}


inline void Sub(Ipp32s value, Ipp16s* srcDst, unsigned int size, int scaleFactor)
{
    ippsSubC_16s_ISfs(value, srcDst, size, scaleFactor);
}


inline void LShift(unsigned int value, const Ipp32s *src, Ipp32s *dst, unsigned int size)
{
    ippsLShiftC_32s(src, value, dst, size);
}

inline void LShift(unsigned int value, const Ipp16s *src, Ipp16s *dst, unsigned int size)
{
    ippsLShiftC_16s(src, value, dst, size);
}

inline void LShift(unsigned int value, Ipp16s *srcDst, unsigned int size)
{
    ippsLShiftC_16s_I(value, srcDst, size);
}

inline void RShift(unsigned int value, const Ipp32s *src, Ipp32s *dst, unsigned int size)
{
    ippsRShiftC_32s(src, value, dst, size);
}

inline void RShift(unsigned int value, const Ipp16s *src, Ipp16s *dst, unsigned int size)
{
    ippsRShiftC_16s(src, value, dst, size);
}

inline void RShift(unsigned int value, Ipp32s *srcDst, unsigned int size)
{
    ippsRShiftC_32s_I(value, srcDst, size);
}

inline void RShift(unsigned int value, Ipp16s *srcDst, unsigned int size)
{
    ippsRShiftC_16s_I(value, srcDst, size);
}


inline void Convert(const Ipp16s *src, Ipp32s *dst, unsigned int size)
{
    ippsConvert_16s32s(src, dst, size);
}

inline void Convert(const Ipp32s *src, Ipp16s *dst, unsigned int size)
{
    ippsConvert_32s16s(src, dst, size);
}


#ifndef XSCALE

inline void Convert(const Ipp32s *src, Ipp32f *dst, unsigned int size)
{
    ippsConvert_32s32f_Sfs(src, dst, size, 0);
}

inline void Convert(const Ipp32f *src, Ipp32s *dst, unsigned int size)
{
    ippsConvert_32f32s_Sfs(src, dst, size, ippRndNear, 0);
}

inline void Convert32s32f(Ipp32f *srcDst, unsigned int size)
{
    ippsConvert_32s32f_Sfs((Ipp32s*)srcDst, srcDst, size, 0);
}

inline void Convert32f32s(Ipp32f *srcDst, unsigned int size)
{
    ippsConvert_32f32s_Sfs(srcDst, (Ipp32s*)srcDst, size, ippRndNear, 0);
}

#endif //#ifndef XSCALE


inline void Convert(const ImageCoreC<Ipp16s, 1> &src, const ImageCoreC<Ipp32s, 1> &dst,
    const IppiSize &size)
{
    RowIterator<Ipp16s> rowSrc = src;
    RowIterator<Ipp32s> rowDst = dst;

    for(int i = 0; i < size.height; i++, ++rowSrc, ++rowDst)
        Convert((Ipp16s*)rowSrc, (Ipp32s*)rowDst, size.width);
}

inline void Convert(const ImageCoreC<Ipp32s, 1> &src, const ImageCoreC<Ipp16s, 1> &dst,
    const IppiSize &size)
{
    RowIterator<Ipp32s> rowSrc = src;
    RowIterator<Ipp16s> rowDst = dst;

    for(int i = 0; i < size.height; i++, ++rowSrc, ++rowDst)
        Convert((Ipp32s*)rowSrc, (Ipp16s*)rowDst, size.width);
}


#ifndef XSCALE

inline void Convert(const ImageCoreC<Ipp32s, 1> &src, const ImageCoreC<Ipp32f, 1> &dst,
    const IppiSize &size)
{
    RowIterator<Ipp32s> rowSrc = src;
    RowIterator<Ipp32f> rowDst = dst;

    for(int i = 0; i < size.height; i++, ++rowSrc, ++rowDst)
        Convert((Ipp32s*)rowSrc, (Ipp32f*)rowDst, size.width);
}

inline void Convert(const ImageCoreC<Ipp32f, 1> &src, const ImageCoreC<Ipp32s, 1> &dst,
    const IppiSize &size)
{
    RowIterator<Ipp32f> rowSrc = src;
    RowIterator<Ipp32s> rowDst = dst;

    for(int i = 0; i < size.height; i++, ++rowSrc, ++rowDst)
        Convert((Ipp32f*)rowSrc, (Ipp32s*)rowDst, size.width);
}

inline void Convert32s32f(const ImageCoreC<Ipp32f, 1> &srcDst, const IppiSize &size)
{
    RowIterator<Ipp32f> row = srcDst;

    for(int i = 0; i < size.height; i++, ++row)
        Convert32s32f(row, size.width);
}

inline void Convert32f32s(const ImageCoreC<Ipp32f, 1> &srcDst, const IppiSize &size)
{
    RowIterator<Ipp32f> row = srcDst;

    for(int i = 0; i < size.height; i++, ++row)
        Convert32f32s(row, size.width);
}

#endif //#ifndef XSCALE


///////////////////////////////////////////////////////////////////////////
//
//  IPP image-processing primitives (mostly ippi & a few ipps-derived auxiliary) wrappers
//


inline void Copy(const ImageCoreC<Ipp16s, 1> &src, const ImageCoreC<Ipp16s, 1> &dst,
    const IppiSize &size)
{
    ippiCopy_16s_C1R(src.Data(), src.LineStep(),
                     dst.Data(), dst.LineStep(), size);
}

inline void Copy(const ImageCoreC<Ipp32s, 1> &src, const ImageCoreC<Ipp32s, 1> &dst,
    const IppiSize &size)
{
    IppiSize size_x_2 = {size.width * 2, size.height};
    ippiCopy_16s_C1R((Ipp16s*)src.Data(), src.LineStep(),
                     (Ipp16s*)dst.Data(), dst.LineStep(), size_x_2);
}


#ifndef XSCALE

inline void Copy(const ImageCoreC<Ipp32f, 1> &src, const ImageCoreC<Ipp32f, 1> &dst,
    const IppiSize &size)
{
    ippiCopy_32f_C1R(src.Data(), src.LineStep(),
                     dst.Data(), dst.LineStep(), size);
}

#endif //#ifndef XSCALE


#ifndef XSCALE

inline void Mul(const ImageCoreC<Ipp32f, 1> &srcDst, const IppiSize &size, Ipp32f value)
{
    ippiMulC_32f_C1IR(value, srcDst.Data(), srcDst.LineStep(),  size);
}

#endif //#ifndef XSCALE


inline void Mul(const ImageCoreC<Ipp16s, 1> &srcDst, const IppiSize &size, Ipp16s value, int scaleFactor)
{
    ippiMulC_16s_C1IRSfs(value, srcDst.Data(), srcDst.LineStep(), size, scaleFactor);
}

inline void Mul(const ImageCoreC<Ipp32s, 1> &srcDst, const IppiSize &size, Ipp32s value, int scaleFactor)
{
    RowIterator<Ipp32s> row = srcDst;

    for(int i = 0; i < size.height; i++, ++row)
        Mul(value, row, size.width, scaleFactor);
}


/*
inline void LShift(const ImageCoreC<Ipp32s, 1> &srcDst,
    const IppiSize &size, unsigned int shift)
{
    ippiLShiftC_32s_C1IR(shift, srcDst.Data(), srcDst.LineStep(), size);
}
*/

inline void LShift(const ImageCoreC<Ipp32s, 1> &src, const ImageCoreC<Ipp32s, 1> &dst,
    const IppiSize &size, unsigned int shift)
{
    ippiLShiftC_32s_C1R(src.Data(), src.LineStep(), shift, dst.Data(), dst.LineStep(), size);
}

inline void LShift(const ImageCoreC<Ipp16s, 1> &srcDst,
    const IppiSize &size, unsigned int shift)
{
    RowIterator<Ipp16s> row = srcDst;

    for(int i = 0; i < size.height; i++, ++row)
        LShift(shift, row, size.width);
}

inline void RShift(const ImageCoreC<Ipp32s, 1> &srcDst,
    const IppiSize &size, unsigned int shift)
{
    ippiRShiftC_32s_C1IR(shift, srcDst.Data(), srcDst.LineStep(), size);
}

inline void RShift(const ImageCoreC<Ipp16s, 1> &srcDst,
    const IppiSize &size, unsigned int shift)
{
    ippiRShiftC_16s_C1IR(shift, srcDst.Data(), srcDst.LineStep(), size);
}

inline void Shift(const ImageCoreC<Ipp32s, 1> &srcDst,
    const IppiSize &size, int shift)
{
    if(shift > 0)
        ippiLShiftC_32s_C1IR(shift, srcDst.Data(), srcDst.LineStep(), size);
    else if(shift < 0)
        ippiRShiftC_32s_C1IR(-shift, srcDst.Data(), srcDst.LineStep(), size);
    else
        return;
}


template<class T>
void Zero(const ImageCoreC<T, 1> &srcDst, const IppiSize &size)
{
    IppiSize roiSize = {size.width * sizeof(T), size.height};

    ippiSet_8u_C1R(0, (Ipp8u*)srcDst.Data(), srcDst.LineStep(), roiSize);
}

inline void Complement(const ImageCoreC<Ipp32s, 1> &srcDst, const IppiSize &size)
{
    ippiComplement_32s_C1IR(srcDst.Data(), srcDst.LineStep(), size);
}


inline void RCTFwd(const ImageCorePn<Ipp32s> &srcDst, const IppiSize &size)
{
    ippiRCTFwd_JPEG2K_32s_P3IR((Ipp32s**)srcDst.Data(), srcDst.LineStep(), size);
}

inline void RCTFwd(Ipp32s *srcDst0, Ipp32s *srcDst1, Ipp32s *srcDst2, unsigned int size)
{
    IppiSize roiSize = {size, 1};
    Ipp32s *srcDstArr[3] = {srcDst0, srcDst1, srcDst2};
    ippiRCTFwd_JPEG2K_32s_P3IR(srcDstArr, size * sizeof(Ipp32s), roiSize);
}

inline void RCTFwd(const ImageCorePn<Ipp16s> &srcDst, const IppiSize &size)
{
    ippiRCTFwd_JPEG2K_16s_P3IR((Ipp16s**)srcDst.Data(), srcDst.LineStep(), size);
}

inline void RCTFwd(Ipp16s *srcDst0, Ipp16s *srcDst1, Ipp16s *srcDst2, unsigned int size)
{
    IppiSize roiSize = {size, 1};
    Ipp16s *srcDstArr[3] = {srcDst0, srcDst1, srcDst2};
    ippiRCTFwd_JPEG2K_16s_P3IR(srcDstArr, size * sizeof(Ipp32s), roiSize);
}

inline void RCTInv(const ImageCorePn<Ipp32s> &srcDst, const IppiSize &size)
{
    ippiRCTInv_JPEG2K_32s_P3IR((Ipp32s**)srcDst.Data(), srcDst.LineStep(), size);
}

inline void RCTInv(Ipp32s *srcDst0, Ipp32s *srcDst1, Ipp32s *srcDst2, unsigned int size)
{
    IppiSize roiSize = {size, 1};
    Ipp32s *srcDstArr[3] = {srcDst0, srcDst1, srcDst2};
    ippiRCTInv_JPEG2K_32s_P3IR(srcDstArr, size * sizeof(Ipp32s), roiSize);
}

inline void RCTInv(Ipp16s *srcDst0, Ipp16s *srcDst1, Ipp16s *srcDst2, unsigned int size)
{
    IppiSize roiSize = {size, 1};
    Ipp16s *srcDstArr[3] = {srcDst0, srcDst1, srcDst2};
    ippiRCTInv_JPEG2K_16s_P3IR(srcDstArr, size * sizeof(Ipp16s), roiSize);
}


#ifndef XSCALE

inline void ICTFwd(const ImageCorePn<Ipp32f> &srcDst, const IppiSize &size)
{
    ippiICTFwd_JPEG2K_32f_P3IR((Ipp32f**)srcDst.Data(), srcDst.LineStep(), size);
}

inline void ICTFwd(Ipp32f *srcDst0, Ipp32f *srcDst1, Ipp32f *srcDst2, unsigned int size)
{
    IppiSize roiSize = {size, 1};
    Ipp32f *srcDstArr[3] = {srcDst0, srcDst1, srcDst2};
    ippiICTFwd_JPEG2K_32f_P3IR(srcDstArr, size * sizeof(Ipp32f), roiSize);
}

#endif //#ifndef XSCALE