MulPack

Intel® Integrated Performance Primitives (Intel® IPP) Developer Guide and Reference

Download PDF

ID 790148

Date 3/22/2024

Version

Public

Visible to Intel only — GUID: GUID-E039B854-4AF7-48EB-906C-C00BA65626C1

View Details

MulPack

Multiplies two source images in packed format.

Syntax

IppStatus ippiMulPack_<mod>(const Ipp32f* pSrc1, int src1Step, const Ipp32f* pSrc2, int src2Step, Ipp32f* pDst, int dstStep, IppiSize roiSize);

Supported values for mod:

32f_C1R

32f_C3R

32f_C4R

32f_AC4R

IppStatus ippiMulPack_<mod>(const Ipp32f* pSrc, int srcStep, Ipp32f* pSrcDst, int srcDstStep, IppiSize roiSize);

Supported values for mod:

32f_C1IR

32f_C3IR

32f_C4IR

32f_AC4IR

Include Files

ippi.h

Domain Dependencies

Headers: ippcore.h, ippvm.h, ipps.h

Libraries: ippcore.lib, ippvm.lib, ipps.lib

Parameters

pSrc1, pSrc2	Pointer to the ROI in the source images.
src1Step, src2Step	Distance in bytes between starts of consecutive lines in the source images.
pDst	Pointer to the destination image ROI.
dstStep	Distance in bytes between starts of consecutive lines in the destination image.
pSrc	Pointer to the first source image ROI for the in-place operation.
srcStep	Distance in bytes between starts of consecutive lines in the first source image for the in-place operation.
pSrcDst	Pointer to the second source and destination image ROI for the in-place operation.
srcDstStep	Distance in bytes between starts of consecutive lines in the source and destination image for the in-place operation.
roiSize	Size of the source and destination ROI in pixels.
scaleFactor	Scale factor (see Integer Result Scaling).

Description

This function operates with ROI (see Regions of Interest in Intel IPP).

This function multiplies corresponding pixel values of two source images, A and B represented in RCPack2D format and stores the result into the destination image C in packed format also. The multiplying is performed according to the following formulas:

ReC = ReA*ReB - ImA*ImB;

ImC = ImA*ReB + ImB*ReA.

Not-in-place flavors multiply pixel values of ROI in the source images pSrc1 and pSrc2, and store result in the pDst.

In-place flavors multiply pixel values of ROI in the source images pSrc and pSrcDst, and store result in the pSrcDst.

This function can be used in image filtering operations that include FFT transforms.

Example

/*******************************************************************************
* Copyright 2015 Intel Corporation.
*
*
* This software and the related documents are Intel copyrighted materials, and your use of them is governed by
* the express license under which they were provided to you ('License'). Unless the License provides otherwise,
* you may not use, modify, copy, publish, distribute, disclose or transmit this software or the related
* documents without Intel's prior written permission.
* This software and the related documents are provided as is, with no express or implied warranties, other than
* those that are expressly stated in the License.
*******************************************************************************/

//    The code example below illustrates how the horizontal edges of an image can be detected.
// implemented with Intel(R) Integrated Performance Primitives (Intel(R) IPP) functions:
//     ippiSet_32f_C1R
//     ippiAddC_32f_C1IR
//     ippiCopy_32f_C1R
//     ippiFFTGetSize_R_32f
//     ippiFFTInit_R_32f
//     ippiFFTFwd_RToPack_32f_C1R
//     ippiMulPack_32f_C1R
//     ippiFFTInv_PackToR_32f_C1R


#include <stdio.h>
#include "ipp.h"

/* Next two defines are created to simplify code reading and understanding */
#define EXIT_MAIN exitLine:                                  /* Label for Exit */
#define check_sts(st) if((st) != ippStsNoErr) goto exitLine; /* Go to Exit if Intel(R) IPP function returned status different from ippStsNoErr */

/* Results of ippMalloc() are not validated because Intel(R) IPP functions perform bad arguments check and will return an appropriate status  */

