Hello,

I'm using Visual Studio 2013 and the Intel IPP 8.2.

I have some Auxiliary Functions I build upon Intel IPP for image manipulation in C++ style by overloading some operators and defining function which are composition of many Intel IPP functions.

Now, I want to build a library of that functions I created and I want this library to be "Self Defined".
Namely, on my future projects I want to link to that library (And only that) and be able to use my functions (Which relies on Intel IPP).
Basically, it is something like the question here:

http://stackoverflow.com/questions/4736877/how-to-link-boost-in-a-depend...

Which refers me here:

http://stackoverflow.com/questions/5445023/c-can-you-build-one-static-li...

Just to explain things, in Project 1 I build a library of function I created which relies on Intel IPP.
I use the static libraries and try to create a static lib out of it.
On Project 2 I use the functions I created.
I only link the LIB file I created from Project 1.
Yet when I try to compile Project 2 I get the following error:

LINK : fatal error LNK1104: cannot open file 'C:\Program Files (x86)\Intel\Composer XE 2015\ipp\include\ippi.h/../../lib/intel64/ippimt.lib'

I prefer the library to be static, but if there's no choice, a dynamic library would be OK as well.

Hi all,

I found the next pseudocode for ippiRGBToHSV_8u_C3R in IPP documentation

The conversion algorithm from RGB to HSV can be represented in pseudocode as follows:
// Value: V = max(R,G,B); // Saturation: temp = min(R,G,B); if V = 0 then // achromatics case S = 0//
H = 0 else // chromatics case S = (V - temp)/V // Hue: Cr = (V - R) / (V - temp) Cg = (V -
G) / (V - temp) Cb = (V - B) / (V - temp) if R = V then H = Cb - Cg if G = V then H = 2 + Cr - Cb if B = V
then H = 4 + Cg - Cr H = 60*H if H < 0 then H = H + 360
The computed H,S,V values are scaled to the full range of the destination data type

I realized this pseudocode in small console application

int GetHSV(int nR,int nG, int nB,int* pnH, int* pnS, int* pnV)
{
    int nH,nS,nV;
    int nCr,nCg,nCb;
    int nResult=0;
    int nTemp=0;
    nV=nR;
    if(nG>nV) nV=nG;
    if(nB>nV) nV=nB;
    nTemp=nR;
    if(nG<nTemp) nTemp=nG;
    if(nB<nTemp) nTemp=nB;
    if(nV==0)
    {
        nH=0;
        nS=0;
    }
    else
    {
        nS = (nV - nTemp);
        nCr=(nV-nR)/(nV-nTemp);
        nCg=(nV-nG)/(nV-nTemp);
        nCb=(nV-nB)/(nV-nTemp);
        if(nR==nV) nH=nCb-nCg;
        if(nG==nV) nH=2+nCr-nCb;
        if(nB==nV) nH=4+nCg-nCr;
        nH=nH*60;
        if(nH<0) nH=nH+360;
    }
    *pnH=(int)(nH*0.71);
    *pnS=nS;
    *pnV=nV;
    return nResult;
}

I also made a small console application, that uses  ippiRGBToHSV_8u_C3R  for color conversion.

The results are very strange. When we have simple colors like red, green, cyan, magenta, everything is fine, the results of two console applications are the same.

But when I try something else (for example RGB(198,97,27)), results are different.

Is my relization of pseudocode correct? If it's correct where can I get the real pseudocode of  ippiRGBToHSV_8u_C3R?

Best regards,
Roman
 

Hi,

I am calling ippTranspose with the following parameters (and valid buffer pointers of course):

void *pSrc = <input buffer>;
void *pDst = <output buffer>;
int iWidth  = 640;
int iHeight = 480;
int iSrcStep = iWidth * 3;
int iDstStep = iHeight * 3;
int iSrcOffset = iSrcStep * (iHeight - 1);
int iSrcStepT  = -iSrcStep;
IppiSize sizeSrc = { iWidth, iHeight };
ippiTranspose_8u_C3R((Ipp8u*)pSrc + iSrcOffset, iSrcStepT, (Ipp8u*)pDst, iDstStep, sizeSrc);

