Intel® Integrated Performance Primitives Developer Reference

Developer Reference

  • 2020
  • 10/21/2020
  • Public Content
Contents

ResamplePolyphase
,
ResamplePolyphaseFixed

Resample input data using polyphase filters.

Syntax

IppStatus ippsResamplePolyphase_16s(const Ipp16s*
pSrc
, int
len
, Ipp16s*
pDst
, Ipp64f
factor
, Ipp32f
norm
, Ipp64f*
pTime
, int*
pOutlen
, const IppsResamplingPolyphase_16s*
pSpec
);
IppStatus ippsResamplePolyphase_32f(const Ipp32f*
pSrc
, int
len
, Ipp32f*
pDst
, Ipp64f
factor
, Ipp32f
norm
, Ipp64f*
pTime
, int*
pOutlen
, const IppsResamplingPolyphase_32f*
pSpec
);
IppStatus ippsResamplePolyphaseFixed_16s(const Ipp16s*
pSrc
, int
len
, Ipp16s*
pDst
, Ipp32f
norm
, Ipp64f*
pTime
, int*
pOutlen
, const IppsResamplingPolyphaseFixed_16s*
pSpec
);
IppStatus ippsResamplePolyphaseFixed_32f(const Ipp32f*
pSrc
, int
len
, Ipp32f*
pDst
, Ipp32f
norm
, Ipp64f*
pTime
, int*
pOutlen
, const IppsResamplingPolyphaseFixed_32f*
pSpec
);
Include Files
ipps.h
Domain Dependencies
Headers:
ippcore.h
,
ippvm.h
Libraries:
ippcore.lib
,
ippvm.lib
Parameters
pSrc
The pointer to the input vector.
pDst
The pointer to the output vector.
len
The number of input vector elements to resample.
norm
The norm factor for output samples.
factor
The resampling factor.
pTime
The pointer to the start time of resampling (in input vector elements). Keeps the input sample number and the phase for the first output sample from the next input data portion.
pOutlen
The number of calculated output vector elements.
pSpec
The pointer to the resampling state structure.
Description
These functions convert data from the input vector changing their frequency and compute all output samples that can be correctly calculated for the given input and the filter length. For the
ippsResamplePolyphase
 function, the ratio of output and input frequencies is defined by the
factor
 argument. For the
ippsResamplePolyphaseFixed
 function, this ratio is defined during creation of the resampling structure. The value for
pTime
[0] defines the time value for which the first output sample is calculated.
Input vector with indices less than
pTime
[0]
 contains the history data of filters. The history length is equal to
flen
/2 for
ippsResamplePolyphaseFixed
 function , and [1/2
window
*max(1, 1/
factor
)]+1 for
ippsResamplePolyphase
 function. Here
flen
 is the filter length and
window
 is the size of the ideal lowpass filter window. The input vector must contain the same number of elements with indices greater than
pTime
[0] +
len
 for the right filter wing for the last element.
After function execution, the time value is updated and
pOutlen
[0] contains the number of calculated output samples.
The output samples are multiplied by
norm
 * min (1,
factor
) before saturation.
Return Values
ippStsNoErr
Indicates no error.
ippStsNullPtrErr
Indicates an error when
pSpec
,
pSrc
,
pDst
,
pTime
 or
pOutlen
 pointer is
NULL
.
ippStsSizeErr
Indicates an error when
len
 is less than or equal to 0.
ippStsBadArgErr
Indicates an error when
factor
 is less than or equal to 0.

Example

The code example below demonstrates resampling of the input mono pcm file.
void resampleIPP(
    int      inRate,    // input frequency
    int      outRate,   // output frequency
    FILE    *infd,      // input pcm file
    FILE    *outfd)     // output pcm file
 {  short *inBuf,*outBuf;
    int bufsize=4096;
    int history=128;
    double time=history;
    int lastread=history;
    int inCount=0,outCount=0,inLen,outLen;
    int size,len,height;
    IppsResamplingPolyphaseFixed_16s *state;
    ippsResamplePolyphaseFixedGetSize_16s(inRate,outRate,2*(history-1),&size,&len, 	&height,ippAlgHintAccurate);
    state=(IppsResamlingPolyphaseFixed_16s*)ippsMalloc_8u(size);
    ippsResamplePolyphaseFixedInit_16s(inRate,outRate,2*(history-1),0.95f,9.0f,state,    	ippAlgHintAccurate);
    inBuf=ippsMalloc_16s(bufsize+history+2);
    outBuf=ippsMalloc_16s((int)((bufsize-history)*outRate/(float)inRate+2));
    ippsZero_16s(inBuf,history);
    while ((inLen=fread(inBuf+lastread,sizeof(short),bufsize-lastread,infd))>0) { 
       inCount+=inLen;
       lastread+=inLen;
       ippsResamplePolyphaseFixed_16s(inBuf,lastread-history-(int)time,
                             outBuf,0.98f,&time,&outLen,state);
       fwrite(outBuf,outLen,sizeof(short),outfd);
       outCount+=outLen;
       ippsMove_16s(inBuf+(int)time-history,inBuf,lastread+history-(int)time);
       lastread-=(int)time-history;	
       time-=(int)time-history;
    }    
				ippsZero_16s(inBuf+lastread,history);
    ippsResamplePolyphaseFixed_16s(inBuf,lastread-(int)time,
                          outBuf,0.98f,&time,&outLen,state);
    fwrite(outBuf,outLen,sizeof(short),outfd);
    outCount+=outLen;
    printf("%d inputs resampled to %d outputs\n",inCount,outCount);
    ippsFree(outBuf);
    ippsFree(inBuf);
    ippsFree (state);
 }

Product and Performance Information

1

Intel's compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.

Notice revision #20110804