ipps.hpp

经典的嵌入式教程C和C++的内容中的源代码

     return ippsImag_32fc( pSrc, pDstIm, len );
     }
 inline IppStatus ippsImag( const Ipp16sc* pSrc, Ipp16s* pDstIm, int len) {
     return ippsImag_16sc( pSrc, pDstIm, len );
     }

/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsCplxToReal
//  Purpose:    form the real and imaginary parts of the input complex vector
//  Parameters:
//    pSrc       pointer to the input complex vector
//    pDstRe     pointer to output vector to store the real part
//    pDstIm     pointer to output vector to store the imaginary part
//    len        length of the vectors, number of items
//  Return:
//    ippStsNullPtrErr        pointer(s) to the data is NULL
//    ippStsSizeErr           length of the vectors is less or equal zero
//    ippStsNoErr             otherwise
*/

 inline IppStatus ippsCplxToReal( const Ipp64fc* pSrc, Ipp64f* pDstRe, Ipp64f* pDstIm,
                             int len) {
     return ippsCplxToReal_64fc( pSrc, pDstRe, pDstIm, len );
     }
 inline IppStatus ippsCplxToReal( const Ipp32fc* pSrc, Ipp32f* pDstRe, Ipp32f* pDstIm,
                             int len) {
     return ippsCplxToReal_32fc( pSrc, pDstRe, pDstIm, len );
     }
 inline IppStatus ippsCplxToReal( const Ipp16sc* pSrc, Ipp16s* pDstRe, Ipp16s* pDstIm,
                             int len) {
     return ippsCplxToReal_16sc( pSrc, pDstRe, pDstIm, len );
     }

/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsRealToCplx
//  Purpose:    form complex vector from the real and imaginary components
//  Parameters:
//    pSrcRe     pointer to the input vector with real part, may be NULL
//    pSrcIm     pointer to the input vector with imaginary part, may be NULL
//    pDst       pointer to the output complex vector
//    len        length of the vectors
//  Return:
//    ippStsNullPtrErr        pointer to the destination data is NULL
//    ippStsSizeErr           length of the vectors is less or equal zero
//    ippStsNoErr             otherwise
//
//  Notes:      one of the two input pointers may be NULL. In this case
//              the corresponding values of the output complex elements is 0
*/

 inline IppStatus ippsRealToCplx( const Ipp64f* pSrcRe, const Ipp64f* pSrcIm, Ipp64fc*
                             pDst, int len) {
     return ippsRealToCplx_64f( pSrcRe, pSrcIm, pDst, len );
     }
 inline IppStatus ippsRealToCplx( const Ipp32f* pSrcRe, const Ipp32f* pSrcIm, Ipp32fc*
                             pDst, int len) {
     return ippsRealToCplx_32f( pSrcRe, pSrcIm, pDst, len );
     }
 inline IppStatus ippsRealToCplx( const Ipp16s* pSrcRe, const Ipp16s* pSrcIm, Ipp16sc*
                             pDst, int len) {
     return ippsRealToCplx_16s( pSrcRe, pSrcIm, pDst, len );
     }