int main(void)
{
    IppStatus status = ippStsNoErr;
    IppiFFTSpec_R_32f *pSpec = NULL;             /* Pointer to FFT spec structure */

    Ipp32f pSrc[64],   pFlt[64],   pDst[64];     /* Pointers to source/filter/destination images */
    Ipp32f pSrcFr[64], pFltFr[64], pDstFr[64];   /* Pointers to source/filter/destination images into the frequency domain */

    Ipp8u *pMemInit = NULL, *pBuffer = NULL;     /* Pointer to the work buffers */
    int sizeSpec = 0, sizeInit = 0, sizeBuf = 0; /* size of FFT spec structure, Init and work buffers */

    const IppiSize roiSize8x8 = { 8, 8 }, roiSize3x3 = { 3, 3 }; /* image and filter roi sizes */
    const Ipp32f filter[3*3] = {-1,-1,-1, 0,0,0, 1,1,1};         /* filter data */

    /* set the image zero */
    check_sts( status = ippiSet_32f_C1R( 0, pSrc, 8*sizeof(Ipp32f), roiSize8x8 ) )

    /* create unit area in the image */
    check_sts( status = ippiAddC_32f_C1IR( 1, pSrc+8+1, 8*sizeof(Ipp32f), roiSize3x3 ) )

    /* set the filter zero */
    check_sts( status = ippiSet_32f_C1R( 0, pFlt, 8*sizeof(Ipp32f), roiSize8x8 ) )

    /* copy the filter coefficients */
    check_sts( status = ippiCopy_32f_C1R( filter, 3*sizeof(Ipp32f), pFlt, 8*sizeof(Ipp32f), roiSize3x3 ) )

    check_sts( status = ippiFFTGetSize_R_32f(3, 3, IPP_FFT_DIV_INV_BY_N, ippAlgHintAccurate,
                           &sizeSpec, &sizeInit, &sizeBuf) )

    /* memory allocation */
    pSpec    = (IppiFFTSpec_R_32f*) ippMalloc( sizeSpec );
    pBuffer  = (Ipp8u*) ippMalloc( sizeBuf );
    pMemInit = (Ipp8u*) ippMalloc( sizeInit );

    check_sts( status = ippiFFTInit_R_32f(3, 3, IPP_FFT_DIV_INV_BY_N, ippAlgHintAccurate, pSpec, pMemInit) )

    /* forward FFT transform : the source image is transformed into the frequency domain*/
    check_sts( status = ippiFFTFwd_RToPack_32f_C1R( pSrc, 8*sizeof(Ipp32f), pSrcFr, 8*sizeof(Ipp32f), pSpec, pBuffer ) )

    /* forward FFT transform: the filter is transformed into the frequency domain */
    check_sts( status = ippiFFTFwd_RToPack_32f_C1R( pFlt, 8*sizeof(Ipp32f), pFltFr, 8*sizeof(Ipp32f), pSpec, pBuffer ) )

    /* multiplying the packed data */
    check_sts( status = ippiMulPack_32f_C1R( pSrcFr, 8*sizeof(Ipp32f), pFltFr, 8*sizeof(Ipp32f), pDstFr, 8*4, roiSize8x8) )

    /* inverse FFT transform : the filtered data is transformed to the time domain */
    check_sts( status = ippiFFTInv_PackToR_32f_C1R( pDstFr, 8*sizeof(Ipp32f), pDst, 8*sizeof(Ipp32f), pSpec, pBuffer ) )

EXIT_MAIN
    ippFree( pMemInit );
    ippFree( pSpec );
    ippFree( pBuffer );
    printf("Exit status %d (%s)\n", (int)status, ippGetStatusString(status));
    return (int)status;
}

Return Values

ippStsNoErr	Indicates no error. Any other value indicates an error or a warning.
ippStsNullPtrErr	Indicates an error condition if any of the specified pointers is `NULL`.
ippStsSizeErr	Indicates an error condition if roiSize has a field with zero or negative value.
ippStsStepErr	Indicates an error condition if any of the specified buffer step values is zero or negative.

Parent topic: Fourier Transforms

Select Your Language

Using Intel.com Search

Quick Links

Recent Searches

Advanced Search

Only search in

Intel® Integrated Performance Primitives (Intel® IPP) Developer Guide and Reference

MulPack

Syntax

Include Files

Domain Dependencies

Parameters

Description

Example

Return Values