Developer Reference

  • 2021
  • 06/28/2021
  • Public Content
Contents

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:
Re
C
= Re
A
*Re
B
- Im
A
*Im
B
;
Im
C
= Im
A
*Re
B
+ Im
B
*Re
A
.
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-2020 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 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.

Product and Performance Information

1

Performance varies by use, configuration and other factors. Learn more at www.Intel.com/PerformanceIndex.