It crashes here:

  050BD325  add         esi,ecx
  050BD327  add         edi,3
  050BD32A  sub         ebx,1
  050BD32D  je          _p8_owniTranspose_8u_C3R+51h (50BD2E1h)
  050BD32F  jmp         _p8_owniTranspose_8u_C3R+7Ah (50BD30Ah)
  050BD331  sub         ebx,9
  050BD334  jl          _p8_owniTranspose_8u_C3R+116h (50BD3A6h)> 050BD336  movd        xmm0,dword ptr [esi]
  050BD33A  movd        xmm1,dword ptr [ecx+esi]
  050BD33F  movd        xmm2,dword ptr [esi+ecx*2]
  050BD344  movd        xmm3,dword ptr [ebp+esi]
  050BD34A  movd        xmm4,dword ptr [esi+ecx*4]
  050BD34F  lea         esi,[esi+ecx*4]
  050BD352  punpckldq   xmm0,xmm1
  050BD356  punpckldq   xmm2,xmm3

It looks like it processes the first source line (which is actually the last) and then ESI points to the next line after the last line instead of respecting the given source step to the next line before the last line.

Am I doing something wrong or is this a bug?
IPP version is 8.1 U1 (included with C++ Composer XE 2013 SP1 U4).

I am trying to use the function ippiFilterBoxBorder and i keep getting a compiler error of
Error    4    error : identifier "y8_ippiFilterBoxBorder_16u_C1R" is undefined   
Error    3    error : identifier "y8_ippiFilterBoxBorderGetBufferSize" is undefined

If i change the FilterBoxBorder function to FilterBox (which is deprecated) everything compiles and runs with no issue.
I am using the latest c++ Intel compiler 15.0.2.179 on windows

Any idea what am i doing wrong?
 

I'm having a hard time understanding the docs for implementing an FFT , and some other minor issues.

1) when I look at the intel folder in my build environment, I see several dynamic libraries. Which one is necessary to implement the FFT

2) Also not clear if I should be using mkl instead of ipp for FFT

3) In trying to follow the example for using the FFT here : https://software.intel.com/en-us/articles/how-to-use-intel-ipp-s-1d-four...

I don't understand the deal with all of the initializing steps. Usually , when I use an intel routine, I am responsible for initializing  all local variables and I just pass them into a library function call.

Could someone point me to an easy example?

I have a vector of modulated signals (real) and  a vector of time points. I need to demodulate the data. I expect to have a vector of complex values and a vector of real values when I am finished.

Any help is greatly appreciated.

I'm working with a DynaColor H264 camera (using IPP to write a decoder). I'm playing games with the max_frame_buffering value to minimize latency. This requires that I unpack and repack the SPS. But (unless I'm making a dumb mistake) there seem to be 2 extra values at the end of this camera's SPS. I get 25 bytes (the '54' is the last one).

unsigned char src[256] = {

0x4d, 0x60, 0x1f, 0x8d, 0x68, 0x0c, 0x81, 0x37, 0xe5, 0xc0,

0x5b, 0x20, 0x00, 0x00, 0x03, 0x00, 0x20, 0x00, 0x00, 0x03,

0x00, 0xa1, 0xe2, 0x84, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00

};

If you actually do the decoding of this data it looks to me like it should end with 0x84 0x40, not 84 54

The 84 40 is basically a max_frames values of 7 - part of the VUI parameters - the last value in the SPS (i think) which is spreaed over the 2 bytes and it should (i think) be followed by a '1' bit to end the SPS stream (the 40).

The '54' seems to imply that the '7' is followed by a '0' and a '1' encoded value and then the 1 bit to end the stream. If I change the 54 to a 40 which should leave a legally formatted SPS the video wont play (even though I traced my decoder code and it never looks at the 'extra' values). Its very strange. Any thoughts?

Hello,

I need to resample my signal from 44100 hZ to 8000 hZ with similar method that Matlab does. As Matlab's help description says that resample method uses polyphase implementation:

 resample  Change the sampling rate of a signal.
    Y = resample(X,P,Q) resamples the sequence in vector X at P/Q times
    the original sample rate using a polyphase implementation.  Y is P/Q
    times the length of X (or the ceiling of this if P/Q is not an integer).  
    P and Q must be positive integers.

I wanted to try IPP's resampling. But I don't quite get it. I found in documentation such example of usage:

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);
 }