/* /////////////////////////////////////////////////////////////////////////////
//  Names:       ippsConj, ippsConjFlip
//  Purpose:     complex conjugate data vector
//  Parameters:
//    pSrc               pointer to the input vetor
//    pDst               pointer to the output vector
//    len                length of the vectors
//  Return:
//    ippStsNullPtrErr      pointer(s) to the data is NULL
//    ippStsSizeErr         length of the vectors is less or equal zero
//    ippStsNoErr           otherwise
//  Notes:
//    the ConjFlip version conjugates and stores result in reverse order
*/

 inline IppStatus ippsConj( Ipp64fc* pSrcDst, int len) {
     return ippsConj_64fc_I( pSrcDst, len );
     }
 inline IppStatus ippsConj( Ipp32fc* pSrcDst, int len) {
     return ippsConj_32fc_I( pSrcDst, len );
     }
 inline IppStatus ippsConj( Ipp16sc* pSrcDst, int len) {
     return ippsConj_16sc_I( pSrcDst, len );
     }
 inline IppStatus ippsConj( const Ipp64fc* pSrc, Ipp64fc* pDst, int len) {
     return ippsConj_64fc( pSrc, pDst, len );
     }
 inline IppStatus ippsConj( const Ipp32fc* pSrc, Ipp32fc* pDst, int len) {
     return ippsConj_32fc( pSrc, pDst, len );
     }
 inline IppStatus ippsConj( const Ipp16sc* pSrc, Ipp16sc* pDst, int len) {
     return ippsConj_16sc( pSrc, pDst, len );
     }
 inline IppStatus ippsConjFlip( const Ipp64fc* pSrc, Ipp64fc* pDst, int len) {
     return ippsConjFlip_64fc( pSrc, pDst, len );
     }
 inline IppStatus ippsConjFlip( const Ipp32fc* pSrc, Ipp32fc* pDst, int len) {
     return ippsConjFlip_32fc( pSrc, pDst, len );
     }
 inline IppStatus ippsConjFlip( const Ipp16sc* pSrc, Ipp16sc* pDst, int len) {
     return ippsConjFlip_16sc( pSrc, pDst, len );
     }
 inline IppStatus ippsConjCcs( Ipp64fc* pSrcDst, int lenDst) {
     return ippsConjCcs_64fc_I( pSrcDst, lenDst );
     }
 inline IppStatus ippsConjCcs( Ipp32fc* pSrcDst, int lenDst) {
     return ippsConjCcs_32fc_I( pSrcDst, lenDst );
     }
 inline IppStatus ippsConjCcs( Ipp16sc* pSrcDst, int lenDst) {
     return ippsConjCcs_16sc_I( pSrcDst, lenDst );
     }
 inline IppStatus ippsConjCcs( const Ipp64f* pSrc, Ipp64fc* pDst, int lenDst) {
     return ippsConjCcs_64fc( pSrc, pDst, lenDst );
     }
 inline IppStatus ippsConjCcs( const Ipp32f* pSrc, Ipp32fc* pDst, int lenDst) {
     return ippsConjCcs_32fc( pSrc, pDst, lenDst );
     }
 inline IppStatus ippsConjCcs( const Ipp16s* pSrc, Ipp16sc* pDst, int lenDst) {
     return ippsConjCcs_16sc( pSrc, pDst, lenDst );
     }
 inline IppStatus ippsConjPack( Ipp64fc* pSrcDst, int lenDst) {
     return ippsConjPack_64fc_I( pSrcDst, lenDst );
     }
 inline IppStatus ippsConjPack( Ipp32fc* pSrcDst, int lenDst) {
     return ippsConjPack_32fc_I( pSrcDst, lenDst );
     }
 inline IppStatus ippsConjPack( Ipp16sc* pSrcDst, int lenDst) {
     return ippsConjPack_16sc_I( pSrcDst, lenDst );
     }
 inline IppStatus ippsConjPack( const Ipp64f* pSrc, Ipp64fc* pDst, int lenDst) {
     return ippsConjPack_64fc( pSrc, pDst, lenDst );
     }
 inline IppStatus ippsConjPack( const Ipp32f* pSrc, Ipp32fc* pDst, int lenDst) {
     return ippsConjPack_32fc( pSrc, pDst, lenDst );
     }
 inline IppStatus ippsConjPack( const Ipp16s* pSrc, Ipp16sc* pDst, int lenDst) {
     return ippsConjPack_16sc( pSrc, pDst, lenDst );
     }
 inline IppStatus ippsConjPerm( Ipp64fc* pSrcDst, int lenDst) {
     return ippsConjPerm_64fc_I( pSrcDst, lenDst );
     }
 inline IppStatus ippsConjPerm( Ipp32fc* pSrcDst, int lenDst) {
     return ippsConjPerm_32fc_I( pSrcDst, lenDst );
     }
 inline IppStatus ippsConjPerm( Ipp16sc* pSrcDst, int lenDst) {
     return ippsConjPerm_16sc_I( pSrcDst, lenDst );
     }
 inline IppStatus ippsConjPerm( const Ipp64f* pSrc, Ipp64fc* pDst, int lenDst) {
     return ippsConjPerm_64fc( pSrc, pDst, lenDst );
     }
 inline IppStatus ippsConjPerm( const Ipp32f* pSrc, Ipp32fc* pDst, int lenDst) {
     return ippsConjPerm_32fc( pSrc, pDst, lenDst );
     }
 inline IppStatus ippsConjPerm( const Ipp16s* pSrc, Ipp16sc* pDst, int lenDst) {
     return ippsConjPerm_16sc( pSrc, pDst, lenDst );
     }

/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsConvert
//  Purpose:    Converts integer data to floating point data
//  Parameters:
//    pSrc        pointer to integer data to be converted
//    pDst        pointer to the destination vector
//    len         length of the vectors
//  Return:
//    ippStsNullPtrErr    pointer(s) to the data is NULL
//    ippStsSizeErr       length of the vectors is less or equal zero
//    ippStsNoErr         otherwise
*/
 inline IppStatus ippsConvert( const Ipp8s* pSrc, Ipp16s* pDst, int len) {
     return ippsConvert_8s16s( pSrc, pDst, len );
     }
 inline IppStatus ippsConvert( const Ipp16s* pSrc, Ipp32s* pDst, int len) {
     return ippsConvert_16s32s( pSrc, pDst, len );
     }
 inline IppStatus ippsConvert( const Ipp32s* pSrc, Ipp16s* pDst, int len) {
     return ippsConvert_32s16s( pSrc, pDst, len );
     }
 inline IppStatus ippsConvert( const Ipp8s* pSrc, Ipp32f* pDst, int len) {
     return ippsConvert_8s32f( pSrc, pDst, len );
     }
 inline IppStatus ippsConvert( const Ipp8u* pSrc, Ipp32f* pDst, int len) {
     return ippsConvert_8u32f( pSrc, pDst, len );
     }
 inline IppStatus ippsConvert( const Ipp16s* pSrc, Ipp32f* pDst, int len) {
     return ippsConvert_16s32f( pSrc, pDst, len );
     }
 inline IppStatus ippsConvert( const Ipp16u* pSrc, Ipp32f* pDst, int len) {
     return ippsConvert_16u32f( pSrc, pDst, len );
     }
 inline IppStatus ippsConvert( const Ipp32s* pSrc, Ipp64f* pDst, int len) {
     return ippsConvert_32s64f( pSrc, pDst, len );
     }
 inline IppStatus ippsConvert( const Ipp32s* pSrc, Ipp32f* pDst, int len) {
     return ippsConvert_32s32f( pSrc, pDst, len );
     }