So I have my *.wav file which data of header looks like this:

Chunk name: RIFF

File size: 31636640

File format: WAVE

Sub chunk id: fmt

Sub chunk size: 16

Compression format: 1

Channels: 1

Sample rate: 44100

Byte rate: 88200

Block align: 2

Bits per sample: 16

Sub chunk id: data

Sub chunk size: 31636604

And I insert it to this examplary function as FILE should be inserted to input from what I understand. I get something on output but I can't play it. I do it like that:

FILE *fInput =fopen(wavFile0.filePath,"rb");
FILE *fOutput  =  fopen ("myTestFile.wav", "wb");

 resampleIPP(44100, 8000, fInput, fOutput);

fclose(fInput);
fclose((fOutput);

By investigating file structure I can say for sure that something has happened with header of the file. Would that mean that I have to insert only vector of data located under sub chunk with id "data" and then after resampleIPP function resamples my data then append it to new header?

I am using IPP 7.1
 

I have a C++ project  using Intel Compile, this project is called A.
This A project have 2 functions ( X& Y). Output of A project is dll and export 2 functions.
I have another C# project which imports 2 functions (X&Y) of A project, the project is called B.
The B project calls X function, doesn't call Y function. 

While executing B project, a bug occurred. The bug caused changing the default value of float.Epsilon from 1.401298E-45 to zero. It seem lose last bit mantissa of float.epsilon.
When I remove Y function from A project, B project will execute normally.
The Y function of A project  has only 1 line code to allocate memory by using ippsMalloc_64f function.
I don't know root cause of this bug. Could you please help me?

Hi,

I just installed the evaluation of IPP from INDE, and I can see the .h files,  and the .lib files, but I cannot see the .DLL files.

I searched, and they do not appear on my disk.

Are they installed with the evaluation?

How do I get the IPP DLL files for evaluation?

Have the DLL files been removed from 8.x ? Where is this documented?

Thanks in advance.

Here is the heirarchy I see:

C:\Intel\INDE\ipp_8.2.1.012\Android 
C:\Intel\INDE\ipp_8.2.1.012\Documentation 
C:\Intel\INDE\ipp_8.2.1.012\Windows 
C:\Intel\INDE\ipp_8.2.1.012\Android\Documentation 
C:\Intel\INDE\ipp_8.2.1.012\Android\x64 
C:\Intel\INDE\ipp_8.2.1.012\Android\x86 
C:\Intel\INDE\ipp_8.2.1.012\Android\Documentation\en_US 
C:\Intel\INDE\ipp_8.2.1.012\Android\Documentation\en_US\ipp 
C:\Intel\INDE\ipp_8.2.1.012\Android\Documentation\en_US\ipp\ipp_manual 
C:\Intel\INDE\ipp_8.2.1.012\Android\Documentation\en_US\ipp\ipp_resources 
C:\Intel\INDE\ipp_8.2.1.012\Android\Documentation\en_US\ipp\ipp_userguide 
C:\Intel\INDE\ipp_8.2.1.012\Android\Documentation\en_US\ipp\ipp_manual\Resources 
C:\Intel\INDE\ipp_8.2.1.012\Android\Documentation\en_US\ipp\ipp_userguide\Resources 
C:\Intel\INDE\ipp_8.2.1.012\Android\x64\ipp 
C:\Intel\INDE\ipp_8.2.1.012\Android\x64\ipp\examples 
C:\Intel\INDE\ipp_8.2.1.012\Android\x64\ipp\include 
C:\Intel\INDE\ipp_8.2.1.012\Android\x64\ipp\lib 
C:\Intel\INDE\ipp_8.2.1.012\Android\x64\ipp\lib\intel64_android 
C:\Intel\INDE\ipp_8.2.1.012\Android\x86\ipp 
C:\Intel\INDE\ipp_8.2.1.012\Android\x86\ipp\examples 
C:\Intel\INDE\ipp_8.2.1.012\Android\x86\ipp\include 
C:\Intel\INDE\ipp_8.2.1.012\Android\x86\ipp\lib 
C:\Intel\INDE\ipp_8.2.1.012\Android\x86\ipp\lib\ia32_android 
C:\Intel\INDE\ipp_8.2.1.012\Documentation\en_US 
C:\Intel\INDE\ipp_8.2.1.012\Windows\Documentation 
C:\Intel\INDE\ipp_8.2.1.012\Windows\x64 
C:\Intel\INDE\ipp_8.2.1.012\Windows\x86 
C:\Intel\INDE\ipp_8.2.1.012\Windows\Documentation\en_US 
C:\Intel\INDE\ipp_8.2.1.012\Windows\Documentation\en_US\ipp 
C:\Intel\INDE\ipp_8.2.1.012\Windows\Documentation\en_US\ipp\ipp_manual 
C:\Intel\INDE\ipp_8.2.1.012\Windows\Documentation\en_US\ipp\ipp_userguide 
C:\Intel\INDE\ipp_8.2.1.012\Windows\Documentation\en_US\ipp\ipp_manual\Resources 
C:\Intel\INDE\ipp_8.2.1.012\Windows\Documentation\en_US\ipp\ipp_userguide\Resources 
C:\Intel\INDE\ipp_8.2.1.012\Windows\x64\ipp 
C:\Intel\INDE\ipp_8.2.1.012\Windows\x64\ipp\examples 
C:\Intel\INDE\ipp_8.2.1.012\Windows\x64\ipp\include 
C:\Intel\INDE\ipp_8.2.1.012\Windows\x64\ipp\lib 
C:\Intel\INDE\ipp_8.2.1.012\Windows\x64\ipp\lib\intel64 
C:\Intel\INDE\ipp_8.2.1.012\Windows\x86\ipp 
C:\Intel\INDE\ipp_8.2.1.012\Windows\x86\ipp\examples 
C:\Intel\INDE\ipp_8.2.1.012\Windows\x86\ipp\include 
C:\Intel\INDE\ipp_8.2.1.012\Windows\x86\ipp\lib 
C:\Intel\INDE\ipp_8.2.1.012\Windows\x86\ipp\lib\ia32 

I am modifying an existing code that  changes an image size using interpolation with two-parameter cubic filters. Current implementation is in 32 bits. I am implementing it for 64 bit. 32 bit implementation use methods ippiResizeCubic_32f_C1R, ippiResizeCubicInit_32f for resizing. I need their 64 bit equivalents. But documentation in links https://software.intel.com/en-us/node/504372 and https://software.intel.com/en-us/node/504360 shows that their 64 bit is not available. What are the methods that I can use for replacing these methods? Any example will be of great help.

Hi,

I'm currently checking IPP 8 and it is saying that many functions related to memory allocation are deprecated. I understand the point, so I'm checking the ways to get the memory allocations done. 

PROBLEM:

int sz;
ippsIIRGetStateSize_BiQuad_32f(1, &sz); => 4576!!!
ippsIIRGetStateSize_BiQuad_64f(1, &sz); => 8560!!!
ippsIIRGetStateSize64f_BiQuad_32f(1, &sz); => 16752!!!

I just don't understand. I want a single biquad IIR filter, where the state is technically 2 numbers, hence 8 bytes for 32-bit floats. If it stores something to fill the XMM registers, plus lots of precomputed stuff from the 6 arguments an IIR filter technically has, we can get to say 64 bytes, I'd survive even 256 thinking that it is really storing lots of stuff. But 4576 bytes??? That honestly looks like a bug.

What am I missing?

ADDITIONAL QUESTION: Does this memory need to be allocated dynamically in a special buffer using ippMalloc or something? Or can we just place it in some other function? Is it possible to preestimate its maximum size, so we can avoid the allocations totally by placing it into our own structures?

Hello,

I want to impelment fast 1D Box Blur on an image.
I saw IPP's function 'SumWindowColumns' and 'SumWindowRow':

https://software.intel.com/en-us/node/504126
https://software.intel.com/en-us/node/504125

I was wondering, do they have efficient implementation which is independent of the Kernel Size?
This could be done using Integral Images or the trick to add a pixel and remove one.

Moreover, could you add a feature to have Weight per window?
Why doesn't the function support 32f type of images?

Thank You.

Hi,

I'm currently investigating IPP 8 and have a few problems with the biquad IIR support:

- ippsIIRInitAlloc is now deprecated, fine by me, we can allocate manually. However I need to be able to changes the IIR taps WITHOUT changing the filter state. ippsIIRInit seems to destroy the delay line, which makes it unusable. So the only way to change taps without using deprecated functions is to copy the delay line and set it back with ippsIIRInit, which is unacceptable. So what am I missing?

- In many cases I use multiple instances of the same filter - same taps, but used on multiple signals. Right now it seems I need to allocate the IppsIIRState for each of the signals, which means duplicate the taps. It's always just a single biquad, so no big deal, but...

- The requested "new" method using ippMalloc and ippsIIRInit made me check the sizes of the IppsIIRState structures and these are HUGE - like over 4k for a single biquad filter! For 1000 filters that makes 4MB, that looks hardly efficient, especially since I need just a single biquad, so state structure of "2 numbers" (plus taps, plus anything for optimizations, but that could hardly be 4k). Am I missing something or is it a bug?

Thanks in advance!

Hello,

Given an Image how can I apply an IIR filter on it using Intel IPP?
What would be the fastest way?

The image is 32 Bit Float and I want the output to be 32 Bit float as well.

Thank You.

This question may have been asked before, but it's kinda hard to find something using the combination of IPP and Library...

I need to build a Windows library (.lib) for someone and I'm using XE2015 with IPP 8.2. I have built the library here, with 'Using Intel IPP' set to 'Single Threaded Static Library'. I also made a small program to test it, which also needs 'Using Intel IPP' set to the same value, and that works fine.

Now, the person who's going to use it is using Visual Studio 6 with IPP 5.0. And he's getting a linker error: LINK : fatal error LNK1104: cannot open file "C:\Program Files (x86)\Intel\Composer XE 2015\ipp\include\ippcore.h/../../lib/ia32/ippcoremt.lib"

Previously, when I was still using Intel C++ 11.1 with IPP 7.1, he could use my library without any issues (well there were a few, but they were easy to fix). Beside having him install the newest IPP, which would probably cause problems for his own code, and creating a DLL instead, are there any other options to make this work?

hi

i have a system with 15 -750 cpu and windows 8.1 and I use IPP8.2 .

my program have a greate number Array Mul ,Div or sqrt.

i write a small code with ipp and use both ippm and ipps for mul array and compare that code performance with my simple array mul.

my code is this:

/-------------------------------------------------------------

    Ipp64f* src=new Ipp64f[200]();
    for(int i=0;i<200;i++)
    {
        src[i]=i; // initialize source array with values
    }
    Ipp64f* res=new Ipp64f[200]();

    double t1=GetTickCount();
    for(int k=0;k<5000000;k++)
    {
        ippsMulC_64f(src,2,res,200);
    }
    double t2=GetTickCount();

    double Ipp_Mul_Time=t2-t1;

    for(int k=0;k<5000000;k++)
    {
        for(int i=0;i<200;i++)
        {
            res[i]=src[i]*2;
        }
    }
    double t3=GetTickCount();
  
    double MyMulTime=t3-t2;

//------------------------------------------------------------------------------------

i run this test program and in every test my simple Mul is faster than IPP Mul

i test this program for both small and big arrays and get same result.

i think that i can improve my progarm performance with intel ipp but it happend.

is exist a problem in my test code that lead to this abnormal behavor? or my test result is correct?

Parallel Image Processing in OpenMP - Image Blocks

Hello,
I'm doing my first steps in the OpenMP world.

I have an image I want to apply a filter on.
Since the image is large I wanted to break it into blocks and apply the filter on each independently in parallel.
Namely, I'm creating 4 images I want to have different threads.

I'm using Intel IPP for the handling of the images and the function to apply on each sub image.

I described the code here:

http://stackoverflow.com/questions/29319226/parallel-image-processing-in...

The problem is I tried both sections and parallel for and got only 20% improvement.

What am I doing wrong?
How can I tell each "Worker" that though data is taken from the same array, it is safe to read (Data won't change) and write (Each worker has exclusive approach to its part of the result image).

Thank You.

Hello,

I was re-writing Matlab DSP algorithm to C++ and managed to receive almost the same result. But Matlab is using double data type by default and thanks to that result is slightly better. Small difference between Matlab code and my code appears because of resampling function (I've checked everything for sure very small difference appears after resampling). So as ippsResamplePolyphase has only 16s and 32f constructors I am forced to convert my double data to float which causes loss of data. I wouldn't mind buying newest IPP, but I see that there is also only 32f ippsResamplePolyphase function.

My question is: It there is any method that would allow me to perform ippsResamplePolyphase on 64f (double) data? (Matlab is using polyphase implementation too - and because of that my result is almost perfect, but I would like to make it perfect)

What I am using currently:

•  IPP 7.1 in C++ code:

(link to documentation of IPP 7.1 - https://software.intel.com/sites/products/documentation/doclib/iss/2013/ipp/ipp_manual/IPPS/ipps_ch6/functn_ResamplePolyphase.htm)

 

IppStatus ippsResamplePolyphaseFixed_32f(const Ipp32f* pSrc, int len, Ipp32f* pDst, Ipp32f norm, Ipp64f* pTime, int* pOutlen, const IppsResamplingPolyphaseFixed_32f* pSpec);

• Matlab R2014a uses this:

(link to documentation - http://www.mathworks.com/help/signal/ref/resample.html)

 

resample - Change the sampling rate of a signal.

Y = resample(X,P,Q) resamples the sequence in vector X at P/Q times
the original sample rate using a polyphase implementation.  Y is P/Q
times the length of X (or the ceiling of this if P/Q is not an integer).  
P and Q must be positive integers.
 
resample applies an anti-aliasing (lowpass) FIR filter to X during the
resampling process, and compensates for the filter's delay.  The filter
is designed using FIRLS.  resample provides an easy-to-use alternative
to UPFIRDN, relieving the user of the need to supply a filter or
compensate for the signal delay introduced by filtering.
 
In its filtering process, resample assumes the samples at times before

and after the given samples in X are equal to zero. Thus large
deviations from zero at the end points of the sequence X can cause
inaccuracies in Y at its end points.

Hello IPP Team 

in the new release notes you writte:

Intel IPP 8.2 provides a lot of new APIs for one-dimensional (signal processing) and two-dimensional (image processing) functions that support external threading (processing by independent tiles). Several Intel IPP functions combined into a single pipeline that is threaded externally at the application level are significantly more efficient from the performance and power consumption point of view than the sequential call of internally threaded variant of the same functions.

Do these APIs only include the described TBB external multithreading with image tiles (for image processing)? Or is this feature something more advanced? Can you please say a couple of words about these APIs? What options do we have now for external threading?

Best

Intel® IPP 9.0 Beta is now available.  The release added the new Intel® AVX-512 optimization for the computer vision and image processing functions, extended optimization for Intel® Atom™ and Intel® Quark™ processors, added the new APIs to support external threading, and provided the custom dynamic library building tool, which enables users to build the dynamic library containing the selected Intel® IPP functions.
 
We also provide some options on the deprecated IPP functions.  Please find more information on Intel IPP 9.0 Beta release note

Intel IPP 9.0 beta release is available as a part of the Intel Parallel Studio XE 2016 Beta now. To sign up for the Intel Parallel Studio XE 2016 Beta, visit this page.

Your feedback and question is welcome during your evaluation.