/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsConvert
//  Purpose:    convert floating point data to integer data
//  Parameters:
//    pSrc         pointer to the input floating point data to be converted
//    pDst         pointer to destination vector
//    len          length of the vectors
//    rndMode      Rounding mode which can be ippRndZero or ippRndNear
//    scaleFactor  scale factor value
//  Return:
//    ippStsNullPtrErr    pointer(s) to the data NULL
//    ippStsSizeErr       length of the vectors is less or equal zero
//    ippStsNoErr         otherwise
//  Note:
//    an out-of-range result will be saturated
*/

 inline IppStatus ippsConvert( const Ipp32f* pSrc, Ipp8s* pDst, int len, IppRoundMode
                             rndMode, int scaleFactor) {
     return ippsConvert_32f8s_Sfs( pSrc, pDst, len, rndMode, scaleFactor );
     }
 inline IppStatus ippsConvert( const Ipp32f* pSrc, Ipp8u* pDst, int len, IppRoundMode
                             rndMode, int scaleFactor) {
     return ippsConvert_32f8u_Sfs( pSrc, pDst, len, rndMode, scaleFactor );
     }
 inline IppStatus ippsConvert( const Ipp32f* pSrc, Ipp16s* pDst, int len, IppRoundMode
                             rndMode, int scaleFactor) {
     return ippsConvert_32f16s_Sfs( pSrc, pDst, len, rndMode, scaleFactor );
     }
 inline IppStatus ippsConvert( const Ipp32f* pSrc, Ipp16u* pDst, int len, IppRoundMode
                             rndMode, int scaleFactor) {
     return ippsConvert_32f16u_Sfs( pSrc, pDst, len, rndMode, scaleFactor );
     }
 inline IppStatus ippsConvert( const Ipp64f* pSrc, Ipp32s* pDst, int len, IppRoundMode
                             rndMode, int scaleFactor) {
     return ippsConvert_64f32s_Sfs( pSrc, pDst, len, rndMode, scaleFactor );
     }
 inline IppStatus ippsConvert( const Ipp32f* pSrc, Ipp32s* pDst, int len, IppRoundMode
                             rndMode, int scaleFactor) {
     return ippsConvert_32f32s_Sfs( pSrc, pDst, len, rndMode, scaleFactor );
     }


/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsConvert_32f64f
//  Purpose:    Converts floating point data Ipp32f
//              to floating point data Ipp64f
//  Parameters:
//    pSrc          pointer to the input vector
//    pDst          pointer to the output vector
//    len           length of the vectors
//  Return:
//    ippStsNullPtrErr    pointer(s) to the data is NULL
//    ippStsSizeErr       length of the vectors is less or equal zero
//    ippStsNoErr         otherwise
*/

 inline IppStatus ippsConvert( const Ipp32f* pSrc, Ipp64f* pDst, int len) {
     return ippsConvert_32f64f( pSrc, pDst, len );
     }


/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsConvert_64f32f
//  Purpose:    Converts floating point data Ipp64f
//              to floating point data Ipp32f
//  Parameters:
//    pSrc          pointer to the input vector
//    pDst          pointer to the output vector
//    len           length of the vectors
//  Return:
//    ippStsNullPtrErr    pointer(s) to the data is NULL
//    ippStsSizeErr       length of the vectors is less or equal zero
//    ippStsNoErr         otherwise
//  Note:
//    an out-of-range result will be saturated
*/

 inline IppStatus ippsConvert( const Ipp64f* pSrc, Ipp32f* pDst, int len) {
     return ippsConvert_64f32f( pSrc, pDst, len );
     }

/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsConvert
//  Purpose:    Converts integer data to floating point data
//  Parameters:
//    pSrc          pointer to integer data to be converted
//    pDst          pointer to the destination vector
//    len           length of the vectors
//    scaleFactor   scale factor value
//  Return:
//    ippStsNullPtrErr    pointer(s) to the data is NULL
//    ippStsSizeErr       length of the vectors is less or equal zero
//    ippStsNoErr         otherwise
*/

 inline IppStatus ippsConvert( const Ipp16s* pSrc, Ipp32f* pDst, int len